def resolve_deployment_credentials(build_cfg, t=config.COMMONREPO): # skip resolving if either no credential key was defined or user and password were specified if build_cfg.deploy_cred_key(t) is None or build_cfg.deploy_user( t) is not None and build_cfg.deploy_password(t) is not None: return prodpassaccess = build_cfg.tools().prodpassaccess() log.info("accessing credential key " + build_cfg.deploy_cred_key(t) + " for repository type " + t) # user log.info("call prodpassaccess to retrieve user") (rc, stdout, _) = OS_Utils.exec_script( [prodpassaccess, 'get', build_cfg.deploy_cred_key(t), 'user']) if rc > 0: raise XmakeException('prodpassaccess returned %s' % str(rc)) build_cfg.set_deploy_user(stdout.strip(), t) log.info("user retrieved") # password log.info("call prodpassaccess to retrieve password") (rc, stdout, _) = OS_Utils.exec_script( [prodpassaccess, 'get', build_cfg.deploy_cred_key(t), 'password']) if rc > 0: raise XmakeException('prodpassaccess returned %s' % str(rc)) build_cfg.set_deploy_password(stdout.strip(), t) log.info("password retrieved")
def select_bootstrapper(f,argv): parser = OptionParser() parser.add_option( '--select-bootstrapper', dest="boot", action='store_true', help="the bootstrapper version to use") (values,args)=parser.parse_args(argv[1:],Bunch(boot=False)) if not values.boot: raise XmakeException("inconsistent use of bootstrapper option") if len(args) == 0: "check and notify about the actually configured bootstrapper" if isfile(f): log.info("determining bootstrapper") v=get_first_line(f,'cannot read '+f) if v!=None: log.info("actual bootstrapper version is "+v) else: log.info("no bootstrapper version configured in "+f) else: log.info("no bootstrapper version configured") else: "set or change the bootstrapper version to use" if len(args)!=1: raise XmakeException("only one version argument possible") (v,_)=load_latest(args[0]) with open(f,"w") as b: b.write(v+"\n") log.info("setting bootstrapper to version "+v)
def _check(build): if build.image_name is not None: if build.mode != 'docker': raise XmakeException( 'using docker image name requires mode "docker"') return if build.mode is None: if build.version is None or build.gid is None: build.mode = 'docker' if build.aid is None: raise XmakeException( 'docker image name or artifact id required: specify property aid for build plugin' ) if build.gid is None: if build.mode != 'docker': raise XmakeException( 'group id for docker image required: specify property gid for build plugin' ) elif 'IS_NEW_DOCKER' in os.environ and os.environ[ 'IS_NEW_DOCKER'] == 'true': build.gid = re.sub('^[^:]+:\d+/', '', build.gid) build.gid = build.registry + '/' + build.gid if build.version is None: if build.mode != 'docker': raise XmakeException( 'version of docker image required: specify property version for build plugin' ) else: if build.mode is 'tool': if build.version.endwith('-SNAPSHOT'): raise XmakeException( 'snapshot versions not supported for tool dependencies')
def acquire_forwarding_script(self, build_cfg, plugin_path): #dynamically load custom build script log.info( 'loading forwarding plugin '+plugin_path) plugin_code = compile(open(plugin_path, "rt").read(), plugin_path, "exec") plugin_dict = { "__name__": "forwardplugin", "object": _ObjectBase, } exec plugin_code in plugin_dict try: forward_script_class = plugin_dict["forward"] except KeyError: log.error( "custom forwarding script must define a class 'forward' - no such class def found at: " + plugin_path) raise XmakeException("failed to instantiate 'forward' (no such class def found)") #check for existence of c'tor w/ one formal parameter if not len(inspect.getargspec(forward_script_class.__init__)[0]) == 2: log.error( "custom forward class must implement a c'tor w/ exactly one formal parameter (which is of type BuildConfig)") raise XmakeException("failed to instantiate 'forward' (no c'tor def w/ correct amount of formal parameters (which is one) found)") if not len(inspect.getargspec(forward_script_class.run)[0]) == 1: log.error( "custom forward class must implement a method 'run' w/ exactly one formal parameter (which is of type BuildConfig)") raise XmakeException("failed to instantiate 'forward' (no method 'run' def w/ correct amount of formal parameters (which is one) found)") forward_script = forward_script_class(build_cfg) return forward_script
def execute_scripts(self): log.info('executing docker build...') self.image = None def handler(line): if self.src_image is None: self.src_imagename = self.match(line, 'Step 0 : FROM', self.src_imagename) if not self.src_imagename: self.src_imagename = self.match(line, 'Step 1 : FROM', self.src_imagename) self.src_image = self.match(line, ' --->', self.src_image) self.image = self.match(line, 'Successfully built', self.src_image) return line try: self.docker(["build",self.context_dir],handler=handler) except XmakeException: log.error("docker image '%s' not found.\nPlease check the docker registry '%s'" % (self.src_imagename, self.registry)) raise XmakeException("ERR: docker image '%s' not found.\nPlease check the docker registry '%s'" % (self.src_imagename, self.registry)) if self.image is None: raise XmakeException('ERR: no image found') log.info('generated docker image '+self.image) addfile = os.path.join(self.build_cfg.src_dir(), 'DockerCommands') if is_existing_file(addfile): log.info('executing additional commands...') succeeded = False try: self.image = self.handle_script(self.image, addfile) log.info('generated docker image '+self.image) succeeded = True finally: if self.image is not None and not succeeded: self.cleanup_image(self.image) log.info('root image '+self.src_imagename+' ('+self.src_image+')') with open(self.image_name_file, 'w') as f: f.write(self.image+'\n')
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 __init__(self, build_cfg): BuildPlugin.__init__(self, build_cfg) self._detected_npm_version = None self._node_version = '0.12.0' self._npm_user_options = [] self._bundle = False self._run_shrinkwrap = True self._after_install = [] self._before_publish = [] self._node_executable = None self._npmcmd = None self._env = None self._path = None self._rel_path = 'bin' self._rel_npm = 'lib/node_modules/npm/bin/npm-cli.js' self._root = self.build_cfg.src_dir() self._pkgfile = join(self._root, 'package.json') self._npm_prefix_dir = join(self.build_cfg.temp_dir(), '.npm-global') self.build_cfg.tools().declare_runtime_tool( 'nodejs', 'com.sap.prd.distributions.org.nodejs:nodejs:tar.gz') repos = self.build_cfg.import_repos(NPMREPO) if repos is None or len(repos) == 0: raise XmakeException('npm repository required') if len(repos) > 1: log.warning( 'multiple NPM import repositories found -> ignore all but the first one' ) self.registry = repos[0] log.info('using NPM import repository ' + self.registry) if self._is_plain(): log.info('using plain mode for build') if not is_existing_file(self._pkgfile): raise XmakeException( 'package.json required in projects root or src folder') with open(self._pkgfile, 'r') as d: self.pkg = json.load(d) if 'name' not in self.pkg: raise XmakeException('package.json must contain a name field') self.module_name = self.pkg['name'] if 'dependencies' not in self.pkg: self._run_shrinkwrap = False else: dependencies = self.pkg['dependencies'] if dependencies is not None and bool(dependencies) is False: self._run_shrinkwrap = False self.deps = join(self.build_cfg.temp_dir(), 'dependencies') self.build_cfg.add_metadata_file(self.deps) # Take in account arguments after the -- # All these arguments will be passed to the npm command if self.build_cfg.build_args(): for arg in self.build_cfg.build_args(): log.info(' using custom option ' + arg) self._npm_user_options.append(arg)
def __init__(self, build_cfg): BuildPlugin.__init__(self, build_cfg) if not build_cfg.runtime().startswith('linux'): raise XmakeException('docker build available only on linux runtime') 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) f = join(self.build_cfg.src_dir(), 'Dockerfile') if not is_existing_file(f): raise XmakeException('Docker file required in projects root folder') if 'IS_NEW_DOCKER' in os.environ and os.environ['IS_NEW_DOCKER'] == 'true': with open('Dockerfile') as infile, open('Dockerfile_tmp', 'w') as outfile: for line in infile: line = re.sub('^\s*FROM\s*[^:]+:\d+/', 'FROM ', line) if self.registry is not None: line = re.sub('^\s*FROM\s*', 'FROM '+self.registry+'/', line) outfile.write(line) shutil.copyfile('Dockerfile_tmp', 'Dockerfile') self.context_dir = join(self.build_cfg.gen_dir(), 'context') self.import_dir = join(self.context_dir, 'imports') self.image_file = join(build_cfg.gen_dir(), 'image.tar.gz') self.delta_file = join(build_cfg.gen_dir(), 'delta.tar.gz') self.image_name_file = join(build_cfg.gen_dir(), 'imagename') self.aid = None self.gid = 'com.sap.docker' self.load = None self.delta = False self.common = False self.echo = False self.image = None self.src_image = None self.src_imagename = None self.docker_force_enabled=False output=[] def catch_output(line): if not len(output): log.info(line.rstrip()) output.append(line) docker.docker(["-v"],handler=catch_output) m = re.match(r".*?\s+(?P<Version>\d+\.[\w\.\-]+).*", ''.join(output)) if m and m.group('Version'): log.info("Checking --force flag for version: "+m.group('Version')) if LooseVersion(m.group('Version'))<LooseVersion('1.10'): # starting from 1.10 forcing option is deprecated self.docker_force_enabled=True
def check_coords(self, coords): for c in self._dimensions: if coords.has_key(c): if not coords[c] in self.get_dimension(c): raise XmakeException("invalid value '"+coords[c]+"' for variant dimension '"+c+"'") else: raise XmakeException("missing value for variant dimension '"+c+"'") for c in coords.keys(): if not c in self._dimensions: raise XmakeException("invalid variant dimension '"+c+"'")
def _create_tool_import_script(build_cfg): build_script = build_cfg.build_script() (tool_imports, allgavs) = _gather_tool_imports(build_cfg, build_script) if (not build_cfg.suppress_variant_handling() and build_cfg.variant_cosy_gav() != None): tool_imports.add(build_cfg.variant_cosy_gav()) if len(tool_imports) > 0: imports = {'tools': tool_imports} else: imports = {} imps = build_script.plugin_imports() if imps is not None: if not isinstance(imps, dict): raise XmakeException('plugin_imports must return a dict') log.info('build plugin requests imports: ' + str(imps)) if imps.has_key('tools') and len(imports) > 0: imports['tools'].update(imps['tools']) del imps['tools'] if len(imps) > 0: imports.update(imps) ct = build_cfg.configured_tools() if len(ct) != 0: log.info('found configured tools...') gavs = set() for n in ct.keys(): tid = ct[n].toolid() _handleToolImports(build_cfg, tid, ct[n].version(), gavs, allgavs) if len(gavs) > 0: if imports.has_key('tools'): imports['tools'].update(gavs) else: imports['tools'] = gavs log.info('all tool imports: ' + str(allgavs)) append_import_file(build_cfg, allgavs) if len(imports) == 0: log.info('no tool import script required') return None #dict keys must denote existing (defined) import roots import_keys = ['default', 'tools' ] # default and tools is provided by IMPORT phase (xmake) import_keys.extend(build_script.import_roots().keys()) undefined_import_roots = filter(lambda (key): key not in import_keys, imports.keys()) if len(undefined_import_roots) > 0: raise XmakeException( 'the following import roots were not defined by build plugin: %s' % ', '.join(undefined_import_roots)) import_file = create_import_script(build_cfg, 'plugin-imports.ais', imports) return import_file
def load_plugin(f): plugin_name=basename(f)[:-3] module=imp.load_source('plugin',f) if not hasattr(module, 'content'):raise XmakeException('ERR: content plugin %s does not define a class "content"' % (plugin_name)) if not issubclass(module.content, spi.ContentPlugin): log.warning("content plugin class is not a subclass of spi.ContentPlugin: "+plugin_name) if not has_method(module.content,'__init__', 2): log.error( "content plugin class for %s must implement a c'tor w/ exactly two formal parameters" % (plugin_name)) raise XmakeException("failed to instantiate content plugin "+plugin_name+" (no c'tor def w/ correct amount of formal parameters (which is one) found)") impl=module.content(build_cfg,plugin_name) contentPlugins[plugin_name] = impl
def extract_msvc_env(self, vs_inst_path, arch): """ extracts the msvc environment variables out of the local installation and returns them as a dict """ if arch not in self.archs: log.error("invalid architecture provided: %s" % arch) raise XmakeException("invalid architecture provided: %s" % arch) log.info("looking up env for " + vs_inst_path) vc_vars_all = os.path.normpath( os.path.join(vs_inst_path, "VC", "vcvarsall.bat")) if not os.path.exists(vc_vars_all): log.error("vcvarsall.bat not found") raise XmakeException("vcvarsall.bat not found") cmd = subprocess.Popen(args=["cmd.exe"], stdin=subprocess.PIPE, stdout=subprocess.PIPE) cmd.stdin.write('"%s" %s\n' % (vc_vars_all, arch)) cmd.stdin.write( '''"%s" -c "import pickle, os; print '---{1}---\\n{0}\\n---{1}---'.format(pickle.dumps(dict(os.environ), -1).encode('base64'), 'ENV')"\n''' % sys.executable) cmd.stdin.close() output = cmd.stdout.read() rc = cmd.wait() if rc != 0: log.error("could not determine msvc environment") raise XmakeException("could not determine msvc environment") match = re.search("---ENV---(.*)---ENV---", output, re.DOTALL) if match is None: log.error("getting environment failed") raise XmakeException("getting environment failed") environ_data = match.group(1) environ = pickle.loads(environ_data.strip().decode("base64")) if self.printenv: log.info("environment modifications: ") for v in environ.keys(): n = environ[v] if os.environ.has_key(v): if os.environ[v] != n: log.info(" modified: " + v + "=" + os.environ[v] + " -> " + n) else: log.info(" new : " + v + "=" + n) return environ
def _nexus_staging_push(build_cfg, jsonUserAgent, nexusApi, repoId, diskDeploymentPath): for root, dirs, files in os.walk(diskDeploymentPath): for name in files: artifact = {} artifact['filename'] = name artifact['path'] = os.path.join(root, name) artifact['relpath'] = artifact['path'].replace( diskDeploymentPath, '').replace('\\', '/') if artifact['relpath'].startswith('/'): artifact['relpath'] = artifact['relpath'][1:] succeeded = nexusApi.deployByRepositoryId(repoId, artifact, userAgent=jsonUserAgent) if not succeeded: raise XmakeException( 'Failed to deploy file {} to repository {}'.format( artifact, repoId)) status = nexusApi.getrepositorystatus(repoId) log.info( 'build results pushed into staging repo \'{}\'. This staging repo is not closed yet.' .format(status['repositoryURI'])) return status
def _nexus_deployment(build_cfg, export_repo_url): resolve_deployment_credentials(build_cfg) args = [ build_cfg.tools().artifact_deployer(), 'deploy', '-p', build_cfg.export_file(), '--repo-url', export_repo_url, '--artifact-version', build_cfg.base_version(), '--request-timeout', str(tuning.AD_TIMEOUT), '--write-artifact-info', build_cfg.deployment_info_log() ] suffix = build_cfg.version_suffix() if suffix is not None and len(suffix) > 0: args.extend(['--artifact-version-suffix=-' + suffix]) log.info('calling ' + ' '.join(args)) if build_cfg.deploy_user(): args.extend(['--repo-user', build_cfg.deploy_user()]) if build_cfg.deploy_password(): args.extend(['--repo-passwd', build_cfg.deploy_password()]) rc = log.log_execute(args) if rc == 0: log.info("deployment of exported build results succeeded") log.info("deployed version: " + build_cfg.base_version() + (('-' + suffix) if suffix is not None else '')) else: log.info("deployment returned w/ RC==" + str(rc)) log.error( "deployment of exported build results resulted in an error. See log output for further hints", log.INFRA) raise XmakeException("deployment failed")
def _nexus_staging_close(build_cfg, nexusApi, repoId): if not nexusApi.finish(repoId): raise XmakeException( 'close of staging repository failed. Analyse the build log and look at repository id: {}.' .format(repoId)) status = nexusApi.getrepositorystatus(repoId) ua_scm_snapshot_url = build_cfg.scm_snapshot_url() if not ua_scm_snapshot_url: try: userAgent = json.loads(status['userAgent']) if userAgent: if 'scm' in userAgent: ua_scm_snapshot_url = userAgent['scm'] log.info( 'scm_snapshot_url read from staging repository: {}'. format(ua_scm_snapshot_url)) except ValueError: pass _storeStageCloseProps(nexusApi, build_cfg, repoId, ua_scm_snapshot_url) log.info('*' * 100) log.info('build results are available in staging repository:') log.info(status['repositoryURI']) log.info('scm_snapshot_url:') log.info(ua_scm_snapshot_url) log.info('*' * 100) return status
def forbid_docker(feature,state,args): ''' If docker is available on this host,only docker aware xmake versions may be used ''' if utils.which('docker') is not None: raise XmakeException("non-docker-aware xmake versions may not be used on this host") return args
def after_IMPORT(self, build_cfg): self.java_set_environment(True) # Setup maven self._setup() # If set-version option is on if build_cfg.get_next_version() is not None: self._set_version_in_pom(build_cfg.get_next_version(), build_cfg.component_dir()) # Always copy src see BESTL-8640 Related to Cloud Foundry deployment self._copy_src_dir_to(self._copied_src_dir) elif build_cfg.base_version() == 'NONE': # Always copy src see BESTL-8640 Related to Cloud Foundry deployment self._copy_src_dir_to(self._copied_src_dir) self._get_version_from_effective_pom() # If get-version option is on if build_cfg.get_project_version() is True: status = self._check_project_version_compliance() if status[0] is False: raise XmakeException(status[1]) else: stripped_version = self._remove_leading_zero(self.build_cfg.base_version()) self.build_cfg.set_base_version(stripped_version) log.info('write project version {} in {}'.format(self.build_cfg.base_version(), self.build_cfg.project_version_file())) with open(self.build_cfg.project_version_file(), 'w') as f: f.write(self.build_cfg.base_version())
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 set_import_repos(self, r, t=COMMONREPO): if self.productive() or self.is_release() or self.is_milestone(): if r and len(r) >= 1: raise XmakeException( 'only one repository url is authorized for productive or/and release build. See {} urls passed in --import-repo argument' .format(t)) self._import_repos[t] = r
def _setup(self): if self._npmcmd is None: self._nodehome = self.build_cfg.tools()['nodejs'][ self._node_version] dirs = os.listdir(self._nodehome) if len(dirs) != 1: raise XmakeException('ERR: invalid nodejs distribution %s' % str(self._nodehome)) self._nodehome = join(self._nodehome, dirs[0]) log.info('found node: ' + self._nodehome) self._path = os.path.realpath( os.path.join(self._nodehome, self._rel_path)) self._node_executable = os.path.realpath(self._node_cmd()) self._npmrc_file = os.path.join(self.build_cfg.temp_dir(), '.npmrc') self._npmcmd = [ self._node_executable, '-i', os.path.realpath(self._npm_script()), '--userconfig', self._npmrc_file ] self.module_dir = join(self.build_cfg.gen_dir(), 'module') self.shrinkwrap = join(self.build_cfg.temp_dir(), 'npm-shrinkwrap.json') self.build_cfg.add_metadata_file(self.shrinkwrap) self.setup_env()
def run(self): """the vmake build execution implementation. Invoked during the xmake BUILD phase""" self._initialise() log.info("invoking vmake build...") self._before_build_callback() vmake_args = self.build_cfg.build_args() vmake_args = [ 'all.vprj' ] if vmake_args is None or len(vmake_args) == 0 else vmake_args self._handle_build_mode( self.build_cfg.variant_info()[XMAKE_BUILD_MODE]) vmake_args = ' '.join(vmake_args) if self.is_UNIX: rc = os.system( "bash -c \"source " + self._iprofile() + " && vmake " + vmake_args + "\"") # assume there must be a 'all.vprj' vmake target else: rc = os.system( self._iprofile() + " && vmake " + vmake_args) # assume there must be a 'all.vprj' vmake target # dirty-hacks: 1. RC == 1 seems to mean build was OK, # 2. left-shift RC if on unix if self.is_UNIX and rc > 254: rc = rc >> 8 if rc > 1: raise XmakeException('ERR: vmake returned RC >1: %s' % str(rc))
def _fortifyDeploy(self): ''' Deploy fortify result in corporate fortify server ''' log.info('fortify upload') # Read option values from os environment serverurl = os.getenv('FORTIFY_F360_URL') # https://fortify1.wdf.sap.corp/ssc token = os.getenv('FORTIFY_F360_AUTH_TOKEN') logErrors = [] if serverurl is None: logErrors.append('fortify server url not set. Please set env FORTIFY_F360_URL') elif not serverurl.startswith('http://') and not serverurl.startswith('https://'): logErrors.append('bad fortify server url waiting for http/https url: {}'.format(serverurl)) if token is None: logErrors.append('fortify token not set. Please set env FORTIFY_F360_AUTH_TOKEN') if len(logErrors) > 0: for error in logErrors: log.error(error, log.INFRA) raise XmakeException('fortify results upload fails') # fortify deploy maven_args = [] maven_args.append('com.sap.ldi:fortify-plugin:{}:upload'.format(self._fortify_plugin_version)) maven_args.append('-Dldi.fortify.f360.url={}'.format(serverurl)) maven_args.append('-Dldi.fortify.f360.authToken={}'.format(token)) maven_args.append('-Dldi.fortify.f360.projectVersion={}'.format(self.build_cfg.base_version().split('.')[0])) maven_args.extend(shlex.split(' '.join(self._maven_user_options))) self._mvn(maven_args)
def publish(self): if self.image is None: self.image = get_first_line(self.image_name_file, 'cannot read image id from last build') log.info('reading image name from last build: '+self.image) if is_existing_file(self.delta_file): log.info('reloading image to daemon cache...') docker.docker(['load', '-i', self.delta_file]) repo = self.repo_host() if repo is None: raise XmakeException('no DOCKER deployment repository configured') self.tag_image() log.info('publishing to DOCKER repository '+repo+'...') resolve_deployment_credentials(self.build_cfg, DOCKERREPO) user = self.build_cfg.deploy_user(DOCKERREPO) password = self.build_cfg.deploy_password(DOCKERREPO) dir = '.' if user is not None and password is not None: log.info(' using user '+user) dir = docker.prepare_dockercfg(user, password, repo) success = False try: tag = self.tag_name() log.info('publishing image to '+repo+' ('+tag+')') docker.docker(['push', tag], None, dir=dir, home=dir) log.info('docker logout '+repo) docker.docker(['logout', repo], None, dir=dir, home=dir) success = True finally: if dir is not '.': log.info('cleanup login info '+dir) shutil.rmtree(dir) if success: self.cleanup_image(tag)
def _set_stdrun_option(build, o, v): if o == 'image': build.image_name = v build.mode = 'docker' return True if o == 'aid': build.aid = v return True if o == 'gid': build.gid = v return True if o == 'version': build.version = v return True if o == 'mode': if not v.lower() in ['import', 'docker', 'tool']: raise XmakeException('invalid image mode ' + v + ', please use Import, Docker or Tool') build.mode = v return True if o == 'keepuser': build.keepuser = v.lower() == 'true' return True if o == 'keepcontainer': build.keepcontainer = v.lower() == 'true' return True return False
def set_option_string(self, v): c = v.split(':') if len(c) > 1: raise XmakeException( 'ERR: only version of vmake variant coordinate system can be set: %s' % (v)) self._cosy_version = v log.info(' using coordinate system ' + self.variant_cosy_gav())
def add_import_repo(self, r, t=COMMONREPO): if self.productive() or self.is_release() or self.is_milestone(): repos = utils.get_entry(self._import_repos, t) if repos and len(repos) >= 1: raise XmakeException( 'only one repository url is authorized for productive or/and release build. See {} urls passed in --import-repo argument' .format(t)) utils.add_list_entry(self._import_repos, t, r)
def _validate_vmake_installation(self): if OS_Utils.find_in_PATH("vmake") is not None: return if is_existing_file( join(self.build_cfg.vmake_instdir(), "pgm", "vmake" if OS_Utils.is_UNIX() else "vmake.exe")): return raise XmakeException('Vmake was not found neither in PATH nor in %s.' % (self.build_cfg.vmake_instdir()))
def set_option(self,o,v): if o=="cosy": if len(v.split(':'))==2: log.info( ' using coordinate system '+v) self._variant_cosy_gav=v else: raise XmakeException('ERR: invalid coordinate system specification '+str(v)+': expected <name>:<version>') else: BuildPlugin.set_option(self,o,v)
def _symlink(self, source, link_name): source = os.path.abspath(source) if self.is_UNIX: getattr(os, 'symlink')(source, link_name) # unfortunatly, python 2.7 does not support symlinks on windows else: if os.system("mklink /d " + link_name + " " + source) != 0: raise XmakeException( 'failed to create symbolic link (hint: you may need to run this build w/ administrative privileges)' )
def _handle_build_mode(self, build_mode): build_modes = ['opt', 'dbg', 'rel'] if build_mode is None: log.warning('no build_mode was specified - defaulting to opt') return if build_mode not in build_modes: raise XmakeException('unsupported build mode: %s' % (build_mode)) # todo: do not modify own process' environment, but only to this for vmake subproc os.environ['VMAKE_VERSION'] = build_mode os.environ['VMAKE_DEFAULT'] = build_mode