def deploy_software(self):
JobDeploymentBase.deploy_software(self)
# Here we undertake transfer of the code to the remote platform if this
# is required. In many cases, the software is likely to already be
# deployed on the target platform or may have been configured via a
# tool such as cloud-init, puppet, etc at resource initialisation time.
LOG.debug('SSH Deployer: Deploy software...')
def deploy_software(self):
JobDeploymentBase.deploy_software(self)
def deploy_software(self, *args, **kwargs):
JobDeploymentBase.deploy_software(self)
def deploy_software(self, software_config=None):
JobDeploymentBase.deploy_software(self)
# Here we undertake transfer of the code to the remote platform if this
# is required. In many cases, the software is likely to already be
# deployed on the target platform or may have been configured via a
# tool such as cloud-init, puppet, etc at resource initialisation time.
LOG.debug('Deploy software...')
# If we're not using an unconfigured image, we don't need to run the
# deploy software function
if not self.use_unconfigured:
LOG.info('Using a pre-configured image so running software '
'deployment process...')
return
# Software deployment requires root access to the target node(s). This
# should be possible using the key that has been passed to start the
# reosurce(s).
# If no software configuration is provided, we ignore this function
# call and return. If a configuration is provided, we check that the
# configuration is for the right type of platform and then deploy
# the software.
if not software_config:
return
if type(software_config) != type([]):
software_config = [software_config]
LOG.debug('Received a request to deploy the following software '
'configuration IDs to the target platforms: <%s>...' %
software_config)
# Check that we have an admin security context available. If we don't
# we can't connect to the remote resource(s) to do the required
# configuration
if not self.admin_ctx:
raise JobError(
'deploy_software: There is no admin context '
'available so it will not be possible to connect '
'to remote resources to configure them. Ensure that '
'')
# Check that we can get each of the software configurations and that
# each one supports the target deployment platform.
scm = SoftwareConfigManager.get_instance()
scm.init_configuration()
os_name = self.platform_config.image_unconfigured_os
flavour = self.platform_config.image_unconfigured_flavour
admin_key_user = self.platform_config.image_unconfigured_admin_key_user
admin_key_file = self.platform_config.image_unconfigured_admin_key_file
sc_dict = {}
for sc in software_config:
try:
conf = scm.get_software_configuration(sc)
sc_dict[sc] = conf
except ValueError as e:
raise JobError('Job error - no software could be found for '
'the configuration id <%s>: %s' % (sc, str(e)))
if not ((os_name == conf.software_os_type) and
(flavour == conf.software_os_flavour)):
LOG.error(
'The OS <%s> and flavour <%s> in the provided software '
'configuration don\'t match the target platform with '
'OS <%s> and flavour <%s>.' %
(conf.software_os_type, conf.software_os_flavour, os_name,
flavour))
raise JobError(
'The OS <%s> and flavour <%s> in the provided '
'software configuration don\'t match the target '
'platform with OS <%s> and flavour <%s>.' %
(conf.software_os_type, conf.software_os_flavour, os_name,
flavour))
# If we reach this point we assume that each of the software
# configurations has been found and they are for the right target
# platform.
for sc_key in sc_dict.keys():
sc_obj = sc_dict[sc_key]
install_commands = sc_obj.get_install_commands()
# Now run each of the install commands synchronously on all of the
# target machines to get the software installed.
node_ips = [node[0].public_ips[0] for node in self.running_nodes]
LOG.debug('Deploying to the following list of nodes: %s' %
node_ips)
# Set up a new session using the admin user and key provided for
# the unconfigured image.
adm_session = saga.Session(default=False)
adm_ctx = saga.Context("ssh")
adm_ctx.user_id = admin_key_user
adm_ctx.user_key = admin_key_file
adm_session.add_context(adm_ctx)
# Open shell connections to each of the machines
shell_conns = []
opts = {}
opts['ssh_options'] = {'StrictHostKeyChecking': 'no'}
for node_ip in node_ips:
conn = PTYShell('ssh://%s' % node_ip,
session=adm_session,
opts=opts)
shell_conns.append(conn)
if conf.software_os_type == 'linux':
self._setup_job_account(conn, self.platform_config)
else:
LOG.warning(
'Support for creation of job accounts on '
'platforms other than linux is not yet supported...')
# Copy the job account key to the master node
job_session = saga.Session(default=False)
job_session.add_context(self.job_ctx)
keyfile = File('file://%s' % self.platform_config.user_key_file,
session=job_session)
keyfile_target = shell_conns[0].url + os.path.join(
self.platform_config.user_home, '.ssh', 'id_rsa')
LOG.debug('Copying job key to target directory <%s>' %
keyfile_target)
keyfile.copy(keyfile_target)
for cmd in install_commands:
for shell_connection in shell_conns:
if isinstance(cmd, SoftwareConfigFile):
LOG.debug(
'Software deployment: About to write data to '
'remote file <%s> on node <%s>' %
(cmd.filename, shell_connection.url))
shell_connection.write_to_remote(
cmd.data, cmd.filename)
else:
LOG.debug('Software deployment: About to run command '
'<%s> on resource <%s>...' %
(cmd, shell_connection.url))
if admin_key_user != 'root':
cmd = 'sudo ' + cmd
result, out, err = shell_connection.run_sync(cmd)
LOG.debug('Command completed - Exit code: <%s>, '
'StdOut: <%s>, StdErr:\n<%s>' %
(result, out, err))