def test_script_deployment_and_sshkey_deployment_argument_types(self):
class FileObject(object):
def __init__(self, name):
self.name = name
def read(self):
return 'bar'
ScriptDeployment(script='foobar')
ScriptDeployment(script=u('foobar'))
ScriptDeployment(script=FileObject('test'))
SSHKeyDeployment(key='foobar')
SSHKeyDeployment(key=u('foobar'))
SSHKeyDeployment(key=FileObject('test'))
try:
ScriptDeployment(script=[])
except TypeError:
pass
else:
self.fail('TypeError was not thrown')
try:
SSHKeyDeployment(key={})
except TypeError:
pass
else:
self.fail('TypeError was not thrown')
def test_script_deployment_and_sshkey_deployment_argument_types(self):
class FileObject(object):
def __init__(self, name):
self.name = name
def read(self):
return "bar"
ScriptDeployment(script="foobar")
ScriptDeployment(script=u("foobar"))
ScriptDeployment(script=FileObject("test"))
SSHKeyDeployment(key="foobar")
SSHKeyDeployment(key=u("foobar"))
SSHKeyDeployment(key=FileObject("test"))
try:
ScriptDeployment(script=[])
except TypeError:
pass
else:
self.fail("TypeError was not thrown")
try:
SSHKeyDeployment(key={})
except TypeError:
pass
else:
self.fail("TypeError was not thrown")
def test_script_deployment(self):
sd1 = ScriptDeployment(script="foobar", delete=True)
sd2 = ScriptDeployment(script="foobar", delete=False)
sd3 = ScriptDeployment(script="foobar",
delete=False,
name="foobarname")
sd4 = ScriptDeployment(script="foobar",
delete=False,
name="foobarname",
timeout=10)
self.assertTrue(sd1.name.find("deployment") != "1")
self.assertEqual(sd3.name, "foobarname")
self.assertEqual(sd3.timeout, None)
self.assertEqual(sd4.timeout, 10)
self.assertEqual(
self.node,
sd1.run(node=self.node, client=MockClient(hostname="localhost")))
self.assertEqual(
self.node,
sd2.run(node=self.node, client=MockClient(hostname="localhost")))
self.assertEqual(
self.node,
sd3.run(node=self.node, client=MockClient(hostname="localhost")))
assertRaisesRegex(
self,
ValueError,
"timeout",
sd4.run,
node=self.node,
client=MockClient(hostname="localhost", throw_on_timeout=True),
)
def test_script_deployment(self):
sd1 = ScriptDeployment(script='foobar', delete=True)
sd2 = ScriptDeployment(script='foobar', delete=False)
sd3 = ScriptDeployment(script='foobar',
delete=False,
name='foobarname')
sd4 = ScriptDeployment(script='foobar',
delete=False,
name='foobarname',
timeout=10)
self.assertTrue(sd1.name.find('deployment') != '1')
self.assertEqual(sd3.name, 'foobarname')
self.assertEqual(sd3.timeout, None)
self.assertEqual(sd4.timeout, 10)
self.assertEqual(
self.node,
sd1.run(node=self.node, client=MockClient(hostname='localhost')))
self.assertEqual(
self.node,
sd2.run(node=self.node, client=MockClient(hostname='localhost')))
self.assertEqual(
self.node,
sd3.run(node=self.node, client=MockClient(hostname='localhost')))
assertRaisesRegex(self,
ValueError,
'timeout',
sd4.run,
node=self.node,
client=MockClient(hostname='localhost',
throw_on_timeout=True))
def test_script_deployment_relative_path(self):
client = Mock()
client.put.return_value = "/home/ubuntu/relative.sh"
client.run.return_value = ("", "", 0)
sd = ScriptDeployment(script='echo "foo"', name="relative.sh")
sd.run(self.node, client)
client.run.assert_called_once_with("/home/ubuntu/relative.sh")
def test_script_deployment_relative_path(self):
client = Mock()
client.put.return_value = FILE_PATH
client.run.return_value = ('', '', 0)
sd = ScriptDeployment(script='echo "foo"', name='relative.sh')
sd.run(self.node, client)
client.run.assert_called_once_with(FILE_PATH)
def test_script_deployment_absolute_path(self):
client = Mock()
client.put.return_value = '/home/ubuntu/relative.sh'
client.run.return_value = ('', '', 0)
sd = ScriptDeployment(script='echo "foo"', name='/root/relative.sh')
sd.run(self.node, client)
client.run.assert_called_once_with('/root/relative.sh')
def test_script_deployment_absolute_path(self):
client = Mock()
client.put.return_value = '/home/ubuntu/relative.sh'
client.run.return_value = ('', '', 0)
sd = ScriptDeployment(script='echo "foo"', name='/root/relative.sh')
sd.run(self.node, client)
client.run.assert_called_once_with('/root/relative.sh')
def test_script_deployment(self):
sd1 = ScriptDeployment(script="foobar", delete=True)
sd2 = ScriptDeployment(script="foobar", delete=False)
sd3 = ScriptDeployment(script="foobar", delete=False, name="foobarname")
self.assertTrue(sd1.name.find("deployment") != "1")
self.assertEqual(sd3.name, "foobarname")
self.assertEqual(self.node, sd1.run(node=self.node, client=MockClient(hostname="localhost")))
self.assertEqual(self.node, sd2.run(node=self.node, client=MockClient(hostname="localhost")))
def test_script_deployment_absolute_path(self):
file_path = "{0}root{0}relative.sh".format(os.path.sep)
client = Mock()
client.put.return_value = file_path
client.run.return_value = ("", "", 0)
sd = ScriptDeployment(script='echo "foo"', name=file_path)
sd.run(self.node, client)
client.run.assert_called_once_with(file_path, timeout=None)
def test_script_deployment_absolute_path(self):
client = Mock()
client.put.return_value = FILE_PATH
client.run.return_value = ('', '', 0)
file_path = '{0}root{0}relative.sh'.format(os.path.sep)
sd = ScriptDeployment(script='echo "foo"', name=file_path)
sd.run(self.node, client)
client.run.assert_called_once_with(file_path)
def test_script_deployment(self):
sd1 = ScriptDeployment(script='foobar', delete=True)
sd2 = ScriptDeployment(script='foobar', delete=False)
sd3 = ScriptDeployment(script='foobar', delete=False, name='foobarname')
self.assertTrue(sd1.name.find('deployment') != '1')
self.assertEqual(sd3.name, 'foobarname')
self.assertEqual(self.node, sd1.run(node=self.node,
client=MockClient(hostname='localhost')))
self.assertEqual(self.node, sd2.run(node=self.node,
client=MockClient(hostname='localhost')))
def create_node(self):
Ovh = get_driver('ovh')
#driver = Ovh('aeNU3zwooBfui4hV','60XdgjYPnKDNgRHxpgVVgLB8DvQYK9g0','9521feabdf2241bda7b22a8b37197dec','8E0DJcWjpzQ45umYmZ28kb0FAl759MdP')
driver = Ovh('xUEdjyPkmNCJyRhl', 'YNexUap0BWHo0aWk5G3N8rA8QqMPocVy',
'407fc2f957624f9f8374cfb70b8fcfc9',
'JpSb8OESQDkifwmnC2rWJPtX85XKE2eH')
node = driver.ex_get_node('cccfddd1-59e5-4729-a29c-b919f02d04cc')
ip_address = node.public_ips
SCRIPT = '''#!/usr/bin/env bash
apt-get -y update && apt-get -y install curl
'''
step = ScriptDeployment(SCRIPT)
msd = MultiStepDeployment([step])
logger.info('+vimage %s ' % (driver))
SSH_CONNECT_TIMEOUT = 1 * 60
ssh_timeout = 10
timeout = SSH_CONNECT_TIMEOUT
max_tries = 3
ssh_client = SSHClient(hostname=ip_address[0],
port=22,
username='******',
password='',
key_files='/var/lib/odoo/.ssh/id_rsa',
timeout=ssh_timeout)
logger.info(ssh_client)
ssh_client.connect()
logger.info(ssh_client)
def check_process(proc_name):
return ScriptDeployment("if ps aux | grep '%s' > /dev/null; "
"then echo '1:%s is running'; "
"else echo '0:%s is NOT running'; "
"fi" % (proc_name, proc_name, proc_name),
name="./deploy_check_process_%s.sh" %
(proc_name, ))
def deployment_script(self):
haproxy_config = self.prepare_haproxy_config(self.config["haproxy"], self.nodes)
# Insert the haproxy.cfg file into the deployment script.
haproxy_deploy = open(self.config["haproxy_deploy"], "r").read()
script = haproxy_deploy % ({"config" : haproxy_config})
deployment = ScriptDeployment(script.encode("utf8"))
return deployment
def deploy_instance(self, *args, **kwargs):
"""
Deploy an AWS node.
"""
username = self.identity.user.username
atmo_init = "/usr/sbin/atmo_init_full.py"
server_atmo_init = "/init_files/30/atmo_init_full.py"
script_deps = ScriptDeployment(
"sudo apt-get install -y emacs vim wget")
script_wget = ScriptDeployment(
"sudo wget -O %s %s%s" %
(atmo_init, settings.SERVER_URL, server_atmo_init))
script_chmod = ScriptDeployment("sudo chmod a+x %s" % atmo_init)
instance_token = kwargs.get('token', '')
awesome_atmo_call = "sudo %s --service_type=%s --service_url=%s"
awesome_atmo_call += " --server=%s --user_id=%s --token=%s"
awesome_atmo_call += " --name=%s &> %s"
awesome_atmo_call %= (atmo_init, "instance_service_v1",
settings.INSTANCE_SERVICE_URL,
settings.SERVER_URL, username, instance_token,
kwargs.get('name',
''), '/var/log/atmo_init_full.err')
logger.debug(awesome_atmo_call)
str_awesome_atmo_call = str(awesome_atmo_call)
#kludge: weirdness without the str cast...
script_atmo_init = ScriptDeployment(str_awesome_atmo_call)
private_key = ("/opt/dev/atmosphere/extras/ssh/id_rsa")
scripts = [script_deps, script_wget, script_chmod, script_atmo_init]
for s in scripts:
logger.debug(s.name)
s.name = s.name.replace('/root', '/home/ubuntu')
logger.debug(s.name)
msd = MultiStepDeployment(scripts)
kwargs.update({'ex_keyname': 'dalloway-key'})
kwargs.update({'ssh_username': '******'})
kwargs.update({'ssh_key': private_key})
kwargs.update({'deploy': msd})
kwargs.update({'timeout': 400})
instance = super(AWSDriver, self).deploy_instance(*args, **kwargs)
created = datetime.strptime(instance.extra['created'],
"%Y-%m-%dT%H:%M:%SZ")
# NOTE: Removed for rtwo port. Moved to service tasks.
# send_instance_email(username, instance.id, instance.ip,
# created, username)
return instance
def umount_volume(mount_location):
return ScriptDeployment(
"mounts=`mount | grep '%s' | cut -d' ' -f3`; "
"for mount in $mounts; do umount %s; done;"
"/bin/sed -i \"/vd[c-z]/d\" /etc/fstab;" # should work for most
"/bin/sed -i \"/vol_[b-z]/d\" /etc/fstab;" # should catch any lingerers
% (mount_location, mount_location),
name="./deploy_umount_volume.sh")
def mount_volume(device, mount_location, username=None, group=None):
mount_script = "mkdir -p %s; " % (mount_location, )
mount_script += "mount %s %s; " % (device, mount_location)
if username and group:
mount_script += "chown -R %s:%s %s" % (username, group, mount_location)
# NOTE: Fails to recognize mount_script as a str
# Removing this line will cause 'celery' to fail
# to execute this particular ScriptDeployment
return ScriptDeployment(str(mount_script), name="./deploy_mount_volume.sh")
def init_log():
return ScriptDeployment(
'if [ ! -d "/var/log/atmo" ];then\n'
'mkdir -p /var/log/atmo\n'
'fi\n'
'if [ ! -f "/var/log/atmo/deploy.log" ]; then\n'
'touch /var/log/atmo/deploy.log\n'
'fi',
name="./deploy_init_log.sh")
def script(vm_):
'''
Return the script deployment object
'''
return ScriptDeployment(
salt.utils.cloud.os_script(
config.get_cloud_config_value('os', vm_, __opts__), vm_, __opts__,
salt.utils.cloud.salt_config_to_yaml(
salt.utils.cloud.minion_config(__opts__, vm_))))
def deploy_service(self, fournisseur, host, service):
scripts = service.template_id.script
hostid = self.env['bibind.host'].browse(host.id)
bibindnode = host.nodeid
driver = self.run_driver()
_logger.info('+vscript host %s ' %(driver) )
name = service.type+'-'+service.partner_id.name+'-'+service.id
stack = driver.ex_deploy_stack( name,
description=None, docker_compose=None,
environment=None, external_id=None,
rancher_compose=None, start=True)
node = driver.ex_get_node(str(bibindnode.idnode))
ip_address = node.public_ips
_logger.info('+vscript host %s ' %(node) )
_logger.info('+vscript ip_address %s ' %(ip_address) )
_logger.info('+vscript ip_address[0] %s ' %(ip_address[0]) )
step=[]
# Shell script to run on the remote server
for script in host.deploy_scripts_ids:
_logger.info('+vscript host %s ' %(script) )
myscript = self.env['launch.script'].browse(script.id)
_logger.info('+vscript host %s ' %(myscript.script_code) )
step.append( ScriptDeployment(str(myscript.script_code)))
_logger.info('+vscript host %s ' %(step) )
msd = MultiStepDeployment(step)
_logger.info('+vimage %s ' %(driver) )
SSH_CONNECT_TIMEOUT = 1 * 60
ssh_timeout = 10
timeout = SSH_CONNECT_TIMEOUT
max_tries = 3
params ={}
params['deploy'] =msd
params['ssh_username'] ='******'
params['ssh_key']='/var/lib/odoo/.ssh/id_rsa'
# deploy_node takes the same base keyword arguments as create_node.
node = driver._connect_and_run_deployment_script(
task=msd, node=node,
ssh_hostname=ip_address[0], ssh_port=22,
ssh_username='******', ssh_password='',
ssh_key_file='/var/lib/odoo/.ssh/id_rsa', ssh_timeout=ssh_timeout,
timeout=timeout, max_tries=max_tries)
return bibindnode
def script(vm_):
'''
Return the script deployment object
'''
minion = saltcloud.utils.minion_conf_string(__opts__, vm_)
return ScriptDeployment(
saltcloud.utils.os_script(
saltcloud.utils.get_option('os', __opts__, vm_),
vm_,
__opts__,
minion,
))
def script(vm_):
"""
Return the script deployment object
"""
return ScriptDeployment(
salt.utils.cloud.os_script(
salt.config.get_cloud_config_value("os", vm_, __opts__),
vm_,
__opts__,
salt.utils.cloud.salt_config_to_yaml(
salt.utils.cloud.minion_config(__opts__, vm_)),
))
def test_script_deployment(self):
sd1 = ScriptDeployment(script='foobar', delete=True)
sd2 = ScriptDeployment(script='foobar', delete=False)
sd3 = ScriptDeployment(script='foobar', delete=False, name='foobarname')
self.assertTrue(sd1.name.find('deployment') != '1')
self.assertEqual(sd3.name, 'foobarname')
self.assertEqual(self.node, sd1.run(node=self.node,
client=MockClient(hostname='localhost')))
self.assertEqual(self.node, sd2.run(node=self.node,
client=MockClient(hostname='localhost')))
def deploy_node(self, **kwargs):
"""
Create a new node, and start deployment.
@keyword enable_root: If true, root password will be set to
vnc_password (this will enable SSH access)
and default 'toor' account will be deleted.
@type enable_root: C{bool}
For detailed description and keywords args, see
L{NodeDriver.deploy_node}.
"""
image = kwargs['image']
vnc_password = kwargs.get('vnc_password', None)
enable_root = kwargs.get('enable_root', False)
if not vnc_password:
raise ValueError('You need to provide vnc_password argument '
'if you want to use deployment')
if (image in self._standard_drives
and not self._standard_drives[image]['supports_deployment']):
raise ValueError('Image %s does not support deployment'
% (image.id))
if enable_root:
script = ("unset HISTFILE;"
"echo root:%s | chpasswd;"
"sed -i '/^toor.*$/d' /etc/passwd /etc/shadow;"
"history -c") % vnc_password
root_enable_script = ScriptDeployment(script=script,
delete=True)
deploy = kwargs.get('deploy', None)
if deploy:
if (isinstance(deploy, ScriptDeployment)
or isinstance(deploy, SSHKeyDeployment)):
deployment = MultiStepDeployment([deploy,
root_enable_script])
elif isinstance(deploy, MultiStepDeployment):
deployment = deploy
deployment.add(root_enable_script)
else:
deployment = root_enable_script
kwargs['deploy'] = deployment
if not kwargs.get('ssh_username', None):
kwargs['ssh_username'] = '******'
return super(ElasticStackBaseNodeDriver, self).deploy_node(**kwargs)
def wrap_script(script_text, script_name):
"""
NOTE: In current implementation, the script can only be executed, and not
logged.
Implementation v2:
* Write to file
* Chmod the file
* Execute and redirect output to stdout/stderr to logfile.
"""
# logfile = "/var/log/atmo/post_boot_scripts.log"
# kludge: weirdness without the str cast...
script_text = str(script_text)
full_script_name = "./deploy_boot_script_%s.sh" % (slugify(script_name), )
return ScriptDeployment(script_text, name=full_script_name)
def deploy_config_depot_script(self, host, service, env, param):
SCRIPT = '''#!/usr/bin/env bash
cd /home && sudo mkdir apt-get -y update && apt-get -y install puppet
'''
hostid = self.env['bibind.host'].browse(host.id)
bibindnode = host.nodeid
driver = self.run_driver()
_logger.info('+vscript host %s ' %(driver) )
node = driver.ex_get_node(str(bibindnode.idnode))
ip_address = node.public_ips
_logger.info('+vscript node %s ' %(node) )
_logger.info('+vscript ip_address %s ' %(ip_address) )
_logger.info('+vscript ip_address[0] %s ' %(ip_address[0]) )
step=[]
step.append( ScriptDeployment(str(script.script_code)))
msd = MultiStepDeployment(step)
_logger.info('+driver %s ' %(step) )
_logger.info('+vscript ip_address[0] %s ' %(msd) )
SSH_CONNECT_TIMEOUT = 1 * 60
ssh_timeout = 10
timeout = SSH_CONNECT_TIMEOUT
max_tries = 3
params ={}
params['deploy'] =msd
params['ssh_username'] ='******'
params['ssh_key']='/var/lib/odoo/.ssh/id_rsa'
# deploy_node takes the same base keyword arguments as create_node.
node = driver._connect_and_run_deployment_script(
task=msd, node=node,
ssh_hostname=ip_address[0], ssh_port=22,
ssh_username='******', ssh_password='',
ssh_key_file='/var/lib/odoo/.ssh/id_rsa', ssh_timeout=ssh_timeout,
timeout=timeout, max_tries=max_tries)
return node
def deploy_host(self, fournisseur, host):
name = host.name
bibind_image = host.image
bibind_size = host.size
bibind_location = host.location
_logger.info('+ idimage %s ' %(bibind_image.id_image) )
_logger.info('+ size %s ' %(bibind_size) )
_logger.info('+v location extr %s ' %(bibind_location) )
driver = self.run_bibind_driver()
img = driver.get_image(bibind_image.id_image)
_logger.info('+ idimage gggg%s ' %(img) )
location = [l for l in driver.list_locations() if l.id == bibind_location.id_location][0]
image = [i for i in driver.list_images() if bibind_image.id_image == i.id][0]
size = [s for s in driver.list_sizes() if s.id == bibind_size.id_size][0]
step = []
# Shell script to run on the remote server
for script in host.deploy_scripts_ids:
_logger.info('+vscript host %s ' %(script) )
myscript = self.env['launch.script'].browse(script.id)
_logger.info('+vscript host %s ' %(myscript.script_code) )
step.append(ScriptDeployment(str(myscript.script_code)))
_logger.info('+vscript host %s ' %(step) )
msd = MultiStepDeployment(step)
_logger.info('+vimage %s ' %(driver) )
params ={}
params['deploy'] =msd
params['ssh_username'] ='******'
params['ssh_key']='/var/lib/odoo/.ssh/id_rsa'
# deploy_node takes the same base keyword arguments as create_node.
node = driver.deploy_node(name=name, image=image, size=size,location=location,ex_keyname='bibind',**params )
_logger.info('+node %s ' %(node) )
nodemodel = self.env['cloud.service.node']
val = self.converti_nodelibcloud_to_nodebibind(node, size)
bibindnode = nodemodel.create(val)
return bibindnode
def deploy_node(self, **kwargs):
"""
Create a new node, and start deployment.
@inherits: :class:`NodeDriver.deploy_node`
:keyword enable_root: If true, root password will be set to
vnc_password (this will enable SSH access)
and default 'toor' account will be deleted.
:type enable_root: ``bool``
"""
image = kwargs["image"]
vnc_password = kwargs.get("vnc_password", None)
enable_root = kwargs.get("enable_root", False)
if not vnc_password:
raise ValueError("You need to provide vnc_password argument "
"if you want to use deployment")
if (image in self._standard_drives
and not self._standard_drives[image]["supports_deployment"]):
raise ValueError("Image %s does not support deployment" %
(image.id))
if enable_root:
script = ("unset HISTFILE;"
"echo root:%s | chpasswd;"
"sed -i '/^toor.*$/d' /etc/passwd /etc/shadow;"
"history -c") % vnc_password
root_enable_script = ScriptDeployment(script=script, delete=True)
deploy = kwargs.get("deploy", None)
if deploy:
if isinstance(deploy, ScriptDeployment) or isinstance(
deploy, SSHKeyDeployment):
deployment = MultiStepDeployment(
[deploy, root_enable_script])
elif isinstance(deploy, MultiStepDeployment):
deployment = deploy
deployment.add(root_enable_script)
else:
deployment = root_enable_script
kwargs["deploy"] = deployment
if not kwargs.get("ssh_username", None):
kwargs["ssh_username"] = "******"
return super(ElasticStackBaseNodeDriver, self).deploy_node(**kwargs)
def _install_key(self, server, key_data):
"""Installs key on server."""
server.driver._connect_and_run_deployment_script(
task=ScriptDeployment('echo "%s %s" >> ~/.ssh/authorized_keys' %
(key_data['key'], key_data['id'])),
node=server,
ssh_hostname=server.public_ips[0],
ssh_port=22,
ssh_username=self.server_ssh_user,
ssh_password=self._get_password(server),
ssh_key_file=None,
ssh_timeout=10,
timeout=300,
max_tries=3)
return True
def deploy(self, image_id, size_idx=0, location_idx=0, name='test'):
"""Linode supports libcloud's `libcloud.compute.deployment`.
Pass an `SSHKeyDeployment` to `self.driver.deploy_node`."""
sd = SSHKeyDeployment(open(self.ssh_public_key).read())
script = ScriptDeployment("/bin/true") # NOP
msd = MultiStepDeployment([sd, script])
class Image:
id = image_id
size = self.driver.list_sizes()[size_idx]
location = self.driver.list_locations()[location_idx]
return node2dict(
self.driver.deploy_node(name=name,
image=Image,
size=size,
location=location,
deploy=msd))
def test_script_deployment_with_arguments(self):
client = Mock()
client.put.return_value = FILE_PATH
client.run.return_value = ('', '', 0)
file_path = '{0}root{0}relative.sh'.format(os.path.sep)
args = ['arg1', 'arg2', '--option1=test']
sd = ScriptDeployment(script='echo "foo"', args=args, name=file_path)
sd.run(self.node, client)
expected = '%s arg1 arg2 --option1=test' % (file_path)
client.run.assert_called_once_with(expected)
client.reset_mock()
args = []
sd = ScriptDeployment(script='echo "foo"', args=args, name=file_path)
sd.run(self.node, client)
expected = file_path
client.run.assert_called_once_with(expected)
def test_script_deployment_with_arguments(self):
client = Mock()
client.put.return_value = '/home/ubuntu/relative.sh'
client.run.return_value = ('', '', 0)
args = ['arg1', 'arg2', '--option1=test']
sd = ScriptDeployment(script='echo "foo"', args=args,
name='/root/relative.sh')
sd.run(self.node, client)
expected = '/root/relative.sh arg1 arg2 --option1=test'
client.run.assert_called_once_with(expected)
client.reset_mock()
args = []
sd = ScriptDeployment(script='echo "foo"', args=args,
name='/root/relative.sh')
sd.run(self.node, client)
expected = '/root/relative.sh'
client.run.assert_called_once_with(expected)
def deploy_node(driver, networks=None, script=None):
script = script or """#!/bin/sh
echo "Hello from $(hostname)"
"""
script = ScriptDeployment(script)
name = uuid.uuid4().hex
node = driver.deploy_node(name=name,
image=driver.get_image("hashicorp/precise64"),
size=driver.list_sizes()[0],
ex_networks=networks,
deploy=script)
try:
assert node.name == name
assert script.exit_status == 0, script.stderr
expected = "Hello from %s" % (node.name,)
assert (expected in script.stdout), script.stdout
yield script.stdout
finally:
driver.destroy_node(node)
def test_script_deployment_with_arguments(self):
client = Mock()
client.put.return_value = "/home/ubuntu/relative.sh"
client.run.return_value = ("", "", 0)
args = ["arg1", "arg2", "--option1=test"]
sd = ScriptDeployment(script='echo "foo"', args=args, name="/root/relative.sh")
sd.run(self.node, client)
expected = "/root/relative.sh arg1 arg2 --option1=test"
client.run.assert_called_once_with(expected)
client.reset_mock()
args = []
sd = ScriptDeployment(script='echo "foo"', args=args, name="/root/relative.sh")
sd.run(self.node, client)
expected = "/root/relative.sh"
client.run.assert_called_once_with(expected)
def test_script_deployment_with_arguments(self):
client = Mock()
client.put.return_value = '/home/ubuntu/relative.sh'
client.run.return_value = ('', '', 0)
args = ['arg1', 'arg2', '--option1=test']
sd = ScriptDeployment(script='echo "foo"', args=args,
name='/root/relative.sh')
sd.run(self.node, client)
expected = '/root/relative.sh arg1 arg2 --option1=test'
client.run.assert_called_once_with(expected)
client.reset_mock()
args = []
sd = ScriptDeployment(script='echo "foo"', args=args,
name='/root/relative.sh')
sd.run(self.node, client)
expected = '/root/relative.sh'
client.run.assert_called_once_with(expected)
