def installKits(self, dbm): self._logger.info('Installing kits') self.out('\n' + _('Installing kits') + '...\n') kitApi = KitApi() # Iterate over the glob of 'kits-*.tar.bz2' kitFileGlob = '%s/kits/kit-*.tar.bz2' % (self._cm.getRoot()) # Split comma-separated list of kits to skip installing. Sorry, you # cannot skip installing the base kit. val = self._settings['skip_kits'] \ if 'skip_kits' in self._settings else '' skip_kits = set([ item for item in val.split(',') if item != 'base']) \ if val else set() for kitPackage in glob.glob(kitFileGlob): try: kit = get_metadata_from_archive(kitPackage) except KitNotFound: msg = 'Kit [%s] is malformed/invalid. Skipping.' % ( os.path.basename(kitPackage)) self._logger.error(msg) self.out(' %s\n' % (msg)) continue if kit['name'] in skip_kits: msg = 'Kit [%s] installation skipped.' % (kit['name']) self.out(' %s\n' % (msg)) self._logger.info(msg) continue try: kitApi.installKitPackage(dbm, kitPackage) except EulaAcceptanceRequired: msg = 'Kit [%s] requires EULA acceptance. Skipping.' % ( kitPackage) self.out(' %s\n' % (msg)) self._logger.info(msg) continue self.out(' - %s installed.\n' % (kit['name'])) self._logger.info('Kit [%s] installed' % (kit['name'])) self._logger.info('Done installing kits') load_kits()
def _enable_kit_component(self, kit, comp_name, comp_version, software_profile): """ Enables a regular kit component on a specific software profile. :param kit: the Kit instance, whose component is being enabled :param comp_name: the name of the component to enable :param comp_version: the version of the component to enable :param software_profile: the software profile on which the component will be enabled :return: the Component instance that was enabled """ kit_spec = (kit.getName(), kit.getVersion(), kit.getIteration()) load_kits() installer = get_kit_installer(kit_spec)() comp_installer = installer.get_component_installer(comp_name) if not comp_installer.is_enableable(software_profile): self.getLogger().warning('Component cannot be enabled: {}'.format( comp_installer.spec)) return None comp_installer.run_action('pre_enable', software_profile.getName()) best_match_component = self._add_component_to_software_profile( kit, comp_name, comp_version, software_profile) comp_installer.run_action('enable', software_profile.getName()) comp_installer.run_action('post_enable', software_profile.getName()) return best_match_component
def _disable_kit_component(self, kit, comp_name, comp_version, software_profile): """ Disables a regular kit component on a specific software profile. :param kit: the Kit instance, whose component is being disabled :param comp_name: the name of the component to disable :param comp_version: the version of the component to disable :param software_profile: the software profile on which the component will be disable :return: the Component instance that was disabled """ kit_spec = (kit.getName(), kit.getVersion(), kit.getIteration()) load_kits() installer = get_kit_installer(kit_spec)() comp_installer = installer.get_component_installer(comp_name) comp_installer.run_action('pre_disable', software_profile.getName()) comp_installer.run_action('disable', software_profile.getName()) best_match_component = \ self._remove_component_from_software_profile( kit, comp_name, comp_version, software_profile) comp_installer.run_action('post_disable', software_profile.getName()) return best_match_component
def runCommand(self): self.parseArgs( _(""" Lists all software to hardware profile mappings in the system. """)) load_kits() softwareUsesHardwareDbApi = SoftwareUsesHardwareDbApi() hwApi = HardwareProfileApi() swApi = SoftwareProfileApi() with DbManager().session() as session: hwPList = hwApi.getHardwareProfileList(session) swPList = swApi.getSoftwareProfileList(session) mappingList = softwareUsesHardwareDbApi.getSoftwareUsesHardwareList( session) print('Current mappings:') print('Software Profile Hardware Profile') for mapping in mappingList: outputString = '' for sp in swPList: if sp.getId() == mapping[0]: outputString += ' %s' % sp.getName() outputString = outputString.ljust(32) for hp in hwPList: if hp.getId() == mapping[1]: outputString += hp.getName() print(outputString)
def run_server(daemonize: bool = False, pidfile: str = None, debug: bool = False): logger.debug('Starting service') # # Load kits # load_kits() # # Initialize plugins # if daemonize: plugins.Daemonizer(cherrypy.engine).subscribe() if pidfile: plugins.PIDFile(cherrypy.engine, pidfile).subscribe() DatabasePlugin(cherrypy.engine).subscribe() WebsocketPlugin( app.cm.getWebsocketScheme(), app.cm.getWebsocketPort(), cherrypy.engine, debug=debug ).subscribe() # # Setup the signal handler to stop the application while running. # cherrypy.engine.signals.subscribe() # # Initialize tools # cherrypy.tools.db = DatabaseTool() authentication_methods = [ auth_methods.HttpBasicAuthenticationMethod(), auth_methods.HttpBasicAuthenticationVaultMethod(), auth_methods.HttpSessionAuthenticationMethod(), auth_methods.HttpJwtAuthenticationMethod() ] cherrypy.tools.auth = cherrypy.Tool( 'before_handler', CherryPyAuthenticator(authentication_methods) ) # # Start the engine. # cherrypy.engine.start() cherrypy.engine.block() return 0
def main(): if len(sys.argv) != 2: sys.exit(1) # ensure all available kits are loaded load_kits() nodeName = sys.argv[1].lower() # Load DNSZone from GlobalParameters session = dbm.openSession() try: get_puppet_node_yaml(session, nodeName) finally: dbm.closeSession()
def _map_db_tables(self): # # Make sure all kit table mappers have been registered # load_kits() for kit_installer_class in get_all_kit_installers(): kit_installer = kit_installer_class() kit_installer.register_database_table_mappers() # # Map all tables that haven't yet been mapped # for table_mapper in get_all_table_mappers(): key = table_mapper.__name__ if key not in self._mapped_tables.keys(): logger.debug('Mapping table: {}'.format(key)) self._mapped_tables[key] = table_mapper() self._mapped_tables[key].map(self)
def runCommand(self): self.parseArgs( _(""" Display list of nodes able to use the specified software profile, ordered by cost. """)) softwareProfileName = self.getArgs().softwareProfile nodeApi = NodeApi() softwareUsesHardwareDbApi = SoftwareUsesHardwareDbApi() hardwareProfileDbApi = HardwareProfileDbApi() load_kits() with DbManager().session() as session: hwPList = hardwareProfileDbApi.getHardwareProfileList(session) hardwareProfileIdList = softwareUsesHardwareDbApi.\ getAllowedHardwareProfilesBySoftwareProfileName( session, softwareProfileName) nodeList = nodeApi.getNodeList(session) usableNodes = [] for node in nodeList: if (node.getHardwareProfile().getId() in hardwareProfileIdList) \ and node.getIsIdle(): usableNodes.append(node) costNameList = [] for node in usableNodes: nodeHwP = node.getHardwareProfile().getId() for hwP in hwPList: if hwP.getId() == nodeHwP: costNameList.append( [int(hwP.getCost()), node.getName()]) break costNameList.sort() for node in costNameList: print('%s' % (node[1]))
def runCommand(self): self.parseArgs() load_kits() with DbManager().session() as session: kitmgr = KitActionsManager() kitmgr.session = session component = kitmgr.load_component(self.getArgs().cname) nodegroup = 'installer' if '_configure' not in dir(component): print(_('This component does not have configuration'), file=sys.stderr) sys.exit(0) component._configure(nodegroup, sys.stdout)
def start(self): self.bus.log('[{0}] Initializing thread manager'.format( self.__class__.__name__)) # # Ensure that all kit worker actions are loaded # load_kits() for kit_installer_class in get_all_kit_installers(): kit_installer = kit_installer_class() kit_installer.register_web_service_worker_actions() # Create 8 worker threads num_worker_threads = 8 self.bus.log('[{0}] Initializing {1} worker threads'.format( self.__class__.__name__, num_worker_threads)) for thread_id in range(num_worker_threads): t = threading.Thread(target=worker_thread, args=(thread_id, threadManager)) t.setDaemon(True) t.start()
def runCommand(self): self.parseArgs( _(""" Installs operating system media to Tortuga for the purpose of package-based node provisioning. """)) load_kits() api = getKitApi(self.getUsername(), self.getPassword()) # Pre-process the media URL list os_media_urls: List[str] = self.getArgs().osMediaUrl.split(',') with DbManager().session() as session: api.installOsKit(session, os_media_urls, bUseSymlinks=self.getArgs().symlinksFlag, bInteractive=True, mirror=self.getArgs().mirror) if self.getArgs().sync: Puppet().agent()
def setupRoutes(): """ Used to setup RESTFul resources. """ # # Ensure all kits are loaded, and their web services are registered # load_kits() for kit_installer_class in get_all_kit_installers(): kit_installer = kit_installer_class() kit_installer.register_web_service_controllers() dispatcher = cherrypy.dispatch.RoutesDispatcher() dispatcher.mapper.explicit = False for controller_class in get_all_ws_controllers(): controller = controller_class() for action in controller.actions: dispatcher.connect(action['name'], action['path'], action=action['action'], controller=controller, conditions=dict(method=action['method'])) return dispatcher
def runCommand(self): self.parseArgs( _(""" Show the software to hardware profile mappings for the specified software profile.""")) load_kits() softwareUsesHardwareDbApi = SoftwareUsesHardwareDbApi() with DbManager().session() as session: api = HardwareProfileApi() hardwareProfileIdList = softwareUsesHardwareDbApi.\ getAllowedHardwareProfilesBySoftwareProfileName( session, self.getArgs().swprofile) print('Software Profile [%s] is allowed to use the following' ' hardware profiles:' % (self.getArgs().swprofile)) for hardwareProfileId in hardwareProfileIdList: for hp in api.getHardwareProfileList(session): if hp.getId() == hardwareProfileId: print(hp.getName())
# the Celery app that does not depend on an external broker. # if 'TORTUGA_TEST' in os.environ: app = TestApp(include=[ 'tortuga.events.tasks', 'tortuga.resourceAdapter.tasks', ]) app.app = Application() app.dbm = DbManager() # # In regular mode, we also want to load the kits, and include any tasks # they may have as well. # else: load_kits() kits_task_modules: List[str] = [] for kit_installer_class in get_all_kit_installers(): kit_installer = kit_installer_class() kit_installer.register_event_listeners() kits_task_modules += kit_installer.task_modules config_manager = ConfigManager() redis_password = config_manager.getRedisPassword() app = TortugaCeleryApp( 'tortuga.tasks.queue', broker='redis://:{}@localhost:6379/0'.format(redis_password), backend='redis://:{}@localhost:6379/0'.format(redis_password), include=[ 'tortuga.events.tasks',
def __init__(self): super(KitActionsManager, self).__init__() load_kits()
def main(): cm = ConfigManager() p = argparse.ArgumentParser() p.add_argument('-f', '--force', dest='force', action='store_true', default=False) p.add_argument('name', help='Software profile name') p.add_argument('kit', help='Kit descriptor (NAME-VERSION-ITERATION)') p.add_argument('component', help='Component descriptor (NAME-VERSION)') args = p.parse_args() kitNameAndVersion, kitIteration = args.kit.rsplit('-', 1) kitName, kitVersion = kitNameAndVersion.split('-', 1) compName, _ = args.component.split('-', 2) flagFile = os.path.join( cm.getRoot(), 'var/run/actions/%s/component_%s_%s_post_install' % (args.name, args.kit, args.component)) if os.path.exists(flagFile): if not args.force: sys.stderr.write( 'post-install component action for [%s] already run\n' % (compName)) sys.exit(0) # Remove the existing flag file, we're forcing a run os.unlink(flagFile) load_kits() kit_spec = (kitName, kitVersion, kitIteration) try: with DbManager().session() as session: kit_installer = get_kit_installer(kit_spec)() kit_installer.session = session c = kit_installer.get_component_installer(compName) if c is None: raise ComponentNotFound( 'Component [%s] not found in kit [%s]' % (compName, kitName)) c.run_action('post_install') logger.debug( 'post_install component action run for [%s] from kit [%s]' % (args.component, args.kit)) # Ensure destination directory exists if not os.path.exists(os.path.dirname(flagFile)): os.makedirs(os.path.dirname(flagFile)) # touch flagFile open(flagFile, 'w').close() except Exception as exc: # noqa pylint: disable=broad-except print('Error: {}'.format(exc), file=sys.stderr) sys.exit(0)