ArmarXManager.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of ArmarX.
3  *
4  * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
5  *
6  * ArmarX is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  * ArmarX is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17  *
18  * @package ArmarXCore::core
19  * @author Kai Welke (kai dot welke at kit dot edu)
20  * @date 2012
21  * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
22  * GNU General Public License
23  */
24 
26 #include <ArmarXCore/core/Component.h> // for ComponentPtr, Component
27 #include <ArmarXCore/core/IceManager.h> // for IceManager
28 #include <ArmarXCore/core/ManagedIceObject.h> // for ManagedIceObject
32 #include <ArmarXCore/core/system/ArmarXDataPath.h> // for ArmarXDataPath
34 #include <ArmarXCore/core/time/LocalTimeServer.h> // for LocalTimeServer
35 #include <ArmarXCore/core/time/TimeUtil.h> // for TimeUtil
38 #include <Ice/BuiltinSequences.h> // for StringSeq
39 #include <Ice/Communicator.h> // for CommunicatorPtr, etc
40 #include <Ice/Identity.h> // for Identity
41 #include <Ice/Initialize.h> // for initialize
42 #include <Ice/LocalException.h> // for AlreadyRegisteredException, etc
43 #include <Ice/NativePropertiesAdmin.h>
44 #include <Ice/ObjectAdapter.h> // for ObjectAdapterPtr
45 #include <Ice/ObjectF.h> // for upCast
46 #include <Ice/Properties.h> // for Properties
47 #include <Ice/PropertiesF.h> // for upCast
48 #include <Ice/Proxy.h> // for Object
49 #include <Ice/ProxyF.h> // for ObjectPrx
50 #include <IceGrid/Admin.h> // for Admin, ObjectObserverPrx, upCast
51 #include <IceGrid/Registry.h> // for RegistryPrx, upCast
52 #include <IceUtil/Handle.h> // for HandleBase, Handle
53 #include <IceStorm/IceStorm.h> // for TopicPrx, TopicManagerPrx, etc
54 
55 #include <cstddef> // for size_t, NULL
56 #include <chrono> // for seconds
57 #include <iostream> // for operator<<, basic_ostream, etc
58 #include <map> // for _Rb_tree_iterator, etc
59 #include <ratio> // for ratio
60 #include <sstream> // for basic_stringbuf<>::int_type, etc
61 #include <string> // for string, allocator, etc
62 #include <thread> // for thread, sleep_for
63 #include <utility> // for pair, make_pair, move
64 #include <vector> // for vector, vector<>::iterator
65 
69 #include "ArmarXCore/core/exceptions/Exception.h" // for LocalException, etc
70 #include "ArmarXCore/core/logging/LogSender.h" // for LogSender
71 #include "ArmarXCore/core/logging/Logging.h" // for ARMARX_VERBOSE, etc
72 #include "ArmarXCore/core/services/tasks/ThreadList.h" // for ThreadList
73 #include "ArmarXCore/interface/core/BasicTypes.h"
74 #include "ArmarXCore/interface/core/Log.h" // for LogPrx, MessageType, etc
75 #include "ArmarXCore/interface/core/ManagedIceObjectDefinitions.h"
76 #include "ArmarXCore/interface/core/ThreadingIceBase.h" // for upCast
77 #include "ArmarXManager.h" // for ArmarXManager, etc
79 #include "IceGridAdmin.h" // for IceGridAdmin
81 
82 namespace Ice
83 {
84  struct Current;
85 } // namespace Ice
86 
87 namespace armarx
88 {
89 #define MANAGEROBJNAME applicationName + "Manager"
90 #define OBJOBSNAME std::string("ArmarXObjectObserver_") + applicationName
91 
92  // *******************************************************
93  // construction
94  // *******************************************************
95  ArmarXManager::ArmarXManager(std::string applicationName, int port, std::string host, std::string locatorName, Ice::StringSeq args) :
96  applicationName(applicationName),
97  managerState(eCreated)
98  {
99  // initialize communicator
100  std::stringstream defaultLocator;
101  defaultLocator << "--Ice.Default.Locator=" << locatorName << ":tcp -p " << port << " -h " << host;
102  args.push_back(defaultLocator.str());
103  Ice::CommunicatorPtr communicator = Ice::initialize(args);
104 
105  // init members
106  init(applicationName, communicator);
107  }
108 
109  ArmarXManager::ArmarXManager(std::string applicationName, const Ice::CommunicatorPtr& communicator) :
110  applicationName(applicationName),
111  managerState(eCreated)
112  {
113  // init members
114  init(applicationName, communicator);
115  }
116 
117 
119  {
120  shutdown();
121  waitForShutdown();
122  }
123 
124  bool ArmarXManager::checkIceConnection(bool printHint) const
125  {
126  return CheckIceConnection(iceManager->getCommunicator(), printHint);
127  }
128 
129  bool ArmarXManager::CheckIceConnection(const Ice::CommunicatorPtr& communicator, bool printHint)
130  {
131  const std::string armarxHint = "'\nDid you start armarx?\n\nTo start armarx: armarx start\n"
132  "To kill a hanging armarx: armarx killIce" ;
133  try
134  {
135  if (communicator->getProperties()->getProperty("Ice.Default.Locator").empty())
136  {
137  if (printHint)
138  {
139  std::cerr << "Required Ice property 'Ice.Default.Locator' not set! "
140  << "It has to has a value similar to 'IceGrid/Locator:tcp -p 4061 -h localhost'";
141  }
142  return false;
143  }
144  auto locatorProp = communicator->getProperties()->getProperty("Ice.Default.Locator");
145  auto pos = locatorProp.find_first_of(':');
146  std::string locatorId = locatorProp.substr(0, pos) ;
147  auto proxy = communicator->stringToProxy(locatorId);
148  IceGrid::LocatorPrx::checkedCast(proxy);
149  }
150  catch (...)
151  {
152  if (printHint)
153  {
154  std::cerr << "Could not contact default locator at '"
155  << communicator->getProperties()->getProperty("Ice.Default.Locator")
156  << armarxHint;
157  }
158  return false;
159  }
160 
161  try
162  {
163  std::string registryId = "IceGrid/Registry";
164  auto proxy = communicator->stringToProxy(registryId);
165  IceGrid::RegistryPrx::checkedCast(proxy);
166  }
167  catch (...)
168  {
169  if (printHint)
170  {
171  std::cerr << "Could not contact IceGrid registry at '"
172  << communicator->getProperties()->getProperty("IceGrid.Registry.Client.Endpoints")
173  << armarxHint;
174  }
175  return false;
176  }
177 
178  try
179  {
180  IceManager::GetTopicManager(communicator);
181  }
182  catch (const Ice::NoEndpointException& e)
183  {
184  std::cout << "Caught exception: \n" << e.what() << std::endl;
185 
186  if (printHint)
187  {
188  std::cerr << "Could not contact TopicManager at '"
189  // This string is actually used in IceManager::GetTopicManager()
190  << "IceStorm/TopicManager"
191  // << communicator->getProperties()->getProperty("IceStormAdmin.TopicManager.Default")
192  << armarxHint;
193  }
194  return false;
195  }
196 
197  return true;
198  }
199 
200  // *******************************************************
201  // ArmarXManager property setters
202  // *******************************************************
204  {
206  }
207 
208 
210  {
211  ThreadList::getApplicationThreadList()->enableProfiler(enable);
212  }
213 
214 
216  {
218  }
219 
220  void ArmarXManager::setDataPaths(std::string dataPaths)
221  {
223  }
224 
225  // *******************************************************
226  // adding / removing ManagedIceObjects
227  // *******************************************************
228 
229 
230  void ArmarXManager::addObject(const ManagedIceObjectPtr& object, bool addWithOwnAdapter, const std::string& objectName, bool useOwnScheduleThread)
231  {
232  addObject(object,
233  addWithOwnAdapter ? Ice::ObjectAdapterPtr() : getAdapter(), objectName, useOwnScheduleThread);
234  }
235  void ArmarXManager::addObject(const ManagedIceObjectPtr& object, const std::string& objectName, bool addWithOwnAdapter, bool useOwnScheduleThread)
236  {
237  addObject(object, addWithOwnAdapter, objectName, useOwnScheduleThread);
238  }
239 
240  void ArmarXManager::addObject(const ManagedIceObjectPtr& object, Ice::ObjectAdapterPtr objectAdapterToAddTo, const std::string& objectName, bool useOwnScheduleThread)
241  {
242  if (!object)
243  {
244  throw LocalException("Cannot add NULL object");
245  }
246  {
247  auto cptr = ComponentPtr::dynamicCast(object);
248  if (cptr && !cptr->createdByComponentCreate)
249  {
250  throw LocalException("Components need to be created by Component::create");
251  }
252  }
253 
254  if (!objectName.empty())
255  {
256  if (!object->getName().empty())
257  {
258  ARMARX_INFO << "Adding object with custom name: " << objectName;
259  }
260  object->setName(objectName);
261  }
262  if (object->getName().empty())
263  {
264  object->setName(object->getDefaultName());
265  }
266  if (object->getName().empty())
267  {
268  throw LocalException("Object name must not be empty");
269  }
270  auto lock = acquireManagedObjectsMutex();
271  if (!lock)
272  {
273  return;
274  }
275 
276  bool reachable = false;
277 
278  try
279  {
280  reachable = getIceManager()->isObjectReachable(object->getName());
281  }
282  catch (...)
283  {
284  throw;
285  }
286 
287  if (reachable)
288  {
289  throw Ice::AlreadyRegisteredException(__FILE__, __LINE__, object->ice_id(), object->getName());
290  }
291 
292  try
293  {
294  ArmarXObjectSchedulerPtr objectScheduler = new ArmarXObjectScheduler(this, iceManager, object, objectAdapterToAddTo, useOwnScheduleThread);
295  auto pair = managedObjects.insert(std::make_pair(object->getName(), std::move(objectScheduler)));
296  if (!pair.second)
297  {
298  ARMARX_WARNING << "Insert of object scheduler in managedObjects failed since there is already a scheduler for name " << object->getName();
299  }
300  if (!useOwnScheduleThread)
301  {
302  std::scoped_lock lock(schedulerListMutex);
303  singleThreadedSchedulers.at(rand() % singleThreadedSchedulers.size())->addObjectScheduler(pair.first->second);
304  }
305  }
306  catch (...)
307  {
308  throw;
309  }
310  }
311 
312  void ArmarXManager::addObjectAsync(const ManagedIceObjectPtr& object, const std::string& objectName, bool addWithOwnAdapter, bool useOwnScheduleThread)
313  {
314  ArmarXManagerPtr manager(this);
315  std::thread
316  {
317  [ = ]
318  {
319  try
320  {
321  manager->addObject(object, objectName, addWithOwnAdapter, useOwnScheduleThread);
322  }
323  catch (...)
324  {
326  }
327  }
328 
329  } .detach();
330  }
331 
332  void ArmarXManager::removeObjectBlocking(const std::string& objectName)
333  {
334  ArmarXObjectSchedulerPtr scheduler;
335  {
336  auto lock = acquireManagedObjectsMutex();
337  if (!lock)
338  {
339  return;
340  }
341  scheduler = managedObjects.find(objectName)->second;
342  }
343  try
344  {
345  if (scheduler)
346  {
347  removeObject(scheduler, true);
348  }
349  }
350  catch (...)
351  {
352  throw;
353  }
354 
355  }
356 
357  void ArmarXManager::removeObjectNonBlocking(const std::string& objectName)
358  {
359  auto removal = [objectName, this]()
360  {
361  ArmarXObjectSchedulerPtr scheduler;
362  {
363  auto lock = acquireManagedObjectsMutex();
364  if (!lock)
365  {
366  return;
367  }
368  scheduler = managedObjects.find(objectName)->second;
369  }
370  try
371  {
372  this->removeObject(scheduler, false);
373 
374  }
375  catch (...)
376  {
377  throw;
378  }
379 
380  };
381  std::thread {removal} .detach();
382  }
383 
385  {
386  removeObjectBlocking(object->getName());
387  }
388 
390  {
391  removeObjectNonBlocking(object->getName());
392  }
393 
394  // *******************************************************
395  // shutdown handling
396  // *******************************************************
398  {
399  // assure no state changed
400  managerStateMutex.lock();
401 
402  if (managerState == eShutdown)
403  {
404  managerStateMutex.unlock();
405  return;
406  }
407 
408  // wait for shutdown
409  std::unique_lock lock(shutdownMutex);
410  managerStateMutex.unlock();
411  shutdownCondition.wait(lock);
412  ARMARX_VERBOSE << "Waiting for shutdown finished";
413  }
414 
416  {
417  try
418  {
419  // check state
420  {
421  std::scoped_lock lock(managerStateMutex);
422 
423  // do not shutdown if shutdown is in progress
424  if (managerState >= eShutdownInProgress)
425  {
426  return;
427  }
428 
429  managerState = eShutdownInProgress;
430 
431  // locking managedObjects ne done before state mutex is released
432  managedObjectsMutex.lock();
433  }
434 
435  ARMARX_VERBOSE << "Shutting down ArmarXManager" << std::endl;
436 
437  // stop cleanup task. All objects will be removed manually in shutdown
438  cleanupSchedulersTask->stop();
439 
440  if (checkDependencyStatusTask)
441  {
442  checkDependencyStatusTask->stop();
443  }
444 
445  sharedRemoteHandleState.reset();
446  remoteReferenceCountControlBlockManager.reset();
447 
448  disconnectAllObjects();
449 
450  // shutdown log sender
452 
453  // remove all managed objects
454  removeAllObjects(true);
455  try
456  {
457  iceManager->getIceGridSession()->getAdmin()->removeObject(Ice::Identity {MANAGEROBJNAME, ""});
458  }
459  catch (...) {}
460 
461  singleThreadedSchedulers.clear();
462 
463  try
464  {
465  // deactivate all object adapters (and do internal iceManager shutdown)
466  iceManager->shutdown();
467 
468  // wait until all adapters have been deactivated
469  iceManager->waitForShutdown();
470  }
471  catch (...)
472  {
473  }
474  // destroy manager and communicator
475  iceManager->destroy();
476 
477  // set to NULL to avoid cycle in pointers ArmarXManager <-> ArmarXObjectObserver
478  objObserver = nullptr;
479 
480  // set state to shutdown and notify waitForShutdown
481  {
482  std::scoped_lock lock(managerStateMutex);
483 
484  // inform waiting threads of shutdown
485  {
486  std::unique_lock lock(shutdownMutex);
487  ARMARX_VERBOSE << "notifying shutdown waiters" << std::endl;
488  shutdownCondition.notify_all();
489  }
490 
491  managerState = eShutdown;
492  }
493 
494  managedObjectsMutex.unlock();
495  }
496  catch (std::exception& e)
497  {
498  ARMARX_INFO << "shutdown failed with exception!\n" << e.what() << std::endl;
499  }
500 
501  ARMARX_INFO << "Shutdown of ArmarXManager finished!" << std::endl;
502  }
503 
504  void ArmarXManager::asyncShutdown(std::size_t timeoutMs)
505  {
506  std::thread {[this, timeoutMs]{
507  std::this_thread::sleep_for(std::chrono::milliseconds{timeoutMs});
508  shutdown();
509  }
510  } .detach();
511  }
512 
514  {
515  std::scoped_lock lock(managerStateMutex);
516  return (managerState == eShutdown);
517  }
518 
519 
520  // *******************************************************
521  // getters
522  // *******************************************************
523 
525  {
526  return iceManager;
527  }
528 
530  {
531  return iceManager->getCommunicator();
532  }
533 
534  std::vector<ManagedIceObjectPtr> ArmarXManager::getManagedObjects()
535  {
536  std::vector<ManagedIceObjectPtr> objects;
537 
538  auto lock = acquireManagedObjectsMutex();
539  if (!lock)
540  {
541  return objects;
542  }
543 
544  ObjectSchedulerMap::iterator iter = managedObjects.begin();
545 
546  while (iter != managedObjects.end())
547  {
548  objects.push_back(iter->second->getObject());
549  iter++;
550  }
551 
552 
553  return objects;
554  }
555 
556  // *******************************************************
557  // Slice ArmarXManagerInterface implementation
558  // *******************************************************
559  ManagedIceObjectState ArmarXManager::getObjectState(const std::string& objectName, const Ice::Current& c)
560  {
561  auto lock = acquireManagedObjectsMutex();
562  if (!lock)
563  {
564  return eManagedIceObjectExiting;
565  }
566 
567  ObjectSchedulerMap::iterator iter = managedObjects.find(objectName);
568 
569  if (iter == managedObjects.end())
570  {
571  return eManagedIceObjectExited;
572  }
573 
574  ManagedIceObjectState state = (ManagedIceObjectState)iter->second->getObject()->getState();
575 
576  return state;
577  }
578 
579  ManagedIceObjectConnectivity ArmarXManager::getObjectConnectivity(const std::string& objectName, const Ice::Current& c)
580  {
581  auto lock = acquireManagedObjectsMutex();
582  if (!lock)
583  {
584  return ManagedIceObjectConnectivity();
585  }
586 
587  ObjectSchedulerMap::iterator iter = managedObjects.find(objectName);
588 
589  if (iter == managedObjects.end())
590  {
591  return ManagedIceObjectConnectivity();
592  }
593 
594  ManagedIceObjectConnectivity con = iter->second->getObject()->getConnectivity();
595 
596 
597  return con;
598  }
599 
600 
601  StringStringDictionary ArmarXManager::getObjectProperties(const ::std::string& objectName, const ::Ice::Current&)
602  {
603  StringStringDictionary propertyMap;
604  ObjectSchedulerMap::iterator iter = managedObjects.find(objectName);
605 
606  if (iter == managedObjects.end())
607  {
608  return propertyMap;
609  }
610 
611  ComponentPtr component = ComponentPtr::dynamicCast(iter->second->getObject());
612 
613  if (!component)
614  {
615  return propertyMap;
616  }
617  ARMARX_CHECK_EXPRESSION(component->getPropertyDefinitions());
618  auto result = component->getPropertyDefinitions()->getPropertyValues(component->getPropertyDefinitions()->getPrefix());
619  return result;
620  }
621 
622  ObjectPropertyInfos ArmarXManager::getObjectPropertyInfos(const ::std::string& objectName, const ::Ice::Current&)
623  {
624  ObjectPropertyInfos propertyMap;
625  ObjectSchedulerMap::iterator iter = managedObjects.find(objectName);
626 
627  if (iter == managedObjects.end())
628  {
629  return propertyMap;
630  }
631 
632  ComponentPtr component = ComponentPtr::dynamicCast(iter->second->getObject());
633 
634  if (!component)
635  {
636  return propertyMap;
637  }
638 
639  ARMARX_CHECK_EXPRESSION(component->getPropertyDefinitions());
640  for (auto prop : component->getPropertyDefinitions()->getPropertyValues())
641  {
642  propertyMap[component->getPropertyDefinitions()->getPrefix() + prop.first] = {component->getPropertyDefinitions()->getDefinitionBase(prop.first)->isConstant(),
643  prop.second
644  };
645  }
646  return propertyMap;
647  }
648 
649  ObjectPropertyInfos ArmarXManager::getApplicationPropertyInfos(const Ice::Current&)
650  {
651  ObjectPropertyInfos propertyMap;
652  if (!Application::getInstance() || !Application::getInstance()->getPropertyDefinitions())
653  {
654  return propertyMap;
655  }
656  for (auto prop : Application::getInstance()->getPropertyDefinitions()->getPropertyValues())
657  {
658  propertyMap[Application::getInstance()->getPropertyDefinitions()->getPrefix() + prop.first] = {Application::getInstance()->getPropertyDefinitions()->getDefinitionBase(prop.first)->isConstant(),
659  prop.second
660  };
661  }
662  return propertyMap;
663  }
664 
665 
666  Ice::PropertiesAdminPrx ArmarXManager::getPropertiesAdmin(const Ice::Current&)
667  {
668  Ice::ObjectPrx adminObj = getIceManager()->getCommunicator()->getAdmin();
669  Ice::PropertiesAdminPrx propAdmin = Ice::PropertiesAdminPrx::checkedCast(adminObj, "Properties");
670  return propAdmin;
671  }
672 
674  {
675  for (ManagedIceObjectPtr& managedObject : getManagedObjects())
676  {
677  ComponentPtr component = ComponentPtr::dynamicCast(managedObject);
678  if (component)
679  {
680  component->setIceProperties(properties);
681  }
682  }
683  }
684 
685  void ArmarXManager::updateComponentIceProperties(const Ice::PropertyDict& properties)
686  {
687  for (ManagedIceObjectPtr& managedObject : getManagedObjects())
688  {
689  ComponentPtr component = ComponentPtr::dynamicCast(managedObject);
690  if (component)
691  {
692  component->updateIceProperties(properties);
693  }
694  }
695  }
696 
697 
698  Ice::StringSeq ArmarXManager::getManagedObjectNames(const Ice::Current& c)
699  {
700  Ice::StringSeq objectNames;
701 
702  auto lock = acquireManagedObjectsMutex();
703  if (!lock)
704  {
705  return objectNames;
706  }
707 
708  ObjectSchedulerMap::iterator iter = managedObjects.begin();
709 
710  while (iter != managedObjects.end())
711  {
712  objectNames.push_back(iter->first);
713  iter++;
714  }
715 
716 
717  return objectNames;
718  }
719 
721  public Ice::PropertiesAdminUpdateCallback
722  {
723  public:
725  application(application)
726  {
727  }
728 
729  void updated(const Ice::PropertyDict& changes) override
730  {
731  // ARMARX_INFO << "Properties were updated: " << changes;
732  if (application)
733  {
734  application->updateIceProperties(changes);
735  }
736  }
737  private:
738  armarx::ApplicationPtr application;
739  };
741 
742  // *******************************************************
743  // private methods
744  // *******************************************************
745  void ArmarXManager::init(std::string applicationName, const Ice::CommunicatorPtr& communicator)
746  {
748 
750 
751 
752  // create ice manager
753  iceManager = new IceManager(
754  communicator, applicationName,
755  appInstance ? appInstance->getProperty<std::string>("TopicSuffix").getValue() : "");
756 
757 
758  if (!checkIceConnection())
759  {
760  throw Ice::ConnectFailedException(__FILE__, __LINE__);
761  }
762 
763  this->installProcessFacet();
764 
765  // init logging
766  LogSender::setProxy(applicationName,
767  iceManager->getTopic<LogPrx>("Log"));
768 
769  setTag("ArmarXManager");
770 
772 
773 
774  // make sure icegrid session exists before continuing
775  auto icegrid = iceManager->getIceGridSession();
776  // register obj observer for onDisconnect
777  objObserver = new ArmarXObjectObserver(this);
778  Ice::ObjectAdapterPtr observerAdapter;
779  Ice::ObjectPrx oPrx = icegrid->registerObjectWithNewAdapter(objObserver, OBJOBSNAME, observerAdapter);
780  IceGrid::ObjectObserverPrx objObsPrx = IceGrid::ObjectObserverPrx::checkedCast(oPrx);
781  icegrid->setObjectObserver(objObsPrx);
782 
783  // register manager to ice
784  icegrid->registerObjectWithNewAdapter(this, MANAGEROBJNAME, armarxManagerAdapter);
785 
786 
787 
788  // create periodic task for starter cleanup
789  cleanupSchedulersTask = new PeriodicTask<ArmarXManager>(this, &ArmarXManager::cleanupSchedulers, 500, false, "ArmarXManager::cleanupSchedulers");
790  cleanupSchedulersTask->start();
791 
792  checkDependencyStatusTask = new PeriodicTask<ArmarXManager>(this, &ArmarXManager::checkDependencies, 1000, false, "ArmarXManager::DependenciesChecker");
793  checkDependencyStatusTask->start();
794 
795 
796  // set manager state to running
797  {
798  std::scoped_lock lock(managerStateMutex);
799  managerState = eRunning;
800  }
801 
802  // create ThreadList for this process
803  ThreadList::getApplicationThreadList()->setApplicationThreadListName(applicationName + "ThreadList");
804 
805  try
806  {
808  }
809  catch (...) {}
810 
811  // create a local TimeServer for this process
812  if (appInstance && appInstance->getProperty<bool>("UseTimeServer").getValue())
813  {
814  ARMARX_VERBOSE << "Using time from global time server.";
815  LocalTimeServer::getApplicationTimeServer()->setApplicationTimeServerName(applicationName + "LocalTimeServer");
818  }
819  else
820  {
821  ARMARX_VERBOSE << "Using time from local system clock.";
822  }
823 
824  sharedRemoteHandleState.reset(
826  {
827  appInstance ?
828  appInstance->getProperty<unsigned int>("RemoteHandlesDeletionTimeout").getValue() :
830  }
831  );
832  remoteReferenceCountControlBlockManager.reset(new RemoteReferenceCountControlBlockManager {IceUtil::Time::milliSeconds(100)});
833  }
834 
835  void ArmarXManager::cleanupSchedulers()
836  {
837  std::scoped_lock lock(terminatingObjectsMutex);
838 
839  ObjectSchedulerList::iterator iter = terminatingObjects.begin();
840 
841  while (iter != terminatingObjects.end())
842  {
843  const ArmarXObjectSchedulerPtr& sched = *iter;
844  ARMARX_VERBOSE << deactivateSpam(1, sched->getObject()->getName()) <<
845  "Checking termination state of " << sched->getObject()->getName() <<
846  ": " << ManagedIceObject::GetObjectStateAsString(sched->getObjectState());
847  // remove terminated starters
848  if ((*iter)->isTerminated())
849  {
850  ARMARX_VERBOSE << "Delayed Removal of ManagedIceObject " << (*iter)->getObject()->getName() << " finished";
851  iter = terminatingObjects.erase(iter);
852  }
853  else
854  {
855  iter++;
856  }
857  }
858  }
859 
860  void ArmarXManager::disconnectDependees(const std::string& object)
861  {
862  try
863  {
864  std::vector<std::string> dependees = getDependendees(object);
865 
866  auto lock = acquireManagedObjectsMutex();
867  if (!lock)
868  {
869  return;
870  }
871 
872  for (const auto& dependee : dependees)
873  {
874  ArmarXManager::ObjectSchedulerMap::iterator it = managedObjects.find(dependee);
875  ARMARX_INFO << deactivateSpam(10, dependee + object) << "'" << dependee << "' disconnected because of '" << object << "'";
876 
877  if (it != managedObjects.end())
878  {
879  it->second->disconnected(true);
880  }
881  }
882  }
883  catch (...)
884  {
885  throw;
886  }
887 
888  }
889 
890  void ArmarXManager::disconnectAllObjects()
891  {
892  auto lock = acquireManagedObjectsMutex();
893  if (!lock)
894  {
895  return;
896  }
897  ObjectSchedulerMap::iterator iter = managedObjects.begin();
898 
899  for (; iter != managedObjects.end(); iter++)
900  {
901  iter->second->disconnected(false);
902  }
903  }
904 
905 
906  std::vector<std::string> ArmarXManager::getDependendees(const std::string& removedObject)
907  {
908  std::vector<std::string> result;
909 
910  auto lock = acquireManagedObjectsMutex();
911  if (!lock)
912  {
913  return result;
914  }
915 
916  try
917  {
918 
919  ObjectSchedulerMap::const_iterator it = managedObjects.begin();
920 
921  for (; it != managedObjects.end(); it++)
922  {
923  ArmarXObjectSchedulerPtr scheduler = it->second;
924 
925  if (scheduler->dependsOn(removedObject))
926  {
927  result.push_back(it->first);
928  }
929  }
930  }
931  catch (...)
932  {
933  throw;
934  }
935 
936  return result;
937  }
938 
939  void ArmarXManager::wakeupWaitingSchedulers()
940  {
941  auto lock = acquireManagedObjectsMutex();
942  if (!lock)
943  {
944  return;
945  }
946 
947  try
948  {
949 
950  ObjectSchedulerMap::const_iterator it = managedObjects.begin();
951 
952  for (; it != managedObjects.end(); it++)
953  {
954  ArmarXObjectSchedulerPtr scheduler = it->second;
955  scheduler->wakeupDependencyCheck();
956  }
957  }
958  catch (...)
959  {
960  throw;
961  }
962 
963  }
964 
965  void ArmarXManager::removeAllObjects(bool blocking)
966  {
967  ObjectSchedulerMap tempMap;
968  {
969  std::scoped_lock lock(managedObjectsMutex);
970  tempMap = managedObjects;
971  }
972 
973  for (auto& it : tempMap)
974  {
975  removeObject(it.second, false);
976  }
977 
978  if (blocking)
979  {
980  for (auto objectScheduler : terminatingObjects)
981  {
982  objectScheduler->waitForTermination();
983 
984  }
985 
986  terminatingObjects.clear();
987  }
988 
989  }
990 
991 
992  bool ArmarXManager::removeObject(const ArmarXObjectSchedulerPtr& objectScheduler, bool blocking)
993  {
994  if (!objectScheduler)
995  {
996  return true;
997  }
998 
999  const std::string objName = objectScheduler->getObject()->getName();
1000 
1001  try
1002  {
1003  iceManager->removeObject(objName);
1004  {
1005  std::scoped_lock lock2(managedObjectsMutex);
1006  managedObjects.erase(objectScheduler->getObject()->getName());
1007  }
1008  // terminate
1009  objectScheduler->terminate();
1010 
1011  if (blocking)
1012  {
1013  objectScheduler->waitForTermination();
1014  ARMARX_VERBOSE << "Blocking removal of ManagedIceObject " << objName << " finished";
1015  }
1016  else // only move to terminating list if delayed removal
1017  {
1018  ARMARX_VERBOSE << "Inserting ManagedIceObject into delayed removal list: " << objName;
1019  std::scoped_lock lockTerm(terminatingObjectsMutex);
1020  terminatingObjects.push_back(objectScheduler);
1021  }
1022 
1023  return true;
1024  }
1025  catch (...)
1026  {
1027  ARMARX_ERROR << "Removing of object '" << objName << "' failed with an exception!\n" << GetHandledExceptionString();
1028  }
1029 
1030  return false;
1031  }
1032 
1033 
1034 
1035  //bool ArmarXManager::removeObject(const ObjectSchedulerMap::iterator& iter, bool blocking)
1036  //{
1037  // if (iter != managedObjects.end())
1038  // {
1039  // const std::string objName = iter->second->getObject()->getName();
1040 
1041  // try
1042  // {
1043 
1044  // ARMARX_VERBOSE << "Removing ManagedIceObject " << objName << " - blocking = " << blocking;
1045 
1046 
1047  // ArmarXObjectSchedulerPtr objectScheduler = iter->second;
1048 
1049 
1050  // // managedObjects.erase(iter);
1051  // return removeObject(objectScheduler, blocking);
1052  // }
1053  // catch (...)
1054  // {
1055  // ARMARX_ERROR << "Removing of object '" << objName << "' failed with an exception!";
1056  // handleExceptions();
1057  // }
1058  // }
1059 
1060  // return false;
1061  //}
1062 
1063  ArmarXObjectSchedulerPtr ArmarXManager::findObjectScheduler(const std::string& objectName) const
1064  {
1065  std::scoped_lock lock(managedObjectsMutex);
1066  auto it = managedObjects.find(objectName);
1067  if (it != managedObjects.end())
1068  {
1069  return it->second;
1070  }
1071  else
1072  {
1073  return ArmarXObjectSchedulerPtr();
1074  }
1075  }
1076 
1077  void ArmarXManager::checkDependencies()
1078  {
1079 
1080 
1081  auto lock = acquireManagedObjectsMutex();
1082  if (!lock)
1083  {
1084  return;
1085  }
1086 
1087  try
1088  {
1089  ObjectSchedulerMap::const_iterator it = managedObjects.begin();
1090 
1091  for (; it != managedObjects.end(); it++)
1092  {
1093  const ArmarXObjectSchedulerPtr& scheduler = it->second;
1094 
1095  if (scheduler->getObjectState() == eManagedIceObjectStarted && !scheduler->checkDependenciesStatus())
1096  {
1097  scheduler->disconnected(true);
1098  }
1099  }
1100  }
1101  catch (...)
1102  {
1103  throw;
1104  }
1105 
1106  }
1107 
1108  auto ArmarXManager::acquireManagedObjectsMutex() -> ScopedRecursiveLockPtr
1109  {
1110  // assure no state change until lock of managedObjectsMutex
1111  std::scoped_lock lock(managerStateMutex);
1112 
1113  if (managerState >= eShutdownInProgress)
1114  {
1115  return ScopedRecursiveLockPtr();
1116  }
1117 
1118  // lock access to managed objects
1119  ScopedRecursiveLockPtr lock2(new std::scoped_lock<std::recursive_mutex>(managedObjectsMutex));
1120 
1121  return lock2;
1122  }
1123 
1124  void ArmarXManager::installProcessFacet()
1125  {
1126  ApplicationPtr appInstance = Application::getInstance();
1127  Ice::CommunicatorPtr applicationCommunicator = getCommunicator();
1128  ARMARX_CHECK_EXPRESSION(applicationCommunicator);
1129  // remove default Ice::Process facet
1130  if (applicationCommunicator->findAdminFacet("Process"))
1131  {
1132  applicationCommunicator->removeAdminFacet("Process");
1133  }
1134  // create and register new Ice::Process facet
1135  Ice::ProcessPtr applicationProcessFacet = new ApplicationProcessFacet(*this);
1136  applicationCommunicator->addAdminFacet(applicationProcessFacet, "Process");
1137 
1138  IcePropertyChangeCallbackPtr propertyChangeCallback = new IcePropertyChangeCallback(appInstance);
1139 
1140  Ice::ObjectPtr obj = applicationCommunicator->findAdminFacet("Properties");
1141  Ice::NativePropertiesAdminPtr admin = Ice::NativePropertiesAdminPtr::dynamicCast(obj);
1142  if (admin)
1143  {
1144  admin->addUpdateCallback(propertyChangeCallback);
1145  }
1146  else
1147  {
1148  ARMARX_WARNING << "Could not get properties admin - online property changing will not work";
1149  }
1150 
1151  // activate new Ice::Process facet and PropertyChangeCallback
1152  applicationCommunicator->getAdmin();
1153  }
1154 
1156 
1158  {
1159  std::unique_lock lock(FactoryCollectionBase_RegistrationListMutex());
1160 
1162  {
1163  //ARMARX_INFO_S << "looking for " << preregistration->getFactories();
1164  for (const auto& id2factory : preregistration->getFactories())
1165  {
1166  if (!ic->getValueFactoryManager()->find(id2factory.first))
1167  {
1168  //ARMARX_IMPORTANT_S << "adding object factory for " << id2factory.first;
1169  ic->getValueFactoryManager()->add(id2factory.second, id2factory.first);
1170  }
1171  }
1172  }
1173 
1174  }
1175 
1177  {
1179  }
1180 
1182  {
1183  return armarxManagerAdapter;
1184  }
1185 
1186  const std::shared_ptr<SharedRemoteHandleState>& ArmarXManager::getSharedRemoteHandleState() const
1187  {
1188  return sharedRemoteHandleState;
1189  }
1190 
1192  {
1193  std::scoped_lock lock(schedulerListMutex);
1194  for (int i = 0; i < increaseBy; ++i)
1195  {
1196  singleThreadedSchedulers.push_back(new ArmarXMultipleObjectsScheduler());
1197  }
1198  }
1199 
1200  bool LoadLibFromAbsolutePath(const std::string& path)
1201  {
1202  //these variables should be shared between ArmarXManager -> use static variables
1203  static std::map<std::string, DynamicLibraryPtr> loadedLibs;
1204  static std::mutex libsMutex;
1205  std::lock_guard<std::mutex> guard {libsMutex};
1206  if (loadedLibs.count(path))
1207  {
1208  return true;
1209  }
1210  DynamicLibraryPtr lib(new DynamicLibrary());
1211  try
1212  {
1213  lib->load(path);
1214  }
1215  catch (...)
1216  {
1217  handleExceptions();
1218  return false;
1219  }
1220 
1221  if (lib->isLibraryLoaded())
1222  {
1223  ARMARX_INFO << "Loaded library " << path;
1224  loadedLibs[path] = lib;
1225  }
1226  else
1227  {
1228  ARMARX_ERROR << "Could not load lib " + path + ": " + lib->getErrorMessage();
1229  return false;
1230  }
1231  return true;
1232  }
1233  bool ArmarXManager::loadLibFromPath(const std::string& path, const Ice::Current&)
1234  {
1235  std::string absPath;
1236  if (ArmarXDataPath::getAbsolutePath(path, absPath))
1237  {
1238  return LoadLibFromAbsolutePath(absPath);
1239  }
1240  ARMARX_ERROR << "Could not find library " + path;
1241  return false;
1242  }
1243  bool ArmarXManager::loadLibFromPackage(const std::string& package, const std::string& libname, const Ice::Current&)
1244  {
1245  CMakePackageFinder finder(package);
1246  if (!finder.packageFound())
1247  {
1248  ARMARX_ERROR << "Could not find package '" << package << "'";
1249  return false;
1250  }
1251 
1252  for (auto libDirPath : Split(finder.getLibraryPaths(), ";"))
1253  {
1254  std::filesystem::path fullPath = libDirPath;
1255  fullPath /= "lib" + libname + "." + DynamicLibrary::GetSharedLibraryFileExtension();
1256  if (!std::filesystem::exists(fullPath))
1257  {
1258  fullPath = libDirPath;
1259  fullPath /= libname;
1260  if (!std::filesystem::exists(fullPath))
1261  {
1262  continue;
1263  }
1264  }
1265  if (LoadLibFromAbsolutePath(fullPath.string()))
1266  {
1267  return true;
1268  }
1269  }
1270  ARMARX_ERROR << "Could not find library " << libname << " in package " << package;
1271  return false;
1272  }
1273 
1274 
1275  StringVariantBaseMap armarx::ArmarXManager::getMetaInfo(const std::string& objectName, const Ice::Current&)
1276  {
1277  std::scoped_lock lock(managedObjectsMutex);
1278  StringStringDictionary propertyMap;
1279  ObjectSchedulerMap::iterator iter = managedObjects.find(objectName);
1280 
1281  if (iter == managedObjects.end())
1282  {
1283  return StringVariantBaseMap();
1284  }
1285 
1286  return iter->second->getObject()->getMetaInfoMap();
1287  }
1288 }
armarx::ArmarXManager::setComponentIceProperties
void setComponentIceProperties(const Ice::PropertiesPtr &properties)
Calls Component::setIceProperties() on all components assigend to this ArmarXManager Instance.
Definition: ArmarXManager.cpp:673
armarx::ArmarXManager::getApplicationPropertyInfos
ObjectPropertyInfos getApplicationPropertyInfos(const ::Ice::Current &) override
Definition: ArmarXManager.cpp:649
armarx::ArmarXManager::addObjectAsync
virtual void addObjectAsync(const ManagedIceObjectPtr &object, const std::string &objectName, bool addWithOwnAdapter=true, bool useOwnScheduleThread=true)
Definition: ArmarXManager.cpp:312
armarx::ArmarXManager::getObjectPropertyInfos
ObjectPropertyInfos getObjectPropertyInfos(const ::std::string &objectName, const ::Ice::Current &) override
Definition: ArmarXManager.cpp:622
ARMARX_VERBOSE
#define ARMARX_VERBOSE
Definition: Logging.h:180
armarx::MessageTypeT
MessageTypeT
Definition: LogSender.h:45
cyberglove_with_calib_22dof.ic
ic
Definition: cyberglove_with_calib_22dof.py:22
armarx::IceManager
The IceManager class provides simplified access to commonly used Ice features.
Definition: IceManager.h:105
armarx::Logging::minimumLoggingLevel
MessageTypeT minimumLoggingLevel
Definition: Logging.h:272
armarx::StringVariantBaseMap
std::map< std::string, VariantBasePtr > StringVariantBaseMap
Definition: ManagedIceObject.h:113
armarx::ArmarXManager::waitForShutdown
void waitForShutdown()
Wait for shutdown.
Definition: ArmarXManager.cpp:397
armarx::CMakePackageFinder::packageFound
bool packageFound() const
Returns whether or not this package was found with cmake.
Definition: CMakePackageFinder.cpp:485
armarx::DynamicLibraryPtr
std::shared_ptr< DynamicLibrary > DynamicLibraryPtr
Definition: DynamicLibrary.h:123
armarx::ArmarXManager::ArmarXManager
ArmarXManager(std::string applicationName, int port=4061, std::string host="localhost", std::string locatorName="IceGrid/Locator", Ice::StringSeq args=Ice::StringSeq())
ArmarXManager constructor.
Definition: ArmarXManager.cpp:95
armarx::IcePropertyChangeCallbackPtr
IceUtil::Handle< IcePropertyChangeCallback > IcePropertyChangeCallbackPtr
Definition: ArmarXManager.cpp:740
armarx::LogSender::SetGlobalMinimumLoggingLevel
static void SetGlobalMinimumLoggingLevel(MessageTypeT level)
With setGlobalMinimumLoggingLevel the minimum verbosity-level of log-messages can be set for the whol...
Definition: LogSender.cpp:670
armarx::ProxyType::component
@ component
ArmarXManager.h
armarx::SharedRemoteHandleState
This holds the shared state of all RemoteHandleControlBlocks for one armarx manager.
Definition: RemoteHandleControlBlock.h:52
armarx::LogPrx
::IceInternal::ProxyHandle< ::IceProxy::armarx::Log > LogPrx
Definition: LogSender.h:58
armarx::ArmarXManager::enableProfiling
void enableProfiling(bool enable)
Enable or disable profiling of CPU Usage.
Definition: ArmarXManager.cpp:209
DynamicLibrary.h
armarx::ArmarXManager::getAdapter
const Ice::ObjectAdapterPtr & getAdapter() const
Definition: ArmarXManager.cpp:1181
armarx::ArmarXManager::CheckIceConnection
static bool CheckIceConnection(const Ice::CommunicatorPtr &communicator, bool printHint)
Definition: ArmarXManager.cpp:129
armarx::IcePropertyChangeCallback
Definition: ArmarXManager.cpp:720
armarx::Split
std::vector< std::string > Split(const std::string &source, const std::string &splitBy, bool trimElements=false, bool removeEmptyElements=false)
Definition: StringHelperTemplates.h:35
armarx::LogSender::SetSendLoggingActivated
static void SetSendLoggingActivated(bool activated=true)
Definition: LogSender.cpp:701
armarx::ArmarXManager::increaseSchedulers
void increaseSchedulers(int increaseBy)
increased the number of single threaded schedulers.
Definition: ArmarXManager.cpp:1191
armarx::ArmarXManager::isShutdown
bool isShutdown()
Whether ArmarXManager shutdown has been finished.
Definition: ArmarXManager.cpp:513
armarx::CMakePackageFinder
The CMakePackageFinder class provides an interface to the CMake Package finder capabilities.
Definition: CMakePackageFinder.h:53
PeriodicTask.h
c
constexpr T c
Definition: UnscentedKalmanFilterTest.cpp:43
armarx::CMakePackageFinder::getLibraryPaths
std::string getLibraryPaths() const
Returns the library paths seperated by semi-colons.
Definition: CMakePackageFinder.h:128
FactoryCollectionBase.h
armarx::ThreadList::getApplicationThreadList
static ThreadListPtr getApplicationThreadList()
getApplicationThreadList retrieves the ThreadList, that contains all TimerTasks and PeriodicTasks in ...
Definition: ThreadList.cpp:189
armarx::ManagedIceObject::GetObjectStateAsString
static std::string GetObjectStateAsString(int state)
Definition: ManagedIceObject.cpp:213
armarx::ArmarXManager::getMetaInfo
StringVariantBaseMap getMetaInfo(const std::string &, const Ice::Current &) override
Definition: ArmarXManager.cpp:1275
ArmarXObjectObserver.h
armarx::DynamicLibrary::GetSharedLibraryFileExtension
static std::string GetSharedLibraryFileExtension()
Definition: DynamicLibrary.cpp:157
armarx::ArmarXManager::loadLibFromPath
bool loadLibFromPath(const std::string &path, const Ice::Current &=Ice::emptyCurrent) override
Definition: ArmarXManager.cpp:1233
armarx::ArmarXManager::getManagedObjects
std::vector< ManagedIceObjectPtr > getManagedObjects() override
Retrieve pointers to all ManagedIceObject.
Definition: ArmarXManager.cpp:534
IceInternal::Handle< ::Ice::Communicator >
armarx::ArmarXManager::PeriodicTask< ArmarXManager >
friend class PeriodicTask< ArmarXManager >
Definition: ArmarXManager.h:100
armarx::GetHandledExceptionString
std::string GetHandledExceptionString()
Definition: Exception.cpp:148
GfxTL::Identity
void Identity(MatrixXX< N, N, T > *a)
Definition: MatrixXX.h:523
armarx::IcePropertyChangeCallback::IcePropertyChangeCallback
IcePropertyChangeCallback(armarx::ApplicationPtr application)
Definition: ArmarXManager.cpp:724
LocalTimeServer.h
armarx::ArmarXManager::getSharedRemoteHandleState
const std::shared_ptr< SharedRemoteHandleState > & getSharedRemoteHandleState() const
Definition: ArmarXManager.cpp:1186
Property.h
ManagedIceObject.h
armarx::ArmarXManager::updateComponentIceProperties
void updateComponentIceProperties(const Ice::PropertyDict &properties)
Definition: ArmarXManager.cpp:685
armarx::ArmarXManager::getPropertiesAdmin
Ice::PropertiesAdminPrx getPropertiesAdmin(const Ice::Current &=Ice::emptyCurrent) override
Definition: ArmarXManager.cpp:666
armarx::ArmarXManager::removeObjectNonBlocking
void removeObjectNonBlocking(const ManagedIceObjectPtr &object) override
Removes an object from the manager.
Definition: ArmarXManager.cpp:389
armarx::ArmarXManager::addObject
void addObject(const ManagedIceObjectPtr &object, bool addWithOwnAdapter=true, const std::string &objectName="", bool useOwnScheduleThread=true) override
Add a ManagedIceObject to the manager.
Definition: ArmarXManager.cpp:230
RemoteHandleControlBlock.h
armarx::ArmarXObjectScheduler
Takes care of the lifecycle management of ManagedIceObjects.
Definition: ArmarXObjectScheduler.h:74
armarx::FactoryCollectionBase::PreregistrationList
static std::vector< FactoryCollectionBasePtr > & PreregistrationList()
Definition: FactoryCollectionBase.cpp:57
armarx::RemoteReferenceCountControlBlockManager
Definition: RemoteReferenceCount.h:250
ThreadList.h
armarx::ArmarXManager::enableLogging
void enableLogging(bool enable)
Enable or disable logging.
Definition: ArmarXManager.cpp:203
armarx::ArmarXMultipleObjectsScheduler
Definition: ArmarXMultipleObjectsScheduler.h:37
IceManager.h
ArmarXObjectScheduler.h
IceGridAdmin.h
armarx::ApplicationPtr
IceUtil::Handle< Application > ApplicationPtr
Definition: Application.h:93
armarx::ArmarXManager::loadLibFromPackage
bool loadLibFromPackage(const std::string &package, const std::string &lib, const Ice::Current &=Ice::emptyCurrent) override
Definition: ArmarXManager.cpp:1243
ARMARX_ERROR
#define ARMARX_ERROR
Definition: Logging.h:189
armarx::ArmarXManager::checkIceConnection
bool checkIceConnection(bool printHint=true) const
Definition: ArmarXManager.cpp:124
armarx::ArmarXManager::ArmarXObjectObserver
friend class ArmarXObjectObserver
Definition: ArmarXManager.h:101
armarx::Application::getInstance
static ApplicationPtr getInstance()
Retrieve shared pointer to the application object.
Definition: Application.cpp:288
armarx::ArmarXObjectSchedulerPtr
IceUtil::Handle< ArmarXObjectScheduler > ArmarXObjectSchedulerPtr
Definition: ArmarXFwd.h:33
armarx::ArmarXDataPath::initDataPaths
static void initDataPaths(const std::string &dataPathList)
Definition: ArmarXDataPath.cpp:477
armarx::ArmarXManager::getObjectState
ManagedIceObjectState getObjectState(const std::string &objectName, const Ice::Current &c=Ice::emptyCurrent) override
Retrieve state of a ManagedIceObject.
Definition: ArmarXManager.cpp:559
Component.h
armarx::ArmarXManager::getObjectProperties
::armarx::StringStringDictionary getObjectProperties(const ::std::string &objectName, const ::Ice::Current &=Ice::emptyCurrent) override
getObjectProperties is used to retrieve the properties of an object
Definition: ArmarXManager.cpp:601
ExpressionException.h
Ice
Definition: DBTypes.cpp:64
armarx::TimeUtil::SetTimeServer
static void SetTimeServer(LocalTimeServerPtr ts)
Definition: TimeUtil.cpp:99
ARMARX_CHECK_EXPRESSION
#define ARMARX_CHECK_EXPRESSION(expression)
This macro evaluates the expression and if it turns out to be false it will throw an ExpressionExcept...
Definition: ExpressionException.h:70
armarx::LogSender::SetLoggingActivated
static void SetLoggingActivated(bool activated=true, bool showMessage=true)
setLoggingActivated() is used to activate or disable the logging facilities in the whole application
Definition: LogSender.cpp:687
TimeUtil.h
ARMARX_INFO
#define ARMARX_INFO
Definition: Logging.h:174
armarx::ArmarXManager::setDataPaths
void setDataPaths(std::string dataPaths)
Set data paths used to search for datafiles.
Definition: ArmarXManager.cpp:220
armarx::ArmarXManager::getObjectConnectivity
ManagedIceObjectConnectivity getObjectConnectivity(const std::string &objectName, const Ice::Current &c=Ice::emptyCurrent) override
Retrieve connectivity of a ManagedIceObject.
Definition: ArmarXManager.cpp:579
armarx::LogSender::setProxy
static void setProxy(const std::string &componentName, LogPrx logProxy)
Definition: LogSender.cpp:129
IceUtil::Handle< ArmarXObjectScheduler >
LogSender.h
armarx::FactoryCollectionBase_RegistrationListMutex
std::mutex & FactoryCollectionBase_RegistrationListMutex()
Definition: FactoryCollectionBase.cpp:35
armarx::SharedRemoteHandleState::DEFAULT_DELETION_DELAY
static const unsigned int DEFAULT_DELETION_DELAY
The amount of time (in ms) required to pass after a RemoteHandleControlBlock's usecount has reacht ze...
Definition: RemoteHandleControlBlock.h:58
armarx::ArmarXManager::getManagedObjectNames
Ice::StringSeq getManagedObjectNames(const Ice::Current &c=Ice::emptyCurrent) override
Retrieve the names of all ManagedIceObject.
Definition: ArmarXManager.cpp:698
ManagedIceObjectRegistryInterface.h
armarx::Logging::deactivateSpam
SpamFilterDataPtr deactivateSpam(float deactivationDurationSec=10.0f, const std::string &identifier="", bool deactivate=true) const
disables the logging for the current line for the given amount of seconds.
Definition: Logging.cpp:92
armarx::IceManager::GetTopicManager
static IceStorm::TopicManagerPrx GetTopicManager(Ice::CommunicatorPtr communicator)
Definition: IceManager.cpp:263
armarx::ArmarXManager::removeObjectBlocking
void removeObjectBlocking(const ManagedIceObjectPtr &object) override
Removes an object from the manager.
Definition: ArmarXManager.cpp:384
armarx::ArmarXDataPath::getAbsolutePath
static bool getAbsolutePath(const std::string &relativeFilename, std::string &storeAbsoluteFilename, const std::vector< std::string > &additionalSearchPaths={}, bool verbose=true)
Definition: ArmarXDataPath.cpp:111
armarx::LocalTimeServer::getApplicationTimeServer
static LocalTimeServerPtr getApplicationTimeServer()
Get the applications LocalTimeServer instance.
Definition: LocalTimeServer.cpp:109
armarx::ArmarXManager::registerKnownObjectFactoriesWithIce
void registerKnownObjectFactoriesWithIce()
non static convenience version of ArmarXManager::RegisterKnownObjectFactoriesWithIce()
Definition: ArmarXManager.cpp:1176
armarx::aron::type::ObjectPtr
std::shared_ptr< Object > ObjectPtr
Definition: Object.h:37
armarx::Logging::setTag
void setTag(const LogTag &tag)
Definition: Logging.cpp:55
armarx::DynamicLibrary
The DynamicLibrary class provides a mechanism to load libraries at runtime.
Definition: DynamicLibrary.h:49
ArmarXMultipleObjectsScheduler.h
Logging.h
armarx::ArmarXManager::shutdown
void shutdown()
Shuts down the ArmarXManager.
Definition: ArmarXManager.cpp:415
armarx::ScopedRecursiveLockPtr
std::shared_ptr< ScopedRecursiveLock > ScopedRecursiveLockPtr
Definition: Synchronization.h:143
armarx::handleExceptions
void handleExceptions()
Definition: Exception.cpp:142
armarx::ArmarXManager::~ArmarXManager
~ArmarXManager() override
Definition: ArmarXManager.cpp:118
ApplicationProcessFacet.h
ARMARX_WARNING
#define ARMARX_WARNING
Definition: Logging.h:186
armarx::LoadLibFromAbsolutePath
bool LoadLibFromAbsolutePath(const std::string &path)
Definition: ArmarXManager.cpp:1200
armarx::ArmarXManager::getCommunicator
const Ice::CommunicatorPtr & getCommunicator() const
Definition: ArmarXManager.cpp:529
ArmarXDataPath.h
armarx
This file offers overloads of toIce() and fromIce() functions for STL container types.
Definition: ArmarXTimeserver.cpp:28
Exception.h
armarx::ArmarXManager::RegisterKnownObjectFactoriesWithIce
static void RegisterKnownObjectFactoriesWithIce(const Ice::CommunicatorPtr &ic)
Registers all object factories that are known with Ice.
Definition: ArmarXManager.cpp:1157
armarx::ArmarXManager::asyncShutdown
void asyncShutdown(std::size_t timeoutMs=0)
Calls shutdown() after a timeout.
Definition: ArmarXManager.cpp:504
Application.h
armarx::ArmarXManager::setGlobalMinimumLoggingLevel
void setGlobalMinimumLoggingLevel(MessageTypeT minimumLoggingLevel)
Set minimum logging level to output in log stream.
Definition: ArmarXManager.cpp:215
armarx::IcePropertyChangeCallback::updated
void updated(const Ice::PropertyDict &changes) override
Definition: ArmarXManager.cpp:729
armarx::ArmarXManager::getIceManager
const IceManagerPtr & getIceManager() const
Retrieve the instance of the icemanager.
Definition: ArmarXManager.cpp:524