jaus++/2.0/src/jaus/core/component.cpp

Go to the documentation of this file.

#include "jaus/core/component.h"
#include "jaus/core/transport/judp.h"
#include "jaus/core/transport/jtcpclient.h"
#include "jaus/core/sensor.h"
#include <tinyxml/tinyxml.h>
#include <iostream>
#include <cstdlib>
#include <time.h>

using namespace JAUS;

Component::Component()
{
    mInitializedFlag = false;
    mCheckServiceTimer.RegisterTimerEvent(Component::CheckServiceStatusEvent, this);
    mCheckCoreServicesTimer.RegisterTimerEvent(Component::CheckCoreServicesStatusEvent, this);
    mCoreServicesCheckTimeMs = 0;
    mCoreServicesCheckTimeMs = 0;
    mServices[Transport::Name] = mpTransportService = new JUDP();
    //mServices[Transport::Name] = mpTransportService = new JTCPClient();

    mpEventsService = new Events();
    mpLivenessService = new Liveness();
    mpDiscoveryService = new Discovery();
    mpAccessControlService = new AccessControl();
    mpManagementService = new Management();
    mpTimeService = new TimeService();

    AddService(mpEventsService);
    AddService(mpLivenessService);
    AddService(mpDiscoveryService);
    AddService(mpAccessControlService);
    AddService(mpManagementService);
    AddService(mpTimeService);
}


Component::~Component()
{    
    Shutdown();
    mCheckCoreServicesTimer.Stop();
    if(mCheckServiceTimer.IsActive())
    {
        // Stop checking services.
        mCheckServiceTimer.Stop();
        // Shutdown the Transport Service.
        mpTransportService->RecursiveShutdown();
        mpTransportService->Shutdown();
    }
    Service::Map::iterator s;
    
    s = mServices.find(Transport::Name);
    if(s != mServices.end())
    {
        delete s->second;
        mServices.erase(s);
    }
    
    mpTransportService = NULL;
    
    for(s = mServices.begin();
        s != mServices.end();
        s++)
    {
        delete s->second;
    }
    mServices.clear();    
    mServiceCheckTimeMs = 0;
    mInitializedFlag = false;
    mComponentID(0, 0, 0);
}


bool Component::Initialize(const Address& id, const double serviceUpdateFrequency)
{
    bool result = false;
    
    Shutdown();
    // Check to see if the ID is locked on the local host.
    CxUtils::MappedMemory mappedMem;
    if(mLockID.CreateMappedMemory(std::string("JAUS") + id.ToString(), 256) == 0)
    {
        // ID is in use, exit.
        return false;
    }
   
    mComponentID = id;
    if(DiscoveryService()->IsEnabled() && DiscoveryService()->GetSubsystemIdentification().empty())
    {
        std::cout << "Component::ERROR - Subsystem Identification Not Set.\n";
        return false;
    }
    if(mpTransportService->Initialize(id))
    {
        
        if(serviceUpdateFrequency >= 1.0)
        {
            std::stringstream str;
            str << "JSRVC Check 2 - " << mComponentID.ToString();
            mCheckServiceTimer.SetName(str.str());
            mCheckServiceTimer.Start(serviceUpdateFrequency);
        }
        
        std::stringstream str;
        str << "JSRVC Check 1 - " << mComponentID.ToString();
        mCheckCoreServicesTimer.SetName(str.str());
        mCheckCoreServicesTimer.Start(10);
        mInitializedFlag = result = true;
        Service::Map::iterator s;
        for(s = mServices.begin();
            s != mServices.end();
            s++)
        {
            if(s->second != mpTransportService)
            {
                s->second->Initialize();
            }
        }
        ManagementService()->SetStatus(Management::Status::Standby);
    }

    return result;
}


bool Component::InitializeWithUniqueID(const unsigned int waitTimeMs,
                                       const double serviceUpdateFrequency)
{
    CxUtils::IP4Address::List available;
    if(CxUtils::Socket::GetHostAddresses(available) && available.size() > 0)
    {
        JAUS::Address unique((JAUS::UShort)(available[0].mData[3] + 10000), 1, 1);
        if(Initialize(unique, serviceUpdateFrequency))
        {
            return true;
        }
        for(int c = 254; c > 0; c--)
        {
            for(int n = 254; n > 0; n--)
            {
                if(Address::IsReservedComponentID((JAUS::Byte)c) == false)
                {
                    unique.mNode = (JAUS::Byte)n;
                    unique.mComponent = (JAUS::Byte)c;
                    if(Initialize(unique, serviceUpdateFrequency))
                    {
                        return true;
                    }
                }
            }
        }
    }

    return false;
}


bool Component::LoadSettings(const std::string& filename)
{
    if(mInitializedFlag == false)
    {
        TiXmlDocument xml;
        Service::Map::iterator s;

        if(xml.LoadFile(filename.c_str()) == false)
        {
            return false;
        }
        TiXmlHandle doc(&xml);
        
        TiXmlElement* transportService = doc.FirstChild("JAUS").FirstChild("Transport").ToElement();
        if(transportService && transportService->Attribute("type"))
        {
            if(std::string("JUDP") == transportService->Attribute("type"))
            {
                this->AddService(new JUDP());
            }
            else if(std::string("JTCP") == transportService->Attribute("type"))
            {
                this->AddService(new JTCPClient());
            }
        }
        TiXmlElement* service = doc.FirstChild("JAUS").ToElement();
        if(service && service->FirstChildElement())
        {
            service = service->FirstChildElement();
        }
        while(service)
        {
            std::string name = service->Value();
            for(s = mServices.begin(); s != mServices.end(); s++)
            {
                if(strstr(s->first.c_str(), name.c_str()) != NULL)
                //s = mServices.find(name);
                //if(s != mServices.end())
                {
                    if(s->first != Transport::Name && 
                       service->Attribute("on") && 
                       atoi(service->Attribute("on")) == 0)
                    {
                        s->second->EnableService(false);
                    }
                    else if(s->second->LoadSettings(filename) == false)
                    {
                        return false;
                    }

                }
            }
            service = service->NextSiblingElement();
        }

        return true;
    }
    return false;
}


void Component::Shutdown()
{
    if(IsInitialized())
    {
        mLockID.CloseMappedMemory();

        mInitializedFlag = false; // Stops checking services.
        
        // Tell services to shutdown.
        Service::Map::iterator s;
        for(s = mServices.begin();
            s != mServices.end();
            s++)
        {
            s->second->SignalServiceToShutdown();
        }
        
        AccessControlService()->ReleaseComponentControl(Address());
        EventsService()->CancelSubscription(Address(), 0);
        // Actually shutdown the services (from Transport down).
        mpTransportService->RecursiveShutdown();
        mServiceCheckTimeMs = 0;
        mComponentID(0, 0, 0);
        CxUtils::SleepMs(250);
        // Stop timers.
        mCheckCoreServicesTimer.Stop();
        mCheckServiceTimer.Stop();
    }
}


Events* Component::EventsService()
{
    return mpEventsService;
}


Liveness* Component::LivenessService()
{
    return mpLivenessService;
}


Discovery* Component::DiscoveryService()
{
    return mpDiscoveryService;
}


AccessControl* Component::AccessControlService()
{
    return mpAccessControlService;
}


Management* Component::ManagementService() 
{
    return mpManagementService;
}


TimeService* Component::GetTimeService()
{
    return mpTimeService;
}


const Events* Component::EventsService() const
{
    return mpEventsService;
}


const Liveness* Component::LivenessService() const
{
    return mpLivenessService;
}


const Discovery* Component::DiscoveryService() const
{
    return mpDiscoveryService;
}


const AccessControl* Component::AccessControlService() const
{
    return mpAccessControlService;
}


const Management* Component::ManagementService() const
{
    return mpManagementService;
}


const TimeService* Component::GetTimeService() const
{
    return mpTimeService;
}


bool Component::Send(const Message* message, const int broadcastFlags) const
{
    return mpTransportService->Send(message, broadcastFlags);
}


bool Component::Send(const Message* message, 
                     Message* response, 
                     const unsigned int waitTimeMs) const
{
    return mpTransportService->Send(message, response, waitTimeMs);
}


bool Component::EnableService(const std::string& name, const bool enable)
{
    Service::Map::iterator s;
    s = mServices.find(name);
    if(s != mServices.end())
    {
        s->second->EnableService(enable);
        return true;
    }
    return false;
}


bool Component::AddService(Service* service)
{
    bool result = false;

    if(mInitializedFlag == false)
    {
        Service::Map::iterator s;
        s = mServices.find(service->GetServiceID().mName);
        if(s == mServices.end())
        {
            mServices[service->GetServiceID().mName] = service;
        }
        else
        {
            delete s->second;
            s->second = service;
        }
        // Now attach services that inherit from each other.
        for(s = mServices.begin();
            s != mServices.end();
            s++)
        {
            if(service->InheritsFrom(s->second->GetServiceID()))
            {
                service->SetParentService(s->second);
                s->second->AddChildService(service);
            }
            if(s->second->InheritsFrom(service->GetServiceID()))
            {
                s->second->SetParentService(service);
                service->AddChildService(s->second);
            }
        }
        // Update Transport Service pointer.
        Transport* t = dynamic_cast<Transport *>(service);
        if(t)
        {
            mpTransportService = t;
        }
        // Make sure all services have a pointer to the Component and Transport
        if(mpTransportService)
        {
            mpTransportService->SetComponent(this);
        }
        result = true;
    }
    return result;
}


Service* Component::GetService(const std::string& name)
{
    Service::Map::iterator s;
    s = mServices.find(name);
    if(s != mServices.end())
    {
        return s->second;
    }
    // Try find the closest match.
    for(s = mServices.begin(); s != mServices.end(); s++)
    {
        if(strstr(s->first.c_str(), name.c_str()) != NULL)
        {
            return s->second;
        }
    }
    return NULL;
}


const Service* Component::GetService(const std::string& name) const
{
    Service::Map::const_iterator s;
    s = mServices.find(name);
    if(s != mServices.end())
    {
        return s->second;
    }
    // Try find the closest match.
    for(s = mServices.begin(); s != mServices.end(); s++)
    {
        if(strstr(s->first.c_str(), name.c_str()) != NULL)
        {
            return s->second;
        }
    }
    return NULL;
}


Service::ID::List Component::GetServiceList() const
{
    Service::ID::List result;
    Service::Map::const_iterator s;
    for(s = mServices.begin();
        s != mServices.end();
        s++)
    {
        if(s->second->IsEnabled())
        {
            result.push_back(s->second->GetServiceID());
        }
    }
    return result;
}

Service::ID::Set Component::GetServiceSet() const
{
    Service::ID::Set result;
    Service::Map::const_iterator s;
    for(s = mServices.begin();
        s != mServices.end();
        s++)
    {
        if(s->second->IsEnabled())
        {
            result.insert(s->second->GetServiceID());
        }
    }
    return result;
}


void Component::CheckServiceStatusEvent(void* args)
{
    Component* component = (Component *)args;
    if(component->mInitializedFlag)
    {
        Service::Map::iterator s;
        for(s = component->mServices.begin();
            s != component->mServices.end() && component->mInitializedFlag;
            s++)
        {
            if(s->second != component->mpEventsService && 
               s->second != component->mpLivenessService &&
               s->second != component->mpDiscoveryService &&
               s->second != component->mpAccessControlService &&
               s->second != component->mpManagementService &&
               s->second != component->mpTimeService &&
               s->second != component->mpTransportService)
            {
                s->second->CheckServiceStatus((unsigned int)(Time::GetUtcTimeMs() - component->mServiceCheckTimeMs));
                Sensor* sensor = dynamic_cast<Sensor *>(s->second);
                if(sensor)
                {
                    sensor->CheckServiceSynchronization((unsigned int)(Time::GetUtcTimeMs() - component->mServiceCheckTimeMs));
                }
            }
        }
        component->mServiceCheckTimeMs = Time::GetUtcTimeMs();
    }
}


void Component::CheckCoreServicesStatusEvent(void* args)
{
    Component* component = (Component *)args;
    if(component->mInitializedFlag)
    {
        component->mpTransportService->CheckServiceStatus((unsigned int)(Time::GetUtcTimeMs() - component->mCoreServicesCheckTimeMs));
        component->mpEventsService->CheckServiceStatus((unsigned int)(Time::GetUtcTimeMs() - component->mCoreServicesCheckTimeMs));
        component->mpLivenessService->CheckServiceStatus((unsigned int)(Time::GetUtcTimeMs() - component->mCoreServicesCheckTimeMs));
        component->mpDiscoveryService->CheckServiceStatus((unsigned int)(Time::GetUtcTimeMs() - component->mCoreServicesCheckTimeMs));
        component->mpAccessControlService->CheckServiceStatus((unsigned int)(Time::GetUtcTimeMs() - component->mCoreServicesCheckTimeMs));
        component->mpManagementService->CheckServiceStatus((unsigned int)(Time::GetUtcTimeMs() - component->mCoreServicesCheckTimeMs));
        component->mpTimeService->CheckServiceStatus((unsigned int)(Time::GetUtcTimeMs() - component->mCoreServicesCheckTimeMs));

        component->mCoreServicesCheckTimeMs = Time::GetUtcTimeMs();
    }
}


void Component::PrintStatus() const
{
    Service::Map::const_iterator service;

    std::cout << "========================================================================\n";
    std::cout << "Component Status [" << GetComponentID().ToString() << "]" << std::endl;
    for(service = mServices.begin();
        service != mServices.end();
        service++)
    {
        std::cout << service->second->GetServiceID().ToString() << std::endl;
        service->second->PrintStatus();
    }
}


/*  End of File */