def readPackageCMakeData(rosDebYamlFileName): """ Read the cmake meta data for packages from a cmake yaml file: package1: xenial/trusty: name: ... include_dirs: [] library_dirs: [] libraries: [] components: [] """ # load ros dep yaml file f = open(rosDebYamlFileName, "r") rosDebYamlData = yaml.load(f, Loader=Loader) # dictionary for storing cmake dependencies # e.g. { "<package name 1>" -> PackageCMakeData, "<package name 2>" -> PackageCMakeData ... } data = {} distribution = OsDetect().detect_os()[2] for packageName, packageCMakeData in rosDebYamlData.items(): # find out which distribution if "name" in packageCMakeData: data[packageName] = PackageCMakeData(packageCMakeData) elif distribution in packageCMakeData: data[packageName] = PackageCMakeData( packageCMakeData[distribution]) elif not packageCMakeData: data[packageName] = PackageCMakeData() # placeholder return data
def test_OsDetect_single(): # test each method twice with new instance b/c of caching from rospkg.os_detect import OsDetect detect = OsDetect([('TrueOs', TrueOs())]) assert "TrueOs" == detect.get_name() assert "TrueOs" == detect.get_name() detect = OsDetect([('TrueOs', TrueOs())]) assert "os_version" == detect.get_version() assert "os_version" == detect.get_version() detect = OsDetect([('TrueOs', TrueOs())]) assert "os_codename" == detect.get_codename() assert "os_codename" == detect.get_codename() detect = OsDetect([('TrueOs', TrueOs())]) assert isinstance(detect.get_detector(), TrueOs) assert isinstance(detect.get_detector('TrueOs'), TrueOs)
def __init__(self, stop_app_postexec_fn): ''' @param stop_app_postexec_fn : callback to fire when a listener detects an app getting stopped. @type method with no args ''' self._stop_app_postexec_fn = stop_app_postexec_fn self.app_list = {} self.rocon_master_info = {} self.is_connect = False self.is_app_running = False self.key = uuid.uuid4() self.app_pid = 0 # this might be naive and only work well on ubuntu... os_codename = OsDetect().get_codename() # this would be great as a configurable parameter name = "rqt_remocon_" + self.key.hex self.rocon_uri = rocon_uri.parse( "rocon:/pc/" + name + "/" + rocon_std_msgs.Strings.URI_WILDCARD + "/" + os_codename ) # be also great to have a configurable icon...with a default self.platform_info = rocon_std_msgs.PlatformInfo(version=rocon_std_msgs.Strings.ROCON_VERSION, uri=str(self.rocon_uri), icon=rocon_std_msgs.Icon() ) print("[remocon_info] info component initialised")
def test_OsDetect(): from rospkg.os_detect import OsDetect detect = OsDetect() try: detect.get_detector('fake') assert False, "should raise" except KeyError: pass
def auto_detected_triplet(): machine_name = platform.machine().lower() os_name = OsDetect().get_name().lower() if machine_name in ['amd64', 'x86_64']: return 'x64-%s' % os_name elif machine_name in ['i386', 'i686']: return 'x86-%s' % os_name else: raise RosdepInternalError
def test_OsDetect_ROS_OVERRIDE(): from rospkg.os_detect import OsDetect detect = OsDetect([('TrueOs', TrueOs())]) env = {'ROS_OS_OVERRIDE': 'arch'} assert detect.detect_os(env=env) == ('arch', '', ''), \ detect.detect_os(env=env) env = {'ROS_OS_OVERRIDE': 'fubuntu:04.10'} assert detect.detect_os(env=env) == ('fubuntu', '04.10', '') env = {'ROS_OS_OVERRIDE': 'fubuntu:04.10:opaque'} assert detect.detect_os(env=env) == ('fubuntu', '04.10', 'opaque')
def test_OsDetect_register_default_add_detector(): # test behavior of register_default and add_detector. Both take # precedence over previous detectors, but at different scopes. from rospkg.os_detect import OsDetect o1 = TrueOs() o2 = TrueOs2() key = 'TrueOs' detect = OsDetect([(key, o1)]) assert detect.get_detector(key) == o1 detect.register_default(key, o2) assert detect.get_detector(key) == o1 detect.add_detector(key, o2) assert detect.get_detector(key) == o2 detect = OsDetect() assert detect.get_detector(key) == o2 detect.add_detector(key, o1) assert detect.get_detector(key) == o1 # restore precendence of o1 in default list detect.register_default(key, o1) detect = OsDetect() assert detect.get_detector(key) == o1
def test_InstallerContext_ctor(): from rosdep2.installers import InstallerContext from rospkg.os_detect import OsDetect context = InstallerContext() assert context.get_os_detect() is not None assert isinstance(context.get_os_detect(), OsDetect) detect = OsDetect() context = InstallerContext(detect) assert context.get_os_detect() == detect assert len(context.get_installer_keys()) == 0 assert len(context.get_os_keys()) == 0 context.verbose = True assert context.get_os_detect() == detect assert len(context.get_installer_keys()) == 0 assert len(context.get_os_keys()) == 0
def test_OsDetect_nomatch(): from rospkg.os_detect import OsDetect, OsNotDetected detect = OsDetect([('Dummy', FalseOs())]) assert isinstance(detect.get_detector('Dummy'), FalseOs) try: detect.get_name() assert False except OsNotDetected: pass try: detect.get_version() assert False except OsNotDetected: pass try: detect.get_detector() assert False except OsNotDetected: pass
def __init__(self, stop_interaction_postexec_fn): ''' @param stop_app_postexec_fn : callback to fire when a listener detects an app getting stopped. @type method with no args ''' self._interactions_table = InteractionsTable() self._stop_interaction_postexec_fn = stop_interaction_postexec_fn self.is_connect = False self.key = uuid.uuid4() self._ros_master_port = None try: self._roslaunch_terminal = rocon_launch.create_terminal() except (rocon_launch.UnsupportedTerminal, rocon_python_comms.NotFoundException) as e: console.warning( "Cannot find a suitable terminal, falling back to the current terminal [%s]" % str(e)) self._roslaunch_terminal = rocon_launch.create_terminal( rocon_launch.terminals.active) # this might be naive and only work well on ubuntu... os_codename = OsDetect().get_codename() webbrowser_codename = utils.get_web_browser_codename() # this would be good as a persistant variable so the user can set something like 'Bob' self.name = "rqt_remocon_" + self.key.hex self.rocon_uri = rocon_uri.parse("rocon:/pc/" + self.name + "/" + rocon_std_msgs.Strings.URI_WILDCARD + "/" + os_codename + "|" + webbrowser_codename) # be also great to have a configurable icon...with a default self.platform_info = rocon_std_msgs.PlatformInfo( version=rocon_std_msgs.Strings.ROCON_VERSION, uri=str(self.rocon_uri), icon=rocon_std_msgs.Icon()) console.logdebug("Interactive Client : initialised") self.pairing = None # if an interaction is currently pairing, this will store its hash # expose underlying functionality higher up self.interactions = self._interactions_table.generate_role_view """Get a dictionary of interactions belonging to the specified role."""
def __init__(self, os_detect=None): """ :param os_detect: (optional) :class:`rospkg.os_detect.OsDetect` instance to use for detecting platforms. If `None`, default instance will be used. """ # platform configuration self.installers = {} self.os_installers = {} self.default_os_installer = {} # stores configuration of which value to use for the OS version key (version number or codename) self.os_version_type = {} # OS detection and override if os_detect is None: os_detect = OsDetect() self.os_detect = os_detect self.os_override = None self.verbose = False
def test_ubuntu(): from rospkg.os_detect import OsDetect, OsNotDetected os_detector = OsDetect() detect = os_detector.get_detector('ubuntu') detect.lsb_info = ('Ubuntu', '10.04', 'lucid') assert detect.get_version() == '10.04', detect.get_version() assert detect.get_codename() == 'lucid', detect.get_codename() # test freely if not detect.is_os(): try: detect.get_version() assert False except OsNotDetected: pass try: detect.get_codename() assert False except OsNotDetected: pass
def test_InstallerContext_installers(): from rosdep2.installers import InstallerContext, Installer from rospkg.os_detect import OsDetect detect = OsDetect() context = InstallerContext(detect) context.verbose = True key = 'fake-apt' try: installer = context.get_installer(key) assert False, "should have raised: %s" % (installer) except KeyError: pass class Foo: pass class FakeInstaller(Installer): pass class FakeInstaller2(Installer): pass # test TypeError on set_installer try: context.set_installer(key, 1) assert False, "should have raised" except TypeError: pass try: context.set_installer(key, Foo()) assert False, "should have raised" except TypeError: pass try: # must be instantiated context.set_installer(key, FakeInstaller) assert False, "should have raised" except TypeError: pass installer = FakeInstaller() installer2 = FakeInstaller2() context.set_installer(key, installer) assert context.get_installer(key) == installer assert list(context.get_installer_keys()) == [key] # repeat with same args context.set_installer(key, installer) assert context.get_installer(key) == installer assert list(context.get_installer_keys()) == [key] # repeat with new installer context.set_installer(key, installer2) assert context.get_installer(key) == installer2 assert list(context.get_installer_keys()) == [key] # repeat with new key key2 = 'fake-port' context.set_installer(key2, installer2) assert context.get_installer(key2) == installer2 assert set(context.get_installer_keys()) == set([key, key2]) # test installer deletion key3 = 'fake3' context.set_installer(key3, installer2) assert context.get_installer(key3) == installer2 assert set(context.get_installer_keys()) == set([key, key2, key3]) context.set_installer(key3, None) try: context.get_installer(key3) assert False except KeyError: pass assert set(context.get_installer_keys()) == set([key, key2])
def test_tripwire_ubuntu(): from rospkg.os_detect import OsDetect os_detect = OsDetect() os_detect.get_detector('ubuntu')
def test_tripwire_manjaro(): from rospkg.os_detect import OsDetect os_detect = OsDetect() os_detect.get_detector('manjaro')
def test_tripwire_freebsd(): from rospkg.os_detect import OsDetect os_detect = OsDetect() os_detect.get_detector('freebsd')
def test_tripwire_centos(): from rospkg.os_detect import OsDetect os_detect = OsDetect() os_detect.get_detector('centos')
def test_tripwire_osx(): from rospkg.os_detect import OsDetect os_detect = OsDetect() os_detect.get_detector('osx')
def test_tripwire_slackware(): from rospkg.os_detect import OsDetect os_detect = OsDetect() os_detect.get_detector('slackware')
def test_tripwire_fedora(): from rospkg.os_detect import OsDetect os_detect = OsDetect() os_detect.get_detector('fedora')
def test_tripwire_gentoo(): from rospkg.os_detect import OsDetect os_detect = OsDetect() os_detect.get_detector('gentoo')
def test_tripwire_opensuse(): from rospkg.os_detect import OsDetect os_detect = OsDetect() os_detect.get_detector('opensuse')
def test_InstallerContext_os_installers(): from rosdep2.installers import InstallerContext, Installer from rospkg.os_detect import OsDetect detect = OsDetect() context = InstallerContext(detect) context.verbose = True os_key = 'ubuntu' try: context.get_os_installer_keys(os_key) assert False, "should have raised" except KeyError: pass try: context.get_default_os_installer_key(os_key) assert False, "should have raised" except KeyError: pass try: context.add_os_installer_key(os_key, 'fake-key') assert False, "should have raised" except KeyError: pass try: context.set_default_os_installer_key(os_key, 'non-method') assert False, "should have raised" except KeyError: pass try: context.set_default_os_installer_key(os_key, lambda self: 'fake-key') assert False, "should have raised" except KeyError: pass try: context.get_default_os_installer_key('bad-os') assert False, "should have raised" except KeyError: pass installer_key1 = 'fake1' installer_key2 = 'fake2' class FakeInstaller(Installer): pass class FakeInstaller2(Installer): pass # configure our context with two valid installers context.set_installer(installer_key1, FakeInstaller()) context.set_installer(installer_key2, FakeInstaller2()) # start adding installers for os_key context.add_os_installer_key(os_key, installer_key1) assert context.get_os_installer_keys(os_key) == [installer_key1] # retest set_default_os_installer_key, now with installer_key not configured on os try: context.set_default_os_installer_key(os_key, lambda self: installer_key2) assert False, "should have raised" except KeyError as e: assert 'add_os_installer' in str(e), e # now properly add in key2 context.add_os_installer_key(os_key, installer_key2) assert set(context.get_os_installer_keys(os_key)) == set( [installer_key1, installer_key2]) # test default assert None == context.get_default_os_installer_key(os_key) context.set_default_os_installer_key(os_key, lambda self: installer_key1) assert installer_key1 == context.get_default_os_installer_key(os_key) context.set_default_os_installer_key(os_key, lambda self: installer_key2) assert installer_key2 == context.get_default_os_installer_key(os_key) # retest set_default_os_installer_key, now with invalid os try: context.set_default_os_installer_key('bad-os', lambda self: installer_key1) assert False, "should have raised" except KeyError: pass
def test_tripwire_debian(): from rospkg.os_detect import OsDetect os_detect = OsDetect() os_detect.get_detector('debian')
def test_tripwire_rhel(): from rospkg.os_detect import OsDetect os_detect = OsDetect() os_detect.get_detector('rhel')
def test_tripwire_arch(): from rospkg.os_detect import OsDetect os_detect = OsDetect() os_detect.get_detector('arch')