def grab_base_flat(self, top): """Method that collects all the files from EPICS base into a debian package like format Parameters ---------- top : str Path to the staging area for the tarring process, usually __temp__ """ base_path = self.install_config.base_path LOG.debug('Grabbing flat epics base files') for arch in self.arch_list: self.grab_folder(base_path + '/bin/' + arch, top + '/bin/' + arch) self.grab_folder(base_path + '/lib/' + arch, top + '/lib/' + arch) self.grab_folder(base_path + '/cfg', top + '/cfg') self.grab_folder(base_path + '/lib/perl', top + '/lib/perl') self.grab_folder(base_path + '/configure', top + '/configure') LOG.debug( 'Creating rules.d directory to allow for additional rule sets') os.mkdir(top + '/configure/rules.d') os.mkdir(top + '/req') self.grab_folder(base_path + '/include', top + '/include') self.grab_folder(base_path + '/startup', top + '/startup') self.grab_folder(base_path + '/db', top + '/db') self.grab_folder(base_path + '/dbd', top + '/dbd') self.grab_folder(base_path + '/templates', top + '/templates')
def cleanup_tar_staging(self, filename, module=None): """Function that cleans up tar staging point, and closes readme file. Parameters ---------- filename : str file path string module : InstallModule Optional install module to create single module add-on package Returns ------- int Return code of tar creation call. """ LOG.debug('Generating README file with module version and append instructions...') shutil.copy(installSynApps.join_path(self.output_location, 'README_{}.txt'.format(filename)), installSynApps.join_path('__temp__', 'README_{}.txt'.format(filename))) LOG.write('Tarring...') out = subprocess.call(['tar', 'czf', filename + '.tgz', '-C', '__temp__', '.']) if out < 0: return out os.rename(filename + '.tgz', installSynApps.join_path(self.output_location, filename + '.tgz')) LOG.write('Done. Wrote tarball to {}.'.format(self.output_location)) LOG.write('Name of tarball: {}'.format(installSynApps.join_path(self.output_location, filename + '.tgz'))) shutil.rmtree('__temp__') return out
def acquire_dependecies(self, dependency_script_path): """Method that runs dependency install shell/batch script Parameters ---------- dependency_script_path : str path to dependency shell/batch script """ LOG.debug('Grabbing dependencies via script {}'.format( dependency_script_path)) if os.path.exists(dependency_script_path) and os.path.isfile( dependency_script_path): if dependency_script_path.endswith('.bat'): exec = dependency_script_path else: exec = 'bash {}'.format(dependency_script_path) LOG.print_command(exec) proc = Popen(exec.split(' ')) proc.wait() ret = proc.returncode if ret != 0: LOG.write( 'Dependency script exited with non-zero exit code: {}'. format(ret))
def grab_base(self, top, include_src=False, flat_grab=False): """Function that copies all of the required folders from EPICS_BASE Parameters ---------- top : str resulting location - __temp__ """ if flat_grab: self.grab_base_flat(top) return base_path = self.install_config.base_path if not include_src: LOG.debug('Grabbing lean epics base files') for arch in self.arch_list: self.grab_folder(base_path + '/bin/' + arch, top + '/base/bin/' + arch) self.grab_folder(base_path + '/lib/' + arch, top + '/base/lib/' + arch) self.grab_folder(base_path + '/lib/perl', top + '/base/lib/perl') self.grab_folder(base_path + '/cfg', top + '/base/cfg') self.grab_folder(base_path + '/configure', top + '/base/configure') self.grab_folder(base_path + '/include', top + '/base/include') self.grab_folder(base_path + '/startup', top + '/base/startup') self.grab_folder(base_path + '/db', top + '/base/db') self.grab_folder(base_path + '/dbd', top + '/base/dbd') else: LOG.debug('Grabbing full epics base files') self.grab_folder(base_path, top + '/base')
def add_missing_support_macros(self): """Function that appends any paths to the support/configure/RELEASE file that were not in it originally """ to_append_commented = [] to_append = [] for module in self.install_config.get_module_list(): if module.clone == "YES": was_found = False rel_file = open(installSynApps.join_path(self.install_config.support_path, "configure/RELEASE"), "r") line = rel_file.readline() while line: if line.startswith(module.name + "="): was_found = True line = rel_file.readline() if not was_found and not module.name in self.add_to_release_blacklist and not module.name.startswith("AD"): if module.build == "YES": to_append.append([module.name, module.rel_path]) else: to_append_commented.append([module.name, module.rel_path]) rel_file.close() app_file = open(self.install_config.support_path + "/configure/RELEASE", "a") for mod in to_append: LOG.debug('Adding {} path to support/configure/RELEASE'.format(mod[0])) app_file.write("{}={}\n".format(mod[0], mod[1])) for mod in to_append_commented: LOG.debug('Adding commented {} path to support/configure/RELEASE'.format(mod[0])) app_file.write("#{}={}\n".format(mod[0], mod[1])) app_file.close()
def generate_unique_cmd(self, action): LOG.debug('Generating template unique.cmd from ioc environment...') ioc_path = installSynApps.join_path(self.ioc_template_dir, action.ioc_name) unique_fp = open(installSynApps.join_path(ioc_path, 'unique.cmd'), 'w') unique_fp.write( '###############################################################\n' ) unique_fp.write( '# installSynApps Auto-Generated IOC Template{:<19}#\n'.format('')) unique_fp.write( '# Meant for use with bundles running ADCore {:<19} #\n'.format( self.install_config.get_core_version())) unique_fp.write('# Generated: {:<53}#\n'.format( str(datetime.datetime.now()))) unique_fp.write( '###############################################################\n\n\n' ) for env_var in action.epics_environment.keys(): unique_fp.write('epicsEnvSet("{}",{}"{}")\n'.format( env_var, ' ' * (32 - len(env_var)), action.epics_environment[env_var])) unique_fp.close()
def generate_uninstall(self): """Function that generates an uninstall file based on currently loaded install_config """ LOG.debug('Autogenerating bash uninstall script') uninstall_fp = open(installSynApps.join_path(self.install_config.install_location, "/autogenerated/uninstall.sh"), "w+") uninstall_fp.write("#!/bin/bash\n") uninstall_fp.write(self.message) modules = self.install_config.get_module_list() modules.reverse() for module in modules: if module.build == "YES": uninstall_fp.write("{}={}\n".format(module.name, module.abs_path)) for module in modules: if module.build == "YES": uninstall_fp.write("cd ${}\n".format(module.name)) uninstall_fp.write("make clean uninstall\n") uninstall_fp.write("make clean uninstall\n") modules.reverse() uninstall_fp.close()
def update_macros_dir(self, macro_replace_list, target_dir, force_override_comments=False): """Function that updates the macros for all files in a target location, given a list of macro-value pairs Parameters ---------- macro_replace_list : List list containting macro-value pairs target_dir : str path of target dir for which all macros will be edited. """ LOG.debug('Updating macros in directory {}'.format(target_dir)) if os.path.exists(target_dir) and os.path.isdir(target_dir): for file in os.listdir(target_dir): if os.path.isfile( target_dir + "/" + file) and not file.endswith( ".pl" ) and file != "Makefile" and not file.endswith(".ioc"): self.update_macros_file(macro_replace_list, target_dir, file, force=force_override_comments)
def create_config_file(self, action): LOG.debug('Generating config file for use with procServ...') ioc_path = installSynApps.join_path(self.ioc_template_dir, action.ioc_name) config_fp = open(installSynApps.join_path(ioc_path, 'config'), 'w') config_fp.write('NAME={}\nPORT={}\nUSER=softioc\nHOST={}\n'.format( action.ioc_name, '4000', 'localhost')) config_fp.close()
def cleanup_modules(self): """Function responsible for cleaning up directories that were not selected to clone """ if self.install_config != None and isinstance(self.install_config, IC.InstallConfiguration): for module in self.install_config.modules: if isinstance(module, IM.InstallModule): if module.clone == "NO" and os.path.exists(module.abs_path): LOG.debug('Removing unused repo {}'.format(module.name)) shutil.rmtree(module.abs_path)
def initialize_dir(self): """Function that creates an autogenerated directory """ autogenerated_dir = installSynApps.join_path(self.install_config.install_location, "autogenerated") if os.path.exists(autogenerated_dir): LOG.debug('Removing existing autogenerated script directory') shutil.rmtree(autogenerated_dir) LOG.debug('Creating autogenerated script directory') os.mkdir(autogenerated_dir)
def generate_env_paths(self, ioc_top_path, ioc_boot_path, target, action): LOG.debug('Generating template envPaths based on compiled binaries...') ioc_path = installSynApps.join_path(self.ioc_template_dir, action.ioc_name) envPaths_fp = open(installSynApps.join_path(ioc_path, 'envPaths'), 'w') arch = 'linux-x86_64' if platform == 'win32': arch = 'windows-x64-static' envPaths_fp.write( '# Relative envPaths file auto-generated by installSynApps\n#\n') envPaths_fp.write( '# The BUNDLE_LOC env variable is set in st.cmd. Please edit to top bundle location\n#\n' ) envPaths_fp.write('epicsEnvSet("ARCH", "{}")\n'.format(arch)) envPaths_fp.write('epicsEnvSet("TOP", "{}")\n'.format(ioc_top_path)) base_path = installSynApps.join_path('$(BUNDLE_LOC)', 'base') envPaths_fp.write('epicsEnvSet("EPICS_BASE",{}"{}")\n'.format( (' ' * 14), base_path)) support_path = "$(BUNDLE_LOC)" support_path = installSynApps.join_path(support_path, "support") envPaths_fp.write('epicsEnvSet("SUPPORT",{}"{}")\n\n'.format( (' ' * 17), support_path)) for dir in os.listdir(self.install_config.support_path): mod_path = installSynApps.join_path( self.install_config.support_path, dir) if os.path.isdir(mod_path) and dir not in [ 'base', 'configure', 'utils', 'documentation', '.git', 'lib', 'bin' ]: mod_path = installSynApps.join_path('$(SUPPORT)', dir) envPaths_fp.write('epicsEnvSet("{}",{}"{}")\n'.format( self.get_env_paths_name(dir), ' ' * (24 - len(self.get_env_paths_name(dir))), mod_path)) envPaths_fp.write('\n') for dir in os.listdir(self.install_config.ad_path): mod_path = installSynApps.join_path(self.install_config.ad_path, dir) if os.path.isdir(mod_path) and dir not in [ 'configure', 'docs', 'documentation', 'ci', '.git', '' ]: mod_path = installSynApps.join_path('$(AREA_DETECTOR)', dir) envPaths_fp.write('epicsEnvSet("{}",{}"{}")\n'.format( self.get_env_paths_name(dir), ' ' * (24 - len(self.get_env_paths_name(dir))), mod_path)) envPaths_fp.close()
def grab_dependencies_from_bundle(self, ioc_path, iocBoot_path): LOG.debug('Collecting additional iocBoot files from bundle...') for file in os.listdir(iocBoot_path): target = installSynApps.join_path(iocBoot_path, file) if os.path.isfile(target): if not file.startswith( ('Makefile', 'st', 'test', 'READ', 'dll', 'envPaths')) and not file.endswith(('.xml', '.txt')): shutil.copyfile(target, installSynApps.join_path(ioc_path, file))
def add_to_environment(self, line): try: line_s = line.strip() line_s = re.sub('"', '', line_s) line_s = re.sub('\t', '', line_s) line_s = re.sub(' +', '', line_s) line_s = re.sub('epicsEnvSet', '', line_s) temp = line_s.split(',') self.epics_environment[temp[0][1:]] = temp[1][:-1] except IndexError: LOG.debug('Error, failed to parse epics environment variable.')
def find_isa_version(): """Function that attempts to get the version of installSynApps used. Returns ------- isa_version : str The version string for installSynApps. Either hardcoded version, or git tag description commit_hash : str None if git status not available, otherwise hash of current installSynApps commit. """ isa_version = __version__ commit_hash = None try: LOG.debug('git describe --tags') FNULL = open(os.devnull, 'w') out = subprocess.check_output(['git', 'describe', '--tags'], stderr=FNULL) isa_version = out.decode('utf-8').strip() LOG.debug('git rev-parse HEAD') out = subprocess.check_output(['git', 'rev-parse', 'HEAD'], stderr=FNULL) commit_hash = out.decode('utf-8') FNULL.close() except PermissionError: LOG.debug('Could not find git information for installSynApps versions, defaulting to internal version.') except subprocess.CalledProcessError: LOG.debug('Running from non-git version of installSynApps, default to internal version number.') return isa_version, commit_hash
def grab_module(self, top, module, include_src=False): """Function that grabs all of the required folders from each individual module. Parameters ---------- top : str resulting location - __temp__ module_name : str folder name for the module module_location : str path to dir of location of module """ module_name = os.path.basename(module.abs_path) target_folder = module.abs_path if not os.path.exists(target_folder): LOG.debug('Module {} not found, skipping...'.format(module.name)) return # In a release version we don't need any support helper utilities, so skip it. if not include_src and not module.name == 'SUPPORT': LOG.debug('Grabbing lean files for module {}.'.format(module.name)) self.grab_folder(target_folder + '/opi', top + '/' + module_name + '/opi') self.grab_folder(target_folder + '/db', top + '/' + module_name + '/db') self.grab_folder(target_folder + '/dbd', top + '/' + module_name + '/dbd') self.grab_folder(target_folder + '/include', top + '/' + module_name + '/include') self.grab_folder(target_folder + '/bin/' + self.arch, top + '/' + module_name + '/bin/' + self.arch) self.grab_folder(target_folder + '/lib/' + self.arch, top + '/' + module_name + '/lib/' + self.arch) self.grab_folder(target_folder + '/configure', top + '/' + module_name + '/configure') self.grab_folder(target_folder + '/iocBoot', top + '/' + module_name + '/iocBoot') self.grab_folder(target_folder + '/modules', top + '/' + module_name + '/modules') self.grab_folder(target_folder + '/ADViewers/ImageJ', top + '/' + module_name + '/ADViewers/ImageJ') for dir in os.listdir(target_folder): if 'App' in dir and not dir.startswith('test'): self.grab_folder(target_folder + '/' + dir + '/Db', top + '/' + module_name +'/' + dir + '/Db') self.grab_folder(target_folder + '/' + dir + '/op', top + '/' + module_name +'/' + dir + '/op') if os.path.exists(target_folder + '/iocs'): for dir in os.listdir(target_folder + '/iocs'): ioc_folder = '/iocs/' + dir if 'IOC' in dir: LOG.debug('Grabbing IOC files for module {} ioc: {}'.format(module.name, dir)) self.grab_folder(target_folder + ioc_folder + '/bin/' + self.arch, top + '/' + module_name + ioc_folder + '/bin/' + self.arch) self.grab_folder(target_folder + ioc_folder + '/lib/' + self.arch, top + '/' + module_name + ioc_folder + '/lib/' + self.arch) self.grab_folder(target_folder + ioc_folder + '/dbd', top + '/' + module_name + ioc_folder + '/dbd') self.grab_folder(target_folder + ioc_folder + '/iocBoot', top + '/' + module_name + ioc_folder + '/iocBoot') else: LOG.debug('Grabbing full files for module {}.'.format(module.name)) # Grab some necessary non-module folders and files if module.name == 'AREA_DETECTOR': self.grab_folder(target_folder + '/configure', top + '/' + module_name + '/configure') elif module.name == 'SUPPORT': self.grab_folder(target_folder + '/configure', top + '/' + '/configure') self.grab_folder(target_folder + '/utils', top + '/' + '/utils') self.grab_file(target_folder + '/Makefile', top + '/' + '/Makefile') else: # Otherwise grab the entire module self.grab_folder(target_folder, top + '/' + module_name)
def create_opi_tarball(self): """Function that collects autoconverted .opi files from epics_dir. OPI screens are saved in output_location/ad_opis and creats a tarball. Returns ------- int 0 if suceeded, nonzero otherwise """ opi_base_dir = installSynApps.join_path(self.output_location, '__opis_temp__') opi_dir = installSynApps.join_path(opi_base_dir, 'opis') try: os.mkdir(opi_base_dir) os.mkdir(opi_dir) except OSError: LOG.write('Error creating ' + opi_dir + ' directory', ) for (root, _, files) in os.walk(self.install_config.install_location, topdown=True): for name in files: if '.opi' in name and 'autoconvert' in root: file_name = installSynApps.join_path(root, name) try: shutil.copy(file_name, opi_dir) except OSError: LOG.debug("Can't copy {} to {}".format( file_name, opi_dir)) opi_tarball_basename = 'opis_{}'.format( self.install_config.get_core_version()) opi_tarball = opi_tarball_basename counter = 1 while os.path.exists( installSynApps.join_path(self.output_location, opi_tarball + '.tgz')): opi_tarball = opi_tarball_basename + '_({})'.format(counter) counter = counter + 1 out = subprocess.call( ['tar', 'czf', opi_tarball + '.tgz', '-C', opi_base_dir, '.']) shutil.rmtree(opi_base_dir) os.rename( opi_tarball + '.tgz', installSynApps.join_path(self.output_location, opi_tarball + '.tgz')) return out
def write_build_flags(self, filepath): """Helper Function for writing build flags from install config Parameters ---------- filepath : str Path into which we wish to save configuration """ new_build_flag = open(filepath + "/macroFiles/BUILD_FLAG_CONFIG", 'w') new_build_flag.write('# Saved by installSynApps on {}\n\n'.format(datetime.datetime.now())) for macro_pair in self.install_config.build_flags: LOG.debug('Writing build flag {}={}'.format(macro_pair[0], macro_pair[1])) new_build_flag.write('{}={}\n'.format(macro_pair[0], macro_pair[1])) new_build_flag.close()
def generate_remake_sources(self): """Function that creates a bash/batch script for regenerating binaries from sources """ LOG.debug('Autogenerating regenerateSources bash script') regenerate_fp = open(installSynApps.join_path(self.install_config.install_location, 'autogenerated', 'regenerateSources.sh'), 'w+') regenerate_fp.write('#!/bin/bash\n\ngit clone https://github.com/NSLS-II/installSynApps\n') isa_version, isa_commit_hash = installSynApps.find_isa_version() regenerate_fp.write('cd installSynApps\n') if isa_commit_hash is not None: regenerate_fp.write('git checkout {}\n'.format(isa_commit_hash)) else: regenerate_fp.write('git checkout -q {}\n'.format(isa_version)) abs_loc = os.path.abspath(self.install_config.install_location) regenerate_fp.write('./installCLI.py -i {} -c {} -p -y\n\n'.format(installSynApps.join_path(abs_loc, 'regenerated'), installSynApps.join_path(abs_loc, 'build-config'))) regenerate_fp.close()
def generate_st_cmd(self, action, executable_path, st_base_path): LOG.debug( 'Generating st.cmd using base file:\n{}'.format(st_base_path)) ioc_path = installSynApps.join_path(self.ioc_template_dir, action.ioc_name) lib_path = self.get_lib_path_str(action) # Create base st.cmd, add call to executable st = self.initialize_st_base_file(ioc_path, lib_path, executable_path) LOG.debug('Writing base st.cmd file') # Define envPaths st.write('< envPaths\n\n') # Open existing st.cmd base file st_base_fp = open(st_base_path, 'r') # Read through the lines, add a 'unique.cmd' call after all env sets, and add envSet calls to action environment lines = st_base_fp.readlines() wrote_unique = False for line in lines: if line.startswith( '#!') or 'unique.cmd' in line or 'envPaths' in line: pass elif line.startswith('#'): st.write(line) elif 'Config(' in line and not wrote_unique: st.write('\n< unique.cmd\n\n') st.write(line) wrote_unique = True elif line.startswith('epicsEnvSet'): action.add_to_environment(line) st.write(line) else: st.write(line) st_base_fp.close() st.close() # Collect environment variables set in any other files self.grab_additional_env(action, st_base_path) # Make st.cmd executable. os.chmod(installSynApps.join_path(ioc_path, "st.cmd"), 0o755)
def checkout_module(self, module, recursive=False): """Function responsible for checking out selected tagged versions of modules. Parameters ---------- module : InstallModule Module that is being checked out recursive : bool Specifies whether there are git submodules that need to be initialized Returns ------- int -3 if input was not an InstallModule, -2 if the absolute path is not known, -1 if checkout fails, 0 if success """ ret = -1 LOG.debug('Checking out version for module {}'.format(module.name)) if isinstance(module, IM.InstallModule): if module.abs_path != None: ret = 0 if module.version != "master" and module.url_type == "GIT_URL": current_loc = os.getcwd() os.chdir(module.abs_path) command = "git checkout -q {}".format(module.version) LOG.print_command(command) proc = Popen(command.split(' ')) proc.wait() ret = proc.returncode if recursive and ret == 0: command = 'git submodule update' LOG.print_command(command) proc = Popen(command.split(' ')) proc.wait() ret = proc.returncode os.chdir(current_loc) if ret == 0: LOG.write('Checked out version {}'.format( module.version)) else: LOG.write( 'Checkout of version {} failed for module {}.'. format(module.version, module.name)) return ret
def write_injector_files(self, filepath): """Helper Function for writing injector files from install config Parameters ---------- filepath : str Path into which we wish to save configuration """ # for each injector file write it with its target location for injector_file in self.install_config.injector_files: LOG.debug('Saving injector file {} with target {}'.format(injector_file.name, injector_file.target)) new_fp = open(filepath + "/injectionFiles/" + injector_file.name, 'w') new_fp.write('# Saved by installSynApps on {}\n'.format(datetime.datetime.now())) new_fp.write('__TARGET_LOC__={}\n\n'.format(injector_file.target)) new_fp.write(injector_file.contents) new_fp.close()
def parse_line_to_module(self, line, current_url, current_url_type): """Function that parses a line in the INSTALL_CONFIG file into an InstallModule object Parameters ---------- line : str line from table in file current_url : str url at which module is located current_url_type : str either GIT_URL or WGET_URL Returns ------- InstallModule module parsed from the table line """ # Remove extra whitespace line = re.sub('\t', ' ', line) line = re.sub(' +', ' ', line) module_components = line.split(' ') # If a line is read that isn't in the correct format return None if len(module_components) < 6: return None # line will be in format: # NAME VERSION RELATIVE_PATH REPOSITORY CLONE BUILD PACKAGE name = module_components[0] version = module_components[1] rel_path = module_components[2] repository = module_components[3] clone = module_components[4] build = module_components[5] if name in self.required_in_package: package = "YES" # Add length check for compatibility with older configure directories - default package to NO elif len(module_components) == 7: package = module_components[6] else: package = "NO" # create object from line and return it LOG.debug('Parsed install module: {}'.format(name)) install_module = IM.InstallModule(name, version, rel_path, current_url_type, current_url, repository, clone, build, package) return install_module
def autogenerate_all(self, create_simple_readme=True): """Top level function that calls all autogeneration functions Parameters ---------- create_simple_readme : bool If true, generate simplified README file based on install config """ if platform == 'win32': LOG.debug('Windows machine detected, skipping script generation.') else: LOG.debug('Generating auto-(un)install helper scripts') self.initialize_dir() self.generate_install() self.generate_uninstall() self.generate_remake_sources() if create_simple_readme: self.generate_readme_simple()
def grab_configuration_used(self, top_location, module, readme_fp): """Function that includes the install configuration into the bundle for reuse. Parameters ---------- top : str resulting location - __temp__ """ try: isa_version, isa_commit_hash = installSynApps.find_isa_version() self.generate_build_config(top_location, module, readme_fp) readme_fp.write('Build configuration:\n\n') readme_fp.write( 'installSynApps Version: {}\n\n'.format(isa_version)) readme_fp.write( 'To grab this version:\n\n git clone https://github.com/epicsNSLS2-deploy/installSynApps\n' ) if isa_commit_hash is not None: readme_fp.write( ' git checkout {}\n'.format(isa_commit_hash)) else: readme_fp.write(' git checkout -q {}\n'.format(isa_version)) readme_fp.write( 'To regenerate sources for this bundle, grab installSynApps, and run:\n\n' ) readme_fp.write( ' ./installCLI.py -c $BUILD_CONFIG -i $INSTALL_LOCATION -p\n\n' ) readme_fp.write( 'where $BUILD_CONFIG is the path to the build-config directory,\n' ) readme_fp.write( 'and $INSTALL_LOCATION is your target install path.\n\n{}\n'. format('-' * 64)) readme_fp.write('{:<20}{}\n'.format('Python 3 Version:', sys.version.split()[0])) readme_fp.write('{:<20}{}\n'.format('OS Class:', self.OS)) readme_fp.write('{:<20}{}\n'.format('Build Date:', datetime.datetime.now())) except: LOG.debug('Failed to copy install configuration into bundle.')
def generate_install(self): """Function that generates an install file based on currently loaded install_config """ LOG.debug('Autogenerating bash install script') install_fp = open(self.install_config.install_location + "/autogenerated/install.sh", "w+") install_fp.write("#!/bin/bash\n") install_fp.write(self.message) for module in self.install_config.get_module_list(): if module.build == "YES": install_fp.write("{}={}\n".format(module.name, module.abs_path)) for module in self.install_config.get_module_list(): if module.build == "YES": install_fp.write("cd ${}\n".format(module.name)) install_fp.write("make -sj\n") install_fp.close()
def grab_ioc_files(self, top, target_loc, module_name, flat_grab): for dir in os.listdir(target_loc + '/iocs'): ioc_folder = '/iocs/' + dir if 'IOC' in dir: if not flat_grab: LOG.debug( 'Grabbing IOC files for module {} ioc: {}'.format( module_name, dir)) module_base_folder = os.path.basename(target_loc) for arch in self.arch_list: self.grab_folder( target_loc + ioc_folder + '/bin/' + arch, top + '/' + module_base_folder + ioc_folder + '/bin/' + arch) self.grab_folder( target_loc + ioc_folder + '/lib/' + arch, top + '/' + module_base_folder + ioc_folder + '/lib/' + arch) self.grab_folder( target_loc + ioc_folder + '/dbd', top + '/' + module_base_folder + ioc_folder + '/dbd') self.grab_folder( target_loc + ioc_folder + '/iocBoot', top + '/' + module_base_folder + ioc_folder + '/iocBoot') else: LOG.debug( 'Grabbing IOC files for module {} ioc: {}'.format( module_name, dir)) for arch in self.arch_list: self.grab_all_files_in_dir( target_loc + ioc_folder + '/bin/' + arch, top + '/bin/' + arch) self.grab_all_files_in_dir( target_loc + ioc_folder + '/lib/' + arch, top + '/lib/' + arch) self.grab_all_files_in_dir( target_loc + ioc_folder + '/dbd', top + '/dbd') self.grab_all_files_in_dir( target_loc + ioc_folder + '/protocol', top + '/protocol')
def inject_to_file(self, injector_file): """Function that injects contents of specified file into target First, convert to absolute path given the install config. Then open it in append mode, then write all uncommented lines in the injector file into the target, and then close both Parameters ---------- injector_file_path : InjectorFile object representing injector file """ target_path = injector_file.target if target_path is None or len(target_path) == 0: return target_path = self.install_config.convert_path_abs(target_path) target_file = os.path.basename(target_path) if (not os.path.exists(target_path)): return if target_file.startswith("EXAMPLE_"): target_path_no_example = installSynApps.join_path(os.path.dirname(target_path), target_file[8:]) if os.path.exists(target_path): os.rename(target_path, target_path_no_example) target_path = target_path_no_example target_fp = open(target_path, "a") target_fp.write("\n# ------------The following was auto-generated by installSynApps-------\n\n") if injector_file.contents is not None: LOG.debug('Injecting into {}'.format(target_path)) target_fp.write(injector_file.contents) LOG.debug(injector_file.contents, force_no_timestamp=True) LOG.debug('Injection Done.') target_fp.write("\n# --------------------------Auto-generated end----------------------\n") target_fp.close()
def create_bundle_name(self, module_name=None, source_bundle=False): """Helper function for creating output filename Returns ------- str An output filename describing architecture and ADCore version """ if module_name is not None: module = self.install_config.get_module_by_name(module_name) if module is None: return None bundle_type = 'Prod' if source_bundle: bundle_type = 'Debug' date_str = datetime.date.today() try: core_version = self.install_config.get_core_version() if module_name is None: output_filename = '{}_AD_{}_{}_{}_{}'.format(self.institution, core_version, bundle_type, self.OS, date_str) else: output_filename = '{}_AD_{}_{}_{}_{}_addon'.format(self.institution, core_version, bundle_type, self.OS, module.name) except: LOG.debug('Error generating custom tarball name.') output_filename = 'EPICS_Binary_Bundle_{}'.format(self.OS) temp = output_filename counter = 1 while os.path.exists(self.output_location + '/' + temp + '.tgz'): temp = output_filename temp = temp + '_({})'.format(counter) counter = counter + 1 output_filename = temp LOG.debug('Generated potential output tarball name as: {}'.format(output_filename)) return output_filename
def initialize_st_base_file(self, ioc_path, lib_path, executable_path): """Function responsible for handling executable path injection, and base file creation """ # Setup st.cmd to be executable, rest will be in st_base.cmd LOG.debug('Setting up executable st.cmd with library path') st_exe = open(installSynApps.join_path(ioc_path, 'st.cmd'), 'w+') executable_path_rel = '$BUNDLE_LOC/support/{}'.format( executable_path.split('support/')[1]) if platform == 'win32': st_exe.write('@echo OFF\n\n{}\n\n{} st_base.cmd\n'.format( lib_path, executable_path_rel)) else: st_exe.write('#!/bin/bash\n\n{}\n\n{} st_base.cmd\n'.format( lib_path, executable_path_rel)) st_exe.close() st = open(installSynApps.join_path(ioc_path, "st_base.cmd"), "w+") return st