def _build_environment(self): env = os.environ.copy() env['GOPATH'] = self._gopath env['GOBIN'] = self._gopath_bin include_paths = [] for root in [self.installdir, self.project.stage_dir]: include_paths.extend( common.get_library_paths(root, self.project.arch_triplet)) flags = common.combine_paths(include_paths, '-L', ' ') env['CGO_LDFLAGS'] = '{} {} {}'.format( env.get('CGO_LDFLAGS', ''), flags, env.get('LDFLAGS', '')) if self.project.is_cross_compiling: env['CC'] = '{}-gcc'.format(self.project.arch_triplet) env['CXX'] = '{}-g++'.format(self.project.arch_triplet) env['CGO_ENABLED'] = '1' # See https://golang.org/doc/install/source#environment go_archs = { 'armhf': 'arm', 'i386': '386', 'ppc64el': 'ppc64le', } env['GOARCH'] = go_archs.get(self.project.deb_arch, self.project.deb_arch) if self.project.deb_arch == 'armhf': env['GOARM'] = '7' return env
def _build_environment(self): env = os.environ.copy() env["GOPATH"] = self._gopath env["GOBIN"] = self._gopath_bin include_paths = [] for root in [self.installdir, self.project.stage_dir]: include_paths.extend( common.get_library_paths(root, self.project.arch_triplet)) flags = common.combine_paths(include_paths, "-L", " ") env["CGO_LDFLAGS"] = "{} {} {}".format(env.get("CGO_LDFLAGS", ""), flags, env.get("LDFLAGS", "")) if self.project.is_cross_compiling: env["CC"] = "{}-gcc".format(self.project.arch_triplet) env["CXX"] = "{}-g++".format(self.project.arch_triplet) env["CGO_ENABLED"] = "1" # See https://golang.org/doc/install/source#environment go_archs = {"armhf": "arm", "i386": "386", "ppc64el": "ppc64le"} env["GOARCH"] = go_archs.get(self.project.deb_arch, self.project.deb_arch) if self.project.deb_arch == "armhf": env["GOARM"] = "7" return env
def _extra_config(self): extra_config = [] print(self.installdir) for root in [self.installdir, self.project.stage_dir]: paths = common.get_library_paths(root, self.project.arch_triplet) for path in paths: extra_config.append("LIBS+=\"-L{}\"".format(path)) extra_config.append("LIBS+=\"-L{}\"".format( QmakePlugin._build_qt_path('lib'))) extra_config.append("QMAKE_LIBS+=\"-L{}\"".format( QmakePlugin._build_qt_path('lib'))) extra_config.append("QMAKE_LIBDIR+=\"{}\"".format( QmakePlugin._build_qt_path('lib'))) paths = common.get_include_paths(root, self.project.arch_triplet) for path in paths: extra_config.append("INCLUDEPATH+=\"{}\"".format(path)) extra_config.append("INCLUDEPATH+=\"{}\"".format( QmakePlugin._build_qt_path('include'))) extra_config.append("QML_IMPORT_PATH+=\"{}\"".format( QmakePlugin._build_qt_path('qml'))) extra_config.append("QML2_IMPORT_PATH+=\"{}\"".format( QmakePlugin._build_qt_path('qml'))) return extra_config
def _build_environment(self): env = os.environ.copy() env['GOPATH'] = self._gopath env['GOBIN'] = self._gopath_bin include_paths = [] for root in [self.installdir, self.project.stage_dir]: include_paths.extend( common.get_library_paths(root, self.project.arch_triplet)) flags = common.combine_paths(include_paths, '-L', ' ') env['CGO_LDFLAGS'] = '{} {} {}'.format(env.get('CGO_LDFLAGS', ''), flags, env.get('LDFLAGS', '')) if self.project.is_cross_compiling: env['CC'] = '{}-gcc'.format(self.project.arch_triplet) env['CXX'] = '{}-g++'.format(self.project.arch_triplet) env['CGO_ENABLED'] = '1' # See https://golang.org/doc/install/source#environment go_archs = { 'armhf': 'arm', 'i386': '386', 'ppc64el': 'ppc64le', } env['GOARCH'] = go_archs.get(self.project.deb_arch, self.project.deb_arch) if self.project.deb_arch == 'armhf': env['GOARM'] = '7' return env
def _build_environment(self) -> Dict[str, str]: env = os.environ.copy() env["GOPATH"] = self._gopath env["GOBIN"] = self._gopath_bin library_paths: List[str] = [] for root in [self.installdir, self.project.stage_dir]: library_paths.extend( common.get_library_paths(root, self.project.arch_triplet)) cgo_ldflags = _get_cgo_ldflags(library_paths) if cgo_ldflags: env["CGO_LDFLAGS"] = cgo_ldflags if self.project.is_cross_compiling: env["CC"] = "{}-gcc".format(self.project.arch_triplet) env["CXX"] = "{}-g++".format(self.project.arch_triplet) env["CGO_ENABLED"] = "1" # See https://golang.org/doc/install/source#environment go_archs = {"armhf": "arm", "i386": "386", "ppc64el": "ppc64le"} env["GOARCH"] = go_archs.get(self.project.deb_arch, self.project.deb_arch) if self.project.deb_arch == "armhf": env["GOARM"] = "7" return env
def _build_environment(self): env = os.environ.copy() env["GOPATH"] = self._gopath env["GOBIN"] = self._gopath_bin include_paths = [] for root in [self.installdir, self.project.stage_dir]: include_paths.extend( common.get_library_paths(root, self.project.arch_triplet) ) flags = common.combine_paths(include_paths, "-L", " ") env["CGO_LDFLAGS"] = "{} {} {}".format( env.get("CGO_LDFLAGS", ""), flags, env.get("LDFLAGS", "") ) if self.project.is_cross_compiling: env["CC"] = "{}-gcc".format(self.project.arch_triplet) env["CXX"] = "{}-g++".format(self.project.arch_triplet) env["CGO_ENABLED"] = "1" # See https://golang.org/doc/install/source#environment go_archs = {"armhf": "arm", "i386": "386", "ppc64el": "ppc64le"} env["GOARCH"] = go_archs.get(self.project.deb_arch, self.project.deb_arch) if self.project.deb_arch == "armhf": env["GOARM"] = "7" return env
def env(self, root): """Runtime environment for ROS binaries and services.""" paths = common.get_library_paths(root, self.project.arch_triplet) ld_library_path = formatting_utils.combine_paths(paths, prepend='', separator=':') env = [ # This environment variable tells ROS nodes where to find ROS # master. It does not affect ROS master, however-- this is just the # default URI. 'ROS_MASTER_URI=http://localhost:11311', # Various ROS tools (e.g. rospack, roscore) keep a cache or a log, # and use $ROS_HOME to determine where to put them. 'ROS_HOME=${SNAP_USER_DATA:-/tmp}/ros', # FIXME: LP: #1576411 breaks ROS snaps on the desktop, so we'll # temporarily work around that bug by forcing the locale to # C.UTF-8. 'LC_ALL=C.UTF-8', # The Snapcraft Core will ensure that we get a good LD_LIBRARY_PATH # overall, but it defines it after this function runs. Some ROS # tools will cause binaries to be run when we source the setup.sh, # below, so we need to have a sensible LD_LIBRARY_PATH before then. 'LD_LIBRARY_PATH=$LD_LIBRARY_PATH:{}'.format(ld_library_path), ] # There's a chicken and egg problem here, everything run get's an # env built, even package installation, so the first runs for these # will likely fail. try: # The ROS packaging system tools (e.g. rospkg, etc.) don't go # into the ROS install path (/opt/ros/$distro), so we need the # PYTHONPATH to include the dist-packages in /usr/lib as well. env.append('PYTHONPATH={0}:$PYTHONPATH'.format( common.get_python2_path(root))) except EnvironmentError as e: logger.debug(e) # The setup.sh we source below requires the in-snap python. Here we # make sure it's in the PATH before it's run. env.append('PATH=$PATH:{}/usr/bin'.format(root)) if self.options.underlay: script = '. {}'.format( os.path.join(self.rosdir, 'snapcraft-setup.sh')) else: script = self._source_setup_sh(root, None) # Each of these lines is prepended with an `export` when the # environment is actually generated. In order to inject real shell code # we have to hack it in by appending it on the end of an item already # in the environment. FIXME: There should be a better way to do this. env[-1] = env[-1] + '\n\n' + script return env
def _extra_config(self): extra_config = [] for root in [self.installdir, self.project.stage_dir]: paths = common.get_library_paths(root, self.project.arch_triplet) for path in paths: extra_config.append("LIBS+=\"-L{}\"".format(path)) paths = common.get_include_paths(root, self.project.arch_triplet) for path in paths: extra_config.append("INCLUDEPATH+=\"{}\"".format(path)) return extra_config
def _build_environment(self): env = os.environ.copy() env['GOPATH'] = self._gopath include_paths = [] for root in [self.installdir, self.project.stage_dir]: include_paths.extend( common.get_library_paths(root, self.project.arch_triplet)) flags = common.combine_paths(include_paths, '-L', ' ') env['CGO_LDFLAGS'] = '{} {} {}'.format( env.get('CGO_LDFLAGS', ''), flags, env.get('LDFLAGS', '')) return env
def environment(self): env = os.environ.copy() paths = common.get_library_paths( self._compilers_install_path, self._project.arch_triplet) ld_library_path = formatting_utils.combine_paths( paths, prepend='', separator=':') env['LD_LIBRARY_PATH'] = ( env.get('LD_LIBRARY_PATH', '') + ':' + ld_library_path) env['PATH'] = env.get('PATH', '') + ':' + os.path.join( self._compilers_install_path, 'usr', 'bin') return env
def environment(self): env = os.environ.copy() paths = common.get_library_paths(self._compilers_install_path, self._project.arch_triplet) ld_library_path = formatting_utils.combine_paths(paths, prepend="", separator=":") env["LD_LIBRARY_PATH"] = env.get("LD_LIBRARY_PATH", "") + ":" + ld_library_path env["PATH"] = ( env.get("PATH", "") + ":" + os.path.join(self._compilers_install_path, "usr", "bin")) return env
def _build_environment(self): env = os.environ.copy() env['GOPATH'] = self._gopath # Add $GOPATH/bin so godeps is actually callable. env['PATH'] = '{}:{}'.format(os.path.join(self._gopath, 'bin'), env.get('PATH', '')) include_paths = [] for root in [self.installdir, self.project.stage_dir]: include_paths.extend( common.get_library_paths(root, self.project.arch_triplet)) flags = common.combine_paths(include_paths, '-L', ' ') env['CGO_LDFLAGS'] = '{} {} {}'.format(env.get('CGO_LDFLAGS', ''), flags, env.get('LDFLAGS', '')) return env
def _build_environment(self): env = os.environ.copy() env['GOPATH'] = self._gopath # Add $GOPATH/bin so godeps is actually callable. env['PATH'] = '{}:{}'.format( os.path.join(self._gopath, 'bin'), env.get('PATH', '')) include_paths = [] for root in [self.installdir, self.project.stage_dir]: include_paths.extend( common.get_library_paths(root, self.project.arch_triplet)) flags = common.combine_paths(include_paths, '-L', ' ') env['CGO_LDFLAGS'] = '{} {} {}'.format( env.get('CGO_LDFLAGS', ''), flags, env.get('LDFLAGS', '')) return env
def _build_environment(self): env = os.environ.copy() env["GOPATH"] = self._gopath env["GOBIN"] = self._gopath_bin # Add $GOPATH/bin so godeps is actually callable. env["PATH"] = "{}:{}".format(os.path.join(self._gopath, "bin"), env.get("PATH", "")) include_paths = [] for root in [self.installdir, self.project.stage_dir]: include_paths.extend( common.get_library_paths(root, self.project.arch_triplet)) flags = common.combine_paths(include_paths, "-L", " ") env["CGO_LDFLAGS"] = "{} {} {}".format(env.get("CGO_LDFLAGS", ""), flags, env.get("LDFLAGS", "")) return env
def environment(self): env = os.environ.copy() paths = common.get_library_paths( self._compilers_install_path, self._project.arch_triplet ) ld_library_path = formatting_utils.combine_paths( paths, prepend="", separator=":" ) env["LD_LIBRARY_PATH"] = env.get("LD_LIBRARY_PATH", "") + ":" + ld_library_path env["PATH"] = ( env.get("PATH", "") + ":" + os.path.join(self._compilers_install_path, "usr", "bin") ) return env
def _extra_config(self): extra_config = [] for root in [self.installdir, self.project.stage_dir]: paths = common.get_library_paths(root, self.project.arch_triplet) for path in paths: extra_config.append("LIBS+=\"-L{}\"".format(path)) extra_config.append("LIBS+=\"-L{}\"".format(self.project.parts_dir + '/qt-5-11-1/install/lib')) extra_config.append("QMAKE_LIBS+=\"-L{}\"".format(self.project.parts_dir + '/qt-5-11-1/install/lib')) extra_config.append("QMAKE_LIBDIR+=\"{}\"".format(self.project.parts_dir + '/qt-5-11-1/install/lib')) paths = common.get_include_paths(root, self.project.arch_triplet) for path in paths: extra_config.append("INCLUDEPATH+=\"{}\"".format(path)) extra_config.append("INCLUDEPATH+=\"{}\"".format(self.project.parts_dir + '/qt-5-11-1/install/include')) extra_config.append("QML_IMPORT_PATH+=\"{}\"".format(self.project.parts_dir + '/qt-5-11-1/install/qml')) extra_config.append("QML2_IMPORT_PATH+=\"{}\"".format(self.project.parts_dir + '/qt-5-11-1/install/qml')) return extra_config
def env(self, root): """Runtime environment for ROS binaries and services.""" env = [ # The Snapcraft Core will ensure that we get a good LD_LIBRARY_PATH # overall, but it defines it after this function runs. Some ROS # tools will cause binaries to be run when we source the setup.sh, # below, so we need to have a sensible LD_LIBRARY_PATH before then. 'LD_LIBRARY_PATH="$LD_LIBRARY_PATH:{}"'.format( formatting_utils.combine_paths( common.get_library_paths(root, self.project.arch_triplet), prepend="", separator=":", )) ] # Each of these lines is prepended with an `export` when the environment is # actually generated. In order to inject real shell code we have to hack it in # by appending it on the end of an item already in the environment. # FIXME: There should be a better way to do this. LP: #1792034 env[-1] = env[-1] + "\n\n" + self._source_setup_sh(root) return env
def env(self, root): """Runtime environment for ROS binaries and services.""" paths = common.get_library_paths(root, self.project.arch_triplet) ld_library_path = formatting_utils.combine_paths(paths, prepend="", separator=":") env = [ # This environment variable tells ROS nodes where to find ROS # master. It does not affect ROS master, however-- this is just the # URI. "ROS_MASTER_URI={}".format(self.options.catkin_ros_master_uri), # Various ROS tools (e.g. roscore) keep a cache or a log, # and use $ROS_HOME to determine where to put them. "ROS_HOME=${SNAP_USER_DATA:-/tmp}/ros", # FIXME: LP: #1576411 breaks ROS snaps on the desktop, so we'll # temporarily work around that bug by forcing the locale to # C.UTF-8. "LC_ALL=C.UTF-8", # The Snapcraft Core will ensure that we get a good LD_LIBRARY_PATH # overall, but it defines it after this function runs. Some ROS # tools will cause binaries to be run when we source the setup.sh, # below, so we need to have a sensible LD_LIBRARY_PATH before then. "LD_LIBRARY_PATH=$LD_LIBRARY_PATH:{}".format(ld_library_path), ] # There's a chicken and egg problem here, everything run gets an # env built, even package installation, so the first runs for these # will likely fail. try: # The ROS packaging system tools (e.g. rospkg, etc.) don't go # into the ROS install path (/opt/ros/$distro), so we need the # PYTHONPATH to include the dist-packages in /usr/lib as well. # # Note: Empty segments in PYTHONPATH are interpreted as `.`, thus # adding the current working directory to the PYTHONPATH. That is # not desired in this situation, so take proper precautions when # expanding PYTHONPATH: only add it if it's not empty. env.append("PYTHONPATH={}${{PYTHONPATH:+:$PYTHONPATH}}".format( common.get_python2_path(root))) except errors.SnapcraftEnvironmentError as e: logger.debug(e) # The setup.sh we source below requires the in-snap python. Here we # make sure it's in the PATH before it's run. env.append("PATH=$PATH:{}/usr/bin".format(root)) if self.options.underlay: script = textwrap.dedent(""" if [ -f {snapcraft_setup} ]; then . {snapcraft_setup} fi """).format(snapcraft_setup=os.path.join(self.rosdir, "snapcraft-setup.sh")) else: script = self._source_setup_sh(root, None) # Each of these lines is prepended with an `export` when the # environment is actually generated. In order to inject real shell code # we have to hack it in by appending it on the end of an item already # in the environment. FIXME: There should be a better way to do this. # LP: #1792034 env[-1] = env[-1] + "\n\n" + script return env
def ldflags(self): paths = common.get_library_paths( self._compilers_install_path, self._project.arch_triplet) return formatting_utils.combine_paths( paths, prepend='-L', separator=' ')
def ldflags(self): paths = common.get_library_paths(self._compilers_install_path, self._project.arch_triplet) return formatting_utils.combine_paths(paths, prepend='-L', separator=' ')
def env(self, root): """Runtime environment for ROS binaries and services.""" paths = common.get_library_paths(root, self.project.arch_triplet) ld_library_path = formatting_utils.combine_paths( paths, prepend='', separator=':') env = [ # This environment variable tells ROS nodes where to find ROS # master. It does not affect ROS master, however-- this is just the # URI. 'ROS_MASTER_URI={}'.format(self.options.catkin_ros_master_uri), # Various ROS tools (e.g. rospack, roscore) keep a cache or a log, # and use $ROS_HOME to determine where to put them. 'ROS_HOME=${SNAP_USER_DATA:-/tmp}/ros', # FIXME: LP: #1576411 breaks ROS snaps on the desktop, so we'll # temporarily work around that bug by forcing the locale to # C.UTF-8. 'LC_ALL=C.UTF-8', # The Snapcraft Core will ensure that we get a good LD_LIBRARY_PATH # overall, but it defines it after this function runs. Some ROS # tools will cause binaries to be run when we source the setup.sh, # below, so we need to have a sensible LD_LIBRARY_PATH before then. 'LD_LIBRARY_PATH=$LD_LIBRARY_PATH:{}'.format(ld_library_path), ] # There's a chicken and egg problem here, everything run get's an # env built, even package installation, so the first runs for these # will likely fail. try: # The ROS packaging system tools (e.g. rospkg, etc.) don't go # into the ROS install path (/opt/ros/$distro), so we need the # PYTHONPATH to include the dist-packages in /usr/lib as well. # # Note: Empty segments in PYTHONPATH are interpreted as `.`, thus # adding the current working directory to the PYTHONPATH. That is # not desired in this situation, so take proper precautions when # expanding PYTHONPATH: only add it if it's not empty. env.append('PYTHONPATH={}${{PYTHONPATH:+:$PYTHONPATH}}'.format( common.get_python2_path(root))) except errors.SnapcraftEnvironmentError as e: logger.debug(e) # The setup.sh we source below requires the in-snap python. Here we # make sure it's in the PATH before it's run. env.append('PATH=$PATH:{}/usr/bin'.format(root)) if self.options.underlay: script = '. {}'.format(os.path.join( self.rosdir, 'snapcraft-setup.sh')) else: script = self._source_setup_sh(root, None) # Each of these lines is prepended with an `export` when the # environment is actually generated. In order to inject real shell code # we have to hack it in by appending it on the end of an item already # in the environment. FIXME: There should be a better way to do this. env[-1] = env[-1] + '\n\n' + script return env