root/ossiedev/branches/jeongo9/components/liquid-components/src/PacketSource.cpp @ 10566

/****************************************************************************

Copyright 2010 by your_name_or_organization, all rights reserved.

****************************************************************************/


#include <cstdio>
#include <string>
#include <iostream>

#include "config.h"
#include "PacketSource.h"

// include main.cpp (must define COMPONENT_OBJECT)
#define  COMPONENT_OBJECT PacketSource_i
#include "main.cpp"

PacketSource_i::PacketSource_i(const char *uuid, omni_condition *condition) :
    Resource_impl(uuid), component_running(condition)
{
    packetHeaderDataOut = new standardInterfaces_i::realChar_u("HeaderDataOut");
    packetPayloadDataOut = new standardInterfaces_i::realChar_u("PayloadDataOut");

    header_len = 24;
    payload_len = 64;
    verbose = true;
    packet_delay = 1000;

    packet_id = 0;
}

PacketSource_i::~PacketSource_i(void)
{
    delete packetHeaderDataOut;
    delete packetPayloadDataOut;
}

// Static function for omni thread
void PacketSource_i::Run( void * data )
{
    ((PacketSource_i*)data)->ProcessData();
}

CORBA::Object_ptr PacketSource_i::getPort( const char* portName ) throw (
    CORBA::SystemException, CF::PortSupplier::UnknownPort)
{
    DEBUG(3, PacketSource, "getPort() invoked with " << portName)

    CORBA::Object_var p;

    p = packetHeaderDataOut->getPort(portName);

    if (!CORBA::is_nil(p))
        return p._retn();

    p = packetPayloadDataOut->getPort(portName);

    if (!CORBA::is_nil(p))
        return p._retn();

    /*exception*/
    throw CF::PortSupplier::UnknownPort();
}

void PacketSource_i::start() throw (CORBA::SystemException,
    CF::Resource::StartError)
{
    DEBUG(3, PacketSource, "start() invoked")
    omni_mutex_lock  l(processing_mutex);
    if( false == thread_started )
    {
        thread_started = true;
        // Create the thread for the writer's processing function
        processing_thread = new omni_thread(Run, (void *) this);

        // Start the thread containing the writer's processing function
        processing_thread->start();
    }
}

void PacketSource_i::stop() throw (CORBA::SystemException, CF::Resource::StopError)
{
    DEBUG(3, PacketSource, "stop() invoked")
    omni_mutex_lock l(processing_mutex);
    thread_started = false;
}

void PacketSource_i::releaseObject() throw (CORBA::SystemException,
    CF::LifeCycle::ReleaseError)
{
    DEBUG(3, PacketSource, "releaseObject() invoked")

    component_running->signal();
}

void PacketSource_i::initialize() throw (CF::LifeCycle::InitializeError,
    CORBA::SystemException)
{
    DEBUG(3, PacketSource, "initialize() invoked")
}

void PacketSource_i::query( CF::Properties & configProperties ) throw (CORBA::SystemException, CF::UnknownProperties)
{
    if( configProperties.length() == 0 )
    {
        configProperties.length( propertySet.length() );
        for( unsigned int i = 0; i < propertySet.length(); i++ )
        {
            configProperties[i].id = CORBA::string_dup( propertySet[i].id );
            configProperties[i].value = propertySet[i].value;
        }
        return;
    } else {
        for( unsigned int i = 0; i < configProperties.length(); i++ ) {
            for( unsigned int j = 0; j < propertySet.length(); j++ ) {
                if( strcmp(configProperties[i].id, propertySet[i].id) == 0 ) {
                    configProperties[i].value = propertySet[i].value;
                }
            }
        }
    } // end if-else
}

void PacketSource_i::configure(const CF::Properties& props)
throw (CORBA::SystemException,
    CF::PropertySet::InvalidConfiguration,
    CF::PropertySet::PartialConfiguration)
{
    DEBUG(3, PacketSource, "configure() invoked")

    static int init = 0;
    if( init == 0 ) {
        if( props.length() == 0 ) {
            std::cout << "PacketSource::configure() called with invalid props.length - " << props.length() << std::endl;
            return;
        }
        propertySet.length(props.length());
        for( unsigned int j=0; j < props.length(); j++ ) {
            propertySet[j].id = CORBA::string_dup(props[j].id);
            propertySet[j].value = props[j].value;
        }
        init = 1;
    }

    std::cout << "PacketSource::configure(), props length : " << props.length() << std::endl;

    for ( unsigned int i = 0; i <props.length(); i++) {
        std::cout << "PacketSource::configure(), property id : " << props[i].id << std::endl;

        if (strcmp(props[i].id, "DCE:27ffa4d2-0f35-11df-baab-001aa089d644") == 0) {
            // header_len (number of bytes in header)
            CORBA::Short simple_temp;
            props[i].value >>= simple_temp;
            header_len = simple_temp;
            std::cout << "  PacketSource::configure(), header_len = " << header_len << std::endl;
            for( unsigned int k = 0; k < propertySet.length(); k++ ) {
                if( strcmp(propertySet[k].id, props[i].id) == 0 ) {
                    propertySet[i].value = props[i].value;
                    break;
                }
            }
        } else if (strcmp(props[i].id, "DCE:3320e0ba-0f35-11df-baab-001aa089d644") == 0) {
            // payload_len (number of bytes in payload)
            CORBA::Short simple_temp;
            props[i].value >>= simple_temp;
            payload_len = simple_temp;
            std::cout << "  PacketSource::configure(), payload_len = " << payload_len << std::endl;
            for( unsigned int k = 0; k < propertySet.length(); k++ ) {
                if( strcmp(propertySet[k].id, props[i].id) == 0 ) {
                    propertySet[i].value = props[i].value;
                    break;
                }
            }
        } else if (strcmp(props[i].id, "DCE:45ce96c6-0f35-11df-baab-001aa089d644") == 0) {
            // verbose?
            CORBA::Boolean simple_temp;
            props[i].value >>= simple_temp;
            verbose = simple_temp;
            std::cout << "  PacketSource::configure(), verbose = " << verbose << std::endl;
        } else if (strcmp(props[i].id, "DCE:908059a9-6632-4bc6-8e95-aec06fed3244") == 0) {
            // packet delay (ms)
            CORBA::Short simple_temp;
            props[i].value >>= simple_temp;
            packet_delay = simple_temp;
            std::cout << "  PacketSource::configure(), packet_delay(ms) = " << packet_delay << std::endl;
        } else {
            std::cerr << "PacketSource::configure() : invalid property" << std::endl;
            throw CF::PropertySet::InvalidConfiguration();
        }
    }
}

void PacketSource_i::ProcessData()
{
    DEBUG(3, PacketSource, "ProcessData() invoked")

    // TODO : wait for component to be configured before actually starting

    PortTypes::CharSequence headerData;
    PortTypes::CharSequence payloadData;

    // define lengths
    headerData.length(header_len);
    payloadData.length(payload_len);
    while(continue_processing())
    {
        // wait some time between each packet
        usleep(packet_delay*1000);

        // generate header data (packet id)
        unsigned int i;
        for (i=0; i<header_len; i++)
            headerData[i] = (i == 0) ? packet_id & 0xff : 0;
        for (i=0; i<payload_len; i++)
            payloadData[i] = rand() & 0xff;

        if (verbose) {
            printf("PacketSource generating packet [%4u] %4u bytes\n",
                    packet_id,
                    payload_len);
        }

        // only push header if length is greater than zero
        if (header_len > 0)
            packetHeaderDataOut->pushPacket(headerData);

        packetPayloadDataOut->pushPacket(payloadData);

        packet_id++;
        packet_id &= 0xff; // for now strip id to only last 8 bits
    }
}

bool PacketSource_i::continue_processing()
{
    omni_mutex_lock l(processing_mutex);
    return thread_started;
}