/home/fwph/code/wurde/rde/mcp/mcp.H

Go to the documentation of this file.

#ifndef MCP_H
#define MCP_H

#include <CommsManager.H>
#include <Logger.H>
#include <Heartbeat.H>
#include <MCPControl.H>
#include <unistd.h>
#include <string>
#include <errno.h>
#include <vector>

namespace MCP {

       struct Mapping {
              std::string object;
              std::string source;
              std::string interface;
       };

       class Module {
              
       public:
              Module(std::string name);
              
              Module(WURDE::HeartbeatInfoStruct &info);
              Module(WURDE::HeartbeatDataStruct &data);
              
              bool stale();
              
              WURDE::RunState getState(){return m_state;};
              WURDE::ProcessLocale getLocale(){return m_locale;};
              WURDE::ProcessType getType(){return m_managedType;};
              string getModuleName(){return m_moduleName;};
              string getBinary(){return m_binary;};
              
              void setState(WURDE::RunState somestate){m_state=somestate;};
              void setLocale(WURDE::ProcessLocale somelocale){m_locale=somelocale;};
              void setType(WURDE::ProcessType sometype){m_managedType=sometype;};
              void setTTL(double seconds);
              void setModuleName(std::string name){WURDE::g_logdebug << "Old name: " << m_moduleName << " new name: " << name << endl; m_moduleName=name;};
              void setBinary(std::string bin){m_binary=bin;};
              //              void setCommandLineOptions(std::string options){m_options=options;}
              void addCommandLineOption(std::string option){m_options.push_back(option);}
              void addInterface(std::string interface){addInterface(interface,"Unknown");};
              void addInterface(std::string interface, std::string name);
              //              void addInterface(string interface){m_interfaces.push_back(interface);};
      
              bool beat(WURDE::HeartbeatDataStruct beat);
              bool refresh(WURDE::HeartbeatInfoStruct info);

              std::string findObjectMapping(std::string object, std::string interface, WURDE::ConnectionStrategy strat);

              void setMappings(std::vector<Mapping> mappings){m_mappings=mappings;};
              bool hasSupplier(std::string streamname,std::string type);
              bool startUp(WURDE::CommsManager &myManager, std::string someArgs);

              int m_attemptedStarts;
              int m_maxAttempts;              

       protected:
              Module();
       private:
              WURDE::Time m_lastTimestamp;
              struct timeval m_TTL;
              WURDE::RunState m_state;
              WURDE::ProcessType m_managedType;
              WURDE::ProcessLocale m_locale;
              std::string m_moduleName;
              std::string m_binary;
              std::vector<std::string> m_options;
              std::vector<WURDE::InterfaceStream> m_interfaces;
              std::vector<Mapping> m_mappings;
              std::vector<Mapping> m_occupiedResources; 
              pid_t m_process;
       };
       
       //assorted functions
       
       std::vector<Module> parseConfigFile(std::string config);
       std::vector<Module> parseMapFile(std::string config,std::vector<Module> &theModules);
}

#endif

---