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
