void start(BundleContext::Ptr pContext)
{
_pContext = pContext;
_pPrefs = ServiceFinder::find<PreferencesService>(pContext);
Poco::Util::AbstractConfiguration::Keys keys;
_pPrefs->configuration()->keys("serial.ports", keys);
int index = 0;
for (std::vector<std::string>::const_iterator it = keys.begin(); it != keys.end(); ++it)
{
std::string baseKey = "serial.ports.";
baseKey += *it;
std::string device = _pPrefs->configuration()->getString(baseKey + ".device", "");
std::string params = _pPrefs->configuration()->getString(baseKey + ".params", "8N1");
int speed = _pPrefs->configuration()->getInt(baseKey + ".speed", 9600);
try
{
pContext->logger().information(Poco::format("Creating serial port for device '%s'.", device));
SerialDeviceImpl::SerialPortPtr pSerialPort = new SerialPort(device, speed, params);
createSerialDevice(Poco::NumberFormatter::format(index), pSerialPort);
}
catch (Poco::Exception& exc)
{
pContext->logger().error(Poco::format("Cannot create serial port for device '%s': %s", device, exc.displayText()));
}
index++;
}
}
void start(BundleContext::Ptr pContext)
{
ServiceRef::Ptr pPrefsRef = pContext->registry().findByName(PreferencesService::SERVICE_NAME);
AutoPtr<PreferencesService> pPrefs = pPrefsRef->castedInstance<PreferencesService>();
bool enable = pPrefs->configuration()->getBool("auth.simple.enable", true);
if (enable)
{
std::string adminName = pPrefs->configuration()->getString("auth.simple.admin.name", "admin");
std::string adminPasswordHash = pPrefs->configuration()->getString("auth.simple.admin.passwordHash", "");
std::string userName = pPrefs->configuration()->getString("auth.simple.user.name", "user");
std::string userPasswordHash = pPrefs->configuration()->getString("auth.simple.user.passwordHash", "");
std::string salt = pPrefs->configuration()->getString("auth.simple.salt", "");
std::string perms = pPrefs->configuration()->getString("auth.simple.user.permissions", "");
StringTokenizer tok(perms, ",;", StringTokenizer::TOK_TRIM | StringTokenizer::TOK_IGNORE_EMPTY);
std::set<std::string> userPermissions;
for (StringTokenizer::Iterator it = tok.begin(); it != tok.end(); ++it)
{
userPermissions.insert(*it);
}
AutoPtr<SimpleAuthService> pService = new SimpleAuthService(adminName, adminPasswordHash, userName, userPasswordHash, userPermissions, salt);
_pService = pContext->registry().registerService("osp.auth", pService, Properties());
}
else
{
pContext->logger().information("Simple authentication service disabled.");
}
}
void start(BundleContext::Ptr pContext)
{
_pTimer = new Poco::Util::Timer;
_pContext = pContext;
_pPrefs = ServiceFinder::find<PreferencesService>(pContext);
Poco::Util::AbstractConfiguration::Keys keys;
_pPrefs->configuration()->keys("simulation.sensors", keys);
for (std::vector<std::string>::const_iterator it = keys.begin(); it != keys.end(); ++it)
{
std::string baseKey = "simulation.sensors.";
baseKey += *it;
SimulatedSensor::Params params;
params.id = SimulatedSensor::SYMBOLIC_NAME;
params.id += "#";
params.id += Poco::NumberFormatter::format(_serviceRefs.size());
params.physicalQuantity = _pPrefs->configuration()->getString(baseKey + ".physicalQuantity", "");
params.physicalUnit = _pPrefs->configuration()->getString(baseKey + ".physicalUnit", "");
params.initialValue = _pPrefs->configuration()->getDouble(baseKey + ".initialValue", 0.0);
params.delta = _pPrefs->configuration()->getDouble(baseKey + ".delta", 0.0);
params.cycles = _pPrefs->configuration()->getInt(baseKey + ".cycles", 0);
params.updateRate = _pPrefs->configuration()->getDouble(baseKey + ".updateRate", 0.0);
std::string mode = _pPrefs->configuration()->getString(baseKey + ".mode", "linear");
if (mode == "linear")
params.mode = SimulatedSensor::SIM_LINEAR;
else if (mode == "random")
params.mode = SimulatedSensor::SIM_RANDOM;
try
{
createSensor(params);
}
catch (Poco::Exception& exc)
{
pContext->logger().error(Poco::format("Cannot create simulated sensor: %s", exc.displayText()));
}
}
std::string gpxPath = _pPrefs->configuration()->getString("simulation.gnss.gpxPath", "");
if (!gpxPath.empty())
{
SimulatedGNSSSensor::Params params;
params.id = SimulatedGNSSSensor::SYMBOLIC_NAME;
params.gpxPath = gpxPath;
params.loopReplay = _pPrefs->configuration()->getBool("simulation.gnss.loopReplay", true);
params.speedUp = _pPrefs->configuration()->getDouble("simulation.gnss.speedUp", 1.0);
try
{
createGNSSSensor(params);
}
catch (Poco::Exception& exc)
{
pContext->logger().error(Poco::format("Cannot create simulated GNSS sensor: %s", exc.displayText()));
}
}
}
void handleExtension(Bundle::ConstPtr pBundle, Poco::XML::Element* pExtensionElem)
{
std::string name = pBundle->name();
std::string symbolicName = pBundle->symbolicName();
std::string msg(Poco::format("Running tests in bundle \"%s\" (%s)...", name, symbolicName));
_pContext->logger().information(std::string(msg.size(), '='));
_pContext->logger().information(msg);
_pContext->logger().information(std::string(msg.size(), '-'));
BundleContext::Ptr pContext = _pContext->contextForBundle(pBundle);
TestCase::resetContext(pContext);
LogStream logStream(pContext->logger());
TestFactory::TestVec tests = TestFactory::instance().get(name);
TestFactory::TestVec::iterator it = tests.begin();
TestFactory::TestVec::iterator end = tests.end();
int nTests = 0;
int nErrors = 0;
int nFailures = 0;
for (; it != end; ++it)
{
LogTestResult ltr(logStream);
(*it)->run(<r);
ltr.print(logStream);
nTests += ltr.runTests();
nErrors += ltr.testErrors();
nFailures += ltr.testFailures();
}
if (nErrors > 0)
{
if (nErrors == 1)
_pContext->logger().error("There was 1 error in bundle \"%s\" (%s).", name, symbolicName);
else
_pContext->logger().error("There were %d errors in bundle \"%s\" (%s).", nErrors, name, symbolicName);
}
if (nFailures > 0)
{
if (nFailures == 1)
_pContext->logger().error("There was 1 failure in bundle \"%s\" (%s).", name, symbolicName);
else
_pContext->logger().error("There were %d failures in bundle \"%s\" (%s).", nFailures, name, symbolicName);
}
if (nTests == 1)
msg = Poco::format("Ran 1 test in bundle \"%s\" (%s).", name, symbolicName);
else
msg = Poco::format("Ran %d tests in bundle \"%s\" (%s).", nTests, name, symbolicName);
_pContext->logger().information(std::string(msg.size(), '-'));
_pContext->logger().information(msg);
_pContext->logger().information(std::string(msg.size(), '='));
}
void stop(BundleContext::Ptr pContext)
{
pContext->registry().unregisterService(_pWebSessionManagerSvc);
pContext->registry().unregisterService(_pWebServerDispatcherSvc);
pContext->registry().unregisterService(_pMediaTypeMapperSvc);
_pWebSessionManagerSvc = 0;
_pWebServerDispatcherSvc = 0;
_pMediaTypeMapperSvc = 0;
_pWebServerExtensionPoint = 0;
_pWebFilterExtensionPoint = 0;
}
void stop(BundleContext::Ptr pContext)
{
if (_pService)
{
pContext->registry().unregisterService(_pService);
}
}
void start(BundleContext::Ptr pContext)
{
// Create an instance of the GreetingService
GreetingService::Ptr pService = new GreetingServiceImpl(pContext);
// Register the GreetingService with the ServiceRegistry.
_pService = pContext->registry().registerService("com.appinf.osp.samples.GreetingService", pService, Properties());
}
void start(BundleContext::Ptr pContext)
{
typedef Poco::RemotingNG::ServerHelper<IoT::WebEvent::WebEventNotifier> ServerHelper;
Poco::SharedPtr<IoT::WebEvent::WebEventNotifier> pWebEventNotifier = new WebEventNotifierImpl(pContext);
std::string oid("io.macchina.services.webeventnotifier");
ServerHelper::RemoteObjectPtr pWebEventNotifierRemoteObject = ServerHelper::createRemoteObject(pWebEventNotifier, oid);
ServiceRef::Ptr pServiceRef = pContext->registry().registerService(oid, pWebEventNotifierRemoteObject, Properties());
}
void start(BundleContext::Ptr pContext)
{
// Obtain the GreetingService object from the Service Registry.
ServiceRef::Ptr pServiceRef = pContext->registry().findByName("com.appinf.osp.samples.GreetingService");
if (pServiceRef)
{
// Service is available - let's invoke it
GreetingService::Ptr pService = pServiceRef->castedInstance<GreetingService>();
std::string greeting = pService->greeting();
std::string msg("****** ");
msg += greeting;
msg += " ******";
pContext->logger().information(msg);
}
else
{
// The service is not available
pContext->logger().error("The GreetingService is not available.");
}
}
void start(BundleContext::Ptr pContext)
{
// find ExtensionPointService using the Service Registry
ServiceRef::Ptr pXPSRef = pContext->registry().findByName("osp.core.xp");
if (pXPSRef)
{
// ExtensionPointService is available
AutoPtr<ExtensionPointService> pXPS = pXPSRef->castedInstance<ExtensionPointService>();
// Create an ExtensionPoint
ExtensionPoint::Ptr pXP = new TestExtensionPoint(pContext);
// Register ExtensionPoint
pXPS->registerExtensionPoint(pContext->thisBundle(), "com.appinf.osp.unit.test", pXP);
}
else
{
// The service is not available
pContext->logger().error("The ExtensionPointService is not available.");
}
}
void stop(BundleContext::Ptr pContext)
{
for (std::vector<Poco::OSP::ServiceRef::Ptr>::iterator it = _serviceRefs.begin(); it != _serviceRefs.end(); ++it)
{
pContext->registry().unregisterService(*it);
}
_serviceRefs.clear();
for (std::vector<MQTTClientImpl::Ptr>::iterator it = _clients.begin(); it != _clients.end(); ++it)
{
try
{
(*it)->disconnect(200);
}
catch (Poco::Exception& exc)
{
pContext->logger().log(exc);
}
}
_clients.clear();
ServerHelper::shutdown();
}
void start(BundleContext::Ptr pContext)
{
_pContext = pContext;
_pPrefs = ServiceFinder::find<PreferencesService>(pContext);
std::string device = _pPrefs->configuration()->getString("gnss.nmea.device", "");
std::string params = _pPrefs->configuration()->getString("gnss.nmea.params", "8N1");
int speed = _pPrefs->configuration()->getInt("gnss.nmea.speed", 4800);
try
{
if (!device.empty())
{
pContext->logger().information(Poco::format("Creating GNSSSensor for serial port '%s'.", device));
createGNSSSensor(new Poco::Serial::SerialPort(device, speed, params));
}
}
catch (Poco::Exception& exc)
{
pContext->logger().error(Poco::format("Cannot create serial port for device '%s': %s", device, exc.displayText()));
}
}
void start(BundleContext::Ptr pContext)
{
MediaTypeMapper::Ptr pMediaTypeMapper = new MediaTypeMapper;
#if __cplusplus < 201103L
std::auto_ptr<std::istream> pStream(pContext->thisBundle()->getResource("mime.types"));
#else
std::unique_ptr<std::istream> pStream(pContext->thisBundle()->getResource("mime.types"));
#endif
if (pStream.get())
{
pMediaTypeMapper->load(*pStream);
}
_pMediaTypeMapperSvc = pContext->registry().registerService(MediaTypeMapper::SERVICE_NAME, pMediaTypeMapper, Properties());
ServiceRef::Ptr pPrefsSvcRef = pContext->registry().findByName("osp.core.preferences");
std::string authServiceName(pContext->thisBundle()->properties().getString("authServiceName", ""));
bool cacheResources(pContext->thisBundle()->properties().getBool("cacheResources", false));
bool compressResponse(pContext->thisBundle()->properties().getBool("compressResponses", false));
std::string compressedMediaTypesString(pContext->thisBundle()->properties().getString("compressedMediaTypes", ""));
std::string sessionCookiePersistence(pContext->thisBundle()->properties().getString("cookiePersistence", "persistent"));
if (pPrefsSvcRef)
{
Poco::AutoPtr<PreferencesService> pPrefsSvc = pPrefsSvcRef->castedInstance<PreferencesService>();
authServiceName = pPrefsSvc->configuration()->getString("osp.web.authServiceName", authServiceName);
cacheResources = pPrefsSvc->configuration()->getBool("osp.web.cacheResources", cacheResources);
compressResponse = pPrefsSvc->configuration()->getBool("osp.web.compressResponses", compressResponse);
compressedMediaTypesString = pPrefsSvc->configuration()->getString("osp.web.compressedMediaTypes", compressedMediaTypesString);
sessionCookiePersistence = pPrefsSvc->configuration()->getString("osp.web.sessionManager.cookiePersistence", sessionCookiePersistence);
}
Poco::StringTokenizer tok(compressedMediaTypesString, ",", Poco::StringTokenizer::TOK_TRIM | Poco::StringTokenizer::TOK_IGNORE_EMPTY);
std::set<std::string> compressedMediaTypes(tok.begin(), tok.end());
AutoPtr<WebServerDispatcher> pWebServerDispatcher = new WebServerDispatcher(pContext, pMediaTypeMapper, authServiceName, compressResponse, compressedMediaTypes, cacheResources);
_pWebServerDispatcherSvc = pContext->registry().registerService(WebServerDispatcher::SERVICE_NAME, pWebServerDispatcher, Properties());
WebSessionManager::CookiePersistence cookiePersistence = WebSessionManager::COOKIE_PERSISTENT;
if (sessionCookiePersistence == "transient")
cookiePersistence = WebSessionManager::COOKIE_TRANSIENT;
else if (sessionCookiePersistence != "persistent")
pContext->logger().warning(Poco::format("Ignoring invalid value for osp.web.sessionManager.cookiePersistence: '%s'. Valid values are 'transient' or 'persistent'.", sessionCookiePersistence));
AutoPtr<WebSessionManager> pWebSessionManager = new WebSessionManager;
pWebSessionManager->setCookiePersistence(cookiePersistence);
_pWebSessionManagerSvc = pContext->registry().registerService(WebSessionManager::SERVICE_NAME, pWebSessionManager, Properties());
ServiceRef::Ptr pXPSRef = pContext->registry().findByName("osp.core.xp");
if (pXPSRef)
{
AutoPtr<ExtensionPointService> pXPS = pXPSRef->castedInstance<ExtensionPointService>();
_pWebServerExtensionPoint = new WebServerExtensionPoint(pContext, pWebServerDispatcher);
pXPS->registerExtensionPoint(pContext->thisBundle(), WebServerExtensionPoint::EXTPOINT_DIRECTORY, _pWebServerExtensionPoint);
pXPS->registerExtensionPoint(pContext->thisBundle(), WebServerExtensionPoint::EXTPOINT_HANDLER, _pWebServerExtensionPoint);
_pWebFilterExtensionPoint = new WebFilterExtensionPoint(pContext, pWebServerDispatcher);
pXPS->registerExtensionPoint(pContext->thisBundle(), WebFilterExtensionPoint::EXTPOINT_FILTER, _pWebFilterExtensionPoint);
}
else
{
pContext->logger().error("The ExtensionPointService is not available.");
}
}
void stop(BundleContext::Ptr pContext)
{
// Unregister the GreetingService
pContext->registry().unregisterService(_pService);
}
