def _initialization(self, user_info, **kwargs): util.printStep('Initialize the OpenNebula connector.') self.user_info = user_info if self.is_build_image(): self.tmp_private_key, self.tmp_public_key = generate_keypair() self.user_info.set_private_key(self.tmp_private_key)
def _initialization(self, user_info): util.printStep('Initialize the CloudStack connector.') self.user_info = user_info if self.is_build_image(): raise NotImplementedError('The run category "%s" is not yet implemented' % self.run_category)
def _build_image_on_opennebula(self, user_info, node_instance): listener = self._get_listener() machine_name = node_instance.get_name() vm = self._get_vm(machine_name) ip_address = self._vm_get_ip(vm) vm_id = int(self._vm_get_id(vm)) self._wait_vm_in_state(vm_id, 'Active', time_out=300, time_sleep=10) self._build_image_increment(user_info, node_instance, ip_address) util.printStep('Creation of the new Image.') self._rpc_execute('one.vm.action', 'poweroff', vm_id) self._wait_vm_in_state(vm_id, 'Poweroff', time_out=300, time_sleep=10) listener.write_for(machine_name, 'Saving the image') new_image_name = node_instance.get_image_short_name() + time.strftime( "_%Y%m%d-%H%M%S") new_image_id = int( self._rpc_execute('one.vm.disksaveas', vm_id, 0, new_image_name, '', -1)) self._wait_image_in_state(new_image_id, 'Ready', time_out=1800, time_sleep=30) listener.write_for(machine_name, 'Image saved !') self._rpc_execute('one.vm.action', 'resume', vm_id) self._wait_vm_in_state(vm_id, 'Active', time_out=300, time_sleep=10) return str(new_image_id)
def _initialization(self, user_info): util.printStep('Initialize the OpenStack connector.') self._thread_local.driver = self._get_driver(user_info) try: self.flavors = self._thread_local.driver.list_sizes() except InvalidCredsError as e: raise Exceptions.ValidationException("%s: Invalid Cloud credentials. " "Please check your Cloud username, password, project name and domain " "(if applicable) in your SlipStream user profile." % self.get_cloud_service_name()) except LibcloudError as e: if e.message == 'Could not find specified endpoint': raise Exceptions.ValidationException("%s: Invalid Cloud configuration. " "Please ask your SlipStream administrator to check the region, " "service-type and service-name." % self.get_cloud_service_name()) else: raise if self.is_deployment(): self._get_iaas_attributes() self._import_keypair(user_info) elif self.is_build_image(): self._get_iaas_attributes() self._create_keypair_and_set_on_user_info(user_info)
def _build_image_on_openstack(self, user_info, node_instance): self._thread_local.driver = self._get_driver(user_info) listener = self._get_listener() if not user_info.get_private_key() and self.tempPrivateKey: user_info.set_private_key(self.tempPrivateKey) machine_name = node_instance.get_name() vm = self._get_vm(machine_name) util.printAndFlush("\n node_instance: %s \n" % str(node_instance)) util.printAndFlush("\n VM: %s \n" % str(vm)) ip_address = self._vm_get_ip(vm) vm_id = self._vm_get_id(vm) instance = vm['instance'] self._wait_instance_in_running_state(vm_id) self._build_image_increment(user_info, node_instance, ip_address) util.printStep('Creation of the new Image.') listener.write_for(machine_name, 'Saving the image') newImg = self._thread_local.driver.create_image(instance, node_instance.get_image_short_name(), metadata=None) self._wait_image_creation_completed(newImg.id) listener.write_for(machine_name, 'Image saved !') return newImg.id
def _execute_target(self, target_name, exports=None, abort_on_err=False, ssdisplay=True, ignore_abort=False): target = self.node_instance.get_image_target(target_name) display_target_name = { 'prerecipe': 'Pre-install', 'recipe': 'Post-install', 'execute': 'Deployment', 'report': 'Reporting', 'onvmadd': 'On VM Add', 'onvmremove': 'On VM Remove' }.get(target_name, target_name) if target is None: util.printAndFlush('Nothing to do for script: %s' % display_target_name) return for subtarget in target: full_target_name = '%s:%s' % (subtarget.get('module_uri'), display_target_name) if target_name in [NodeDecorator.NODE_PRERECIPE, NodeDecorator.NODE_RECIPE] \ and not self._need_to_execute_build_step(target, subtarget): util.printAndFlush('Component already built. Nothing to do on target: %s' % full_target_name) continue script = subtarget.get('script') if script: message = "Executing script '%s'" % full_target_name util.printStep(message) if ssdisplay: self.wrapper.set_statecustom(message) fail_msg = "Failed running '%s' script on '%s'" % (full_target_name, self._get_node_instance_name()) self._launch_script(script, exports, abort_on_err, ignore_abort, fail_msg, full_target_name) else: util.printAndFlush('Nothing to do for script: %s' % full_target_name)
def _initialization(self, user_info, **kwargs): util.printStep('Initialize the Docker connector.') self.user_info = user_info self.cert_string = user_info.get_cloud(self.CERT_KEY).replace("\\n", "\n") self.key_string = user_info.get_cloud(self.KEY_KEY).replace("\\n", "\n") self.docker_api = requests.Session() self.docker_api.verify = False self.docker_api.headers = {'Content-Type': 'application/json', 'Accept': 'application/json'}
def initialization(self, user_info): util.printStep('Initialize the OpenStack connector.') self._thread_local.driver = self._getDriver(user_info) self.flavors = self._thread_local.driver.list_sizes() self.images = self._thread_local.driver.list_images() if self.run_category == RUN_CATEGORY_DEPLOYMENT: self._importKeypair(user_info) elif self.run_category == RUN_CATEGORY_IMAGE: self._createKeypairAndSetOnUserInfo(user_info)
def updateSlipStreamImage(self): util.printStep("Updating SlipStream image run") image_info = self.getImageInfo() newImageId = self.cloudProxy.getNewImageId() if not newImageId: return self._updateSlipStreamImage(self.cloudProxy.getResourceUri(image_info), newImageId)
def initialization(self, user_info): util.printStep('Initialize the CloudStack connector.') self._thread_local.driver = self._getDriver(user_info) self.sizes = self._thread_local.driver.list_sizes() self.images = self._thread_local.driver.list_images() self.user_info = user_info if self.run_category == RUN_CATEGORY_DEPLOYMENT: self._importKeypair(user_info) elif self.run_category == RUN_CATEGORY_IMAGE: #self._createKeypairAndSetOnUserInfo(user_info) raise NotImplementedError('The run category "%s" is not yet implemented')
def _initialization(self, user_info): util.printStep('Initialize the CloudStack connector.') self.user_info = user_info if self.is_build_image(): raise NotImplementedError('The run category "%s" is not yet implemented' % self.run_category) elif self.is_deployment(): try: self._import_keypair(user_info) except Exceptions.ExecutionException as e: util.printError(e)
def onProvisioning(self): super(OrchestratorImageBuildExecutor, self).onProvisioning() util.printStep('Starting instance') try: self.wrapper.start_node_instances() except Exceptions.AbortException: pass except Exception as ex: util.printError('Error starting instance with error: %s' % ex) raise finally: self._complete_machine_state()
def onInitializing(self): util.printAction('Initializing') util.printStep('Starting instances') try: self.wrapper.startImages() except Exceptions.AbortException: pass except Exception as ex: util.printError('Error starting instances with error: %s' % ex) raise util.printStep('Publishing instance initialization information') self.wrapper.publishDeploymentInitializationInfo()
def onInitializing(self): util.printAction('Initializing') self._addSshPubkeyIfNeeded() util.printStep('Getting deployment targets') self.targets = self.wrapper.getTargets() util.printDetail('Deployment targets:') for target, script in self.targets.items(): util.printAndFlush('-' * 25) util.printDetail('Target: %s' % target) util.printDetail('Script:\n%s\n' % script[0])
def _run_instances_action(action, action_name): """ :param action: action to run :type action: callable :param action_name: name of the action :type: string """ util.printStep('%s instances' % action_name.capitalize()) try: action() except Exceptions.AbortException: pass except Exception as ex: util.printError('Error %s instances: %s' % (action_name, ex)) raise
def _start_image(self, user_info, node_instance, vm_name): # Adapt naming convention from IaaS model try: service = json.loads(node_instance.get_cloud_parameter("service")) except ValueError as ve: raise ValueError("Requested service is not in JSON format - %s" % ve), None, sys.exc_info()[2] except: raise service_name = service["Name"] if service.has_key("Name") else vm_name util.printStep('Deploy service %s to %s' % (service_name, user_info.get_cloud_endpoint())) return self._start_container_in_docker(user_info, node_instance, service_name)
def onExecuting(self): super(OrchestratorImageBuildExecutor, self).onExecuting() if self.wrapper.isAbort(): util.printError('Abort set, skipping Running') self._complete_machine_state() return util.printStep('Building new image') try: self.wrapper.build_image() except KeyboardInterrupt: raise except Exception as ex: self.wrapper.fail(str(ex)) finally: self._complete_machine_state()
def _initialization(self, user_info): util.printStep('Initialize the CloudStack connector.') self._thread_local.driver = self._get_driver(user_info) self.zones = self._thread_local.driver.list_locations() self.zone = self._get_zone(user_info) self.sizes = self._thread_local.driver.list_sizes(location=self.zone) self.images = self._thread_local.driver.list_images(location=self.zone) self.user_info = user_info if self.is_build_image(): raise NotImplementedError('The run category "%s" is not yet implemented' % self.run_category) elif self.is_deployment(): try: self._import_keypair(user_info) except Exceptions.ExecutionException as e: util.printError(e)
def onTerminal(self): util.printAction('Terminating') util.printStep('Stopping instances') try: self.wrapper.stopNodes() except Exceptions.AbortException: pass except Exception as ex: util.printError('Error stopping instances: %s' % ex) raise util.printStep('Publishing instance termination information') self.wrapper.publishDeploymentTerminateInfo() super(OrchestratorDeploymentExecutor, self).onTerminal() self._killItself()
def _build_image_on_opennebula(self, user_info, node_instance): listener = self._get_listener() machine_name = node_instance.get_name() vm = self._get_vm(machine_name) ip_address = self._vm_get_ip(vm) vm_id = int(self._vm_get_id(vm)) self._wait_vm_in_state(vm_id, 'Active', time_out=300, time_sleep=10) self._build_image_increment(user_info, node_instance, ip_address) util.printStep('Creation of the new Image.') self._rpc_execute('one.vm.action', 'poweroff', vm_id) self._wait_vm_in_state(vm_id, 'Poweroff', time_out=300, time_sleep=10) listener.write_for(machine_name, 'Saving the image') new_image_name = node_instance.get_image_short_name() + time.strftime("_%Y%m%d-%H%M%S") new_image_id = int(self._rpc_execute( 'one.vm.disksaveas', vm_id, 0, new_image_name, '', -1)) self._wait_image_in_state(new_image_id, 'Ready', time_out=1800, time_sleep=30) listener.write_for(machine_name, 'Image saved !') self._rpc_execute('one.vm.action', 'resume', vm_id) self._wait_vm_in_state(vm_id, 'Active', time_out=300, time_sleep=10) return str(new_image_id)
def _install_user_packages(self): util.printAndFlush('Installing packages') if self.is_image_built(): util.printAndFlush( 'Component already built. No packages to install') return packages = self.node_instance.get_packages() if packages: message = 'Installing packages: %s' % ', '.join(packages) fail_msg = "Failed installing packages on '%s'" % self._get_node_instance_name( ) util.printStep(message) self.wrapper.set_statecustom(message) cmd = util.get_packages_install_command( self.node_instance.get_platform(), packages) self._launch_script('#!/bin/sh -xe\n%s' % cmd, fail_msg=fail_msg, name='Install packages') else: util.printAndFlush('No packages to install')
def _executeTarget(self, target): util.printStep("Executing target '%s'" % target) if target in self.targets: tmpfilesuffix = '' if util.isWindows(): tmpfilesuffix = '.ps1' fn = tempfile.mktemp(suffix=tmpfilesuffix) if isinstance(self.targets[target][0], unicode): with codecs.open(fn, 'w', 'utf8') as fh: fh.write(self.targets[target][0]) else: with open(fn, 'w') as fh: fh.write(self.targets[target][0]) os.chmod(fn, 0755) currentDir = os.getcwd() os.chdir(tempfile.gettempdir() + os.sep) try: self._executeRaiseOnError(fn) finally: os.chdir(currentDir) else: print 'Nothing to do'
def _buildImageOnOpenStack(self, userInfo, imageInfo): self._thread_local.driver = self._getDriver(userInfo) vm = self.getVm(NodeDecorator.MACHINE_NAME) util.printAndFlush("\n imageInfo: %s \n" % str(imageInfo)) util.printAndFlush("\n VM: %s \n" % str(vm)) ipAddress = self.vmGetIp(vm) self._creatorVmId = self.vmGetId(vm) instance = vm['instance'] self._waitInstanceInRunningState(self._creatorVmId) self._buildImageIncrement(userInfo, imageInfo, ipAddress) attributes = self.getAttributes(imageInfo) util.printStep('Creation of the new Image.') newImg = self._thread_local.driver.ex_save_image(instance, attributes['shortName'], metadata=None) self._waitImageCreationCompleted(newImg.id) self._newImageId = newImg.id
def _buildImageIncrement(self, user_info, imageInfo, host): prerecipe, recipe, packages = self.extractAllTargets(imageInfo) try: username, password, sshPrivateKeyFile = \ self._getSshCredentials(imageInfo, user_info, NodeDecorator.MACHINE_NAME) if not self.hasCapability(self.CAPABILITY_CONTEXTUALIZATION) and not sshPrivateKeyFile: password = '' sshPrivateKeyFile, publicKey = self._getTempPrivateKeyFileNameAndPublicKey() self._waitCanConnectWithSshOrAbort(host, username=username, password=password, sshKey=sshPrivateKeyFile) if prerecipe: util.printStep('Running Pre-recipe') remoteRunScript(username, host, prerecipe, sshKey=sshPrivateKeyFile, password=password) if packages: util.printStep('Installing Packages') remoteInstallPackages(username, host, packages, self.getPlatform(imageInfo), sshKey=sshPrivateKeyFile, password=password) if recipe: util.printStep('Running Recipe') remoteRunScript(username, host, recipe, sshKey=sshPrivateKeyFile, password=password) if not self.hasCapability(self.CAPABILITY_CONTEXTUALIZATION): self._revertSshSecurity(host, username, sshPrivateKeyFile, publicKey) finally: try: os.unlink(sshPrivateKeyFile) except: pass
def _print_step(self, message, write_for=None): util.printStep(message) if write_for: self._get_listener().write_for(write_for, message)
def _printStep(self, message): util.printStep(message)
def _initialization(self, user_info, **kwargs): util.printStep('Initialize the Kubernetes connector.') self.user_info = user_info
def _update_slipstream_image(self, node_instance, new_image_id): util.printStep("Updating SlipStream image run") url = '%s/%s' % (node_instance.get_image_resource_uri(), self._get_cloud_service_name()) self._put_new_image_id(url, new_image_id)
def _add_ssh_pubkey(self, login_user): if not util.is_windows(): util.printStep('Adding the public keys') append_ssh_pubkey_to_authorized_keys(self._get_user_ssh_pubkey(), login_user)
def _addSshPubkey(self): util.printStep('Adding the public key') appendSshPubkeyToAuthorizedKeys(self._getUserSshPubkey())