def tool(self, version): self._tools._fail_if_not_windows('msvc') try: environment_variable = self.versions[version] except KeyError: log.error("visual studio version '%s' is not supported" % (version)) raise XmakeException("unsupported visual studio version: %s" % version) if os.environ.has_key(environment_variable): visual_studio_inst_dir = os.environ[environment_variable] if not is_existing_directory(visual_studio_inst_dir): log.error( "visual studio '%s' not found in '%s=%s'. Either unset environment variable '%s' or change it" % (version, environment_variable, visual_studio_inst_dir, environment_variable)) raise XmakeException( "visual studio '%s' not found in '%s=%s'" % (version, environment_variable, visual_studio_inst_dir)) visual_studio_inst_dir = os.path.abspath( os.path.join(visual_studio_inst_dir, '..', '..')) else: visual_studio_inst_dir = r"C:\Program Files (x86)\Microsoft Visual Studio " + environment_variable[ 2:4] + "." + environment_variable[4:5] if not is_existing_directory(visual_studio_inst_dir): log.error( "visual studio version '%s' not found in the default folder '%s'. Set environment variable '%s' or install visual studio in the default folder" % (version, visual_studio_inst_dir, environment_variable)) raise XmakeException( "visual studio '%s' not found in the default folder '%s'" % (version, visual_studio_inst_dir)) return visual_studio_inst_dir
def list_deps(self, d, p): r = [] d = join(d, 'node_modules') if is_existing_directory(d): for m in os.listdir(d): md = join(d, m) if m != '.bin' and is_existing_directory(md): mp = p + '/' + m v = self.get_version(md, mp) if v is not None: r.append((mp, str(v))) r.extend(self.list_deps(md, mp)) return r
def install_dependencies(self): # npm install log.info('installing dependencies...') os.mkdir(self.import_dir) if not is_existing_directory(self.build_cfg.import_dir()): return if OS_Utils.is_UNIX(): names = os.listdir(self.build_cfg.import_dir()) if names is not None: for name in names: os.link(join(self.build_cfg.import_dir(), name), join(self.import_dir, name)) else: copytree(self.build_cfg.import_dir(), self.import_dir) if self.load is not None: log.info('preloading images...') for image in self.load: ifile = join(self.build_cfg.import_dir(), image) if is_existing_file(ifile): log.info(' loading '+image) self.docker(['load', '-i', ifile]) else: log.warning('image '+image+' not imported')
def __init__(self, build_cfg): VariantBuildPlugin.__init__(self, build_cfg) if not build_cfg.runtime().startswith('linux'): raise XmakeException( 'docker build available only on linux runtime') if not is_existing_directory(self.build_cfg.src_dir()): self.build_cfg.set_src_dir(self.build_cfg.component_dir()) log.info('using flat source dir: ' + self.build_cfg.src_dir()) repos = self.build_cfg.import_repos('DOCKER') if repos is None or len(repos) == 0: log.warning('no docker repository specified') self.registry = None else: if len(repos) > 1: log.warning( "multiple DOCKER import repositories found -> ignore all but the first one" ) self.registry = repos[0] log.info("using DOCKER import repository " + self.registry) self.image_file = None self.image_name = None self.aid = None self.gid = None self.version = None self.mode = 'tool' self.keepuser = True self.keepcontainer = False self._srcdir = '/src' self._gendir = '/gen' self._importdir = '/imports'
def _setup(self): log.info(" assuming some defaults") self._build_cfg._build_script_name="generic" self._build_cfg.set_base_version('1.0.0') if is_existing_file(join(self._build_cfg.component_dir(),".xmake.cfg")): log.info(" found .xmake.cfg") if not is_existing_directory(self._build_cfg.src_dir()): self._build_cfg.set_src_dir(self._build_cfg.component_dir()) log.info(" using flat source dir: "+self._build_cfg.src_dir())
def setup(self): if self.matches(): if not is_existing_directory(self._build_cfg.cfg_dir()): log.info(" no cfg folder found...") else: log.info(" .xmake.cfg found in project root...") self._setup() return True return False
def _install(self,aid,retrieve,msg=None,archive=True): d=self.path(aid) if is_existing_directory(d): return d a=retrieve(aid) if a==None: return None utils.mkdirs(os.path.dirname(d)) f=tempfile.mkdtemp(suffix='.'+self._base(aid), dir=self._root) try: self._notify(aid,d,a,msg) if not archive: base=os.path.basename(a) ix=base.rfind('.') suf=base[ix:] if ix>=0 else '' if suf=='.gz': base=base[:ix] ix=base.rfind('.') suf=(base[ix:] if ix>=0 else '')+suf shutil.copy(a,join(f,'artifact'+suf)) else: utils.expandArchive(a, f) if self._finalizer!=None: self._finalizer(aid,f) err=0 while not is_existing_directory(d): try: os.rename(f,d) except OSError: if not is_existing_directory(d): err=err+1 else: log.error( 'cannot rename directory '+f+':'+str(sys.exc_info()),log.INFRA) break utils.rmtree(f) if is_existing_directory(d): return d log.error( 'no folder '+d,log.INFRA) return None except: log.error( 'cannot expand archive '+a+':'+ str(sys.exc_info()),log.INFRA) utils.rmtree(f) raise XmakeException('ERR: cannot expand archive '+a+': '+str(sys.exc_info()))
def alternate_path(self): v = self._alternate_path if v is None: return v f = join(self.component_dir(), v) if utils.is_existing_directory(f): return v relPath = '' dirs = v.split('.') relPath = os.sep.join(dirs) return relPath
def _init_buildtools(self): # use symbolic links if only one buildtools directory exists buildtools_target_dir = self._effective_buildtools_dir() def rm_if_target_exists(): if os.path.exists(buildtools_target_dir): OS_Utils.rm_dir(buildtools_target_dir) if os.path.exists(self._build_tools_dir()) and not os.path.exists( self._build_tools_import_dir()) and not os.path.exists( self._build_tools_source_dir()): rm_if_target_exists() buildtools_source = self._build_tools_dir() self._symlink(buildtools_source, buildtools_target_dir) return if not os.path.exists(self._build_tools_dir()) and os.path.exists( self._build_tools_import_dir()) and not os.path.exists( self._build_tools_source_dir()): rm_if_target_exists() buildtools_source = self._build_tools_import_dir() self._symlink(buildtools_source, buildtools_target_dir) return if not os.path.exists(self._build_tools_dir()) and not os.path.exists( self._build_tools_import_dir()) and os.path.exists( self._build_tools_source_dir()): rm_if_target_exists() buildtools_source = self._build_tools_source_dir() self._symlink(buildtools_source, buildtools_target_dir) return rm_if_target_exists() # we need to cp buildtools (local buildtool contents win over imported ones) if is_existing_directory(self._build_tools_import_dir()): dir_util.copy_tree(self._build_tools_import_dir(), buildtools_target_dir) if is_existing_directory(self._build_tools_source_dir()): dir_util.copy_tree(self._build_tools_source_dir(), buildtools_target_dir) if is_existing_directory(self._build_tools_dir()): dir_util.copy_tree(self._build_tools_dir(), buildtools_target_dir)
def xmake_cfg(self): if self._xmake_cfg is None: cfg = None if utils.is_existing_directory(self.cfg_dir()): cfg = join(self.cfg_dir(), XMAKE_CFG) if cfg is None or not utils.is_existing_file(cfg): cfg = join(self.component_dir(), "." + XMAKE_CFG) if utils.is_existing_file(cfg): log.info("found xmake.cfg...") config = utils.IterableAwareCfgParser() config.read(cfg) self._xmake_cfg = config return self._xmake_cfg
def get_xmake_version(v, build_cfg): def finalize(aoid,d): touch_file(join(d,'.loaded')) def retrieve(aid): url=package_url(aid) if test_mode: return join(build_cfg.gen_dir(),"xmake.tar.gz") return tool_retrieve_url(url,aid,XMAKE_PKG_REPO) if environ.has_key('XMAKE_VERSION_INSTALLATION_ROOT'): version_root=environ['XMAKE_VERSION_INSTALLATION_ROOT'] if not is_existing_directory(version_root): log.error("env var 'XMAKE_VERSION_INSTALLATION_ROOT' was set, but does not point to an existing directory. Either unset or change it") raise XmakeException("encountered invalid value of env var 'XMAKE_TOOL_INSTALLATION_ROOT'") else: version_root=join(inst.get_xmake_user_home(),'versions') #xmake_inst_dir = get_installation_dir() #version_root=join(xmake_inst_dir,"versions") versions=appcache.AppCache("xmake",join(version_root),retrieve,finalize) if (v.endswith("-SNAPSHOT")): p=versions.path(v) latest=get_latest(p) if latest==None: log.info('no snapshot found for '+v+' -> load new version') return update_snapshot(versions,v) else: cleanup(p) try: if build_cfg.do_import(): log.info('check for newer snapshot for xmake version '+v) return update_snapshot(versions,v) else: c=time.time() t=getmtime(p) if t+XMAKE_CHECK_TIME<c: log.info('check time exceeded for '+v+' -> check for newer snapshot') return update_snapshot(versions,v) except XmakeException as xme: log.warning('update of xmake version failed: '+ xme.msg) log.warning('reusing actually available snapshot') return latest else: return versions.get(v)
def determine_xmake_version(build_cfg): log.info( 'determining required xmake version...') v=build_cfg.xmake_version() vf=join(build_cfg.cfg_dir(),XMAKE_VERSION) if not is_existing_directory(build_cfg.cfg_dir()): vf=join(build_cfg.component_dir(),"."+XMAKE_VERSION) if v is None and isfile(vf): v=get_first_line(vf,'cannot read '+XMAKE_VERSION) if v is None: config=build_cfg.xmake_cfg() if config is not None: s='xmake' if (config.has_section(s)): if config.has_option(s, "xmake-version"): v=config.get(s,'xmake-version') build_cfg._xmake_version=v return v
def has(self,aid): return is_existing_directory(self.path(aid))
def matches(self): if not is_existing_directory(self._build_cfg.cfg_dir()): return True if is_existing_file(join(self._build_cfg.component_dir(),".xmake.cfg")): return True return False