def create(self, name=None, **kwargs):
"""
return: aws instance object
instance is booting so don't forget to cotton.fabextras.wait_for_shell()
"""
zone_config = get_provider_zone_config()
result = self.filter(name=name)
if result:
abort(red("VM name already in use"))
run_instances_args = dict()
run_instances_args['image_id'] = zone_config['image_id']
run_instances_args['key_name'] = zone_config['provisioning_ssh_key_name']
run_instances_args['instance_type'] = zone_config['instance_type']
if 'security_groups' in zone_config:
run_instances_args['security_groups'] = zone_config['security_groups']
reservation = self.connection.run_instances(**run_instances_args)
instance = reservation.instances[0]
instance.add_tag("Name", name)
instance.add_tag("creator", getpass.getuser())
print("Waiting for instance to run",)
while instance.state != 'running':
instance.update()
sys.stdout.write(".")
sys.stdout.flush()
time.sleep(1)
print(" OK")
return instance
def create(name=None):
from cotton.fabextras import wait_for_shell
zone_config = get_provider_zone_config()
vm_spec = zone_config.get('vm-defaults', {})
vm_spec['name'] = name
try:
vm_spec['tags']
except KeyError:
vm_spec['tags'] = {}
if 'environment' in env:
vm_spec['tags']['env'] = env.environment
if 'project' in env:
vm_spec['tags']['project'] = env.project
try:
vm = env.provider.create(**vm_spec)
except ValueError as e:
abort(red(e))
configure_fabric_for_host(
name) # TODO: we used to pass server object, check impact
wait_for_shell()
return vm
def _find_node_size(cls, node_size):
zone_config = get_provider_zone_config()
for name, size in sorted(zone_config['sizes'].items(),
key=lambda t: t[1]):
if node_size.ram <= size['memory'] and node_size.cpus <= size[
'cpu']:
return name
return 'xx-large-unknown'
def configure_fabric_for_host(name):
"""
loads provider and configures current host based on name
if zone_config['gateway'] than it will be configured
if zone_config['ssh_key'] is supplied then we use it
if we are in provisioning mode than zone_config['provisioning_ssh_key'] & zone_config['provisioning_user'] & zone_config['provisioning_password'] is used
updated variables:
env.provider
env.vm
env.vm_name
env.host_string
env.host
env.key_filename
env.user if in provisioning mode
"""
get_provider_connection()
vms = env.provider.filter(name=name)
if not vms:
abort(red("VM name='{}' not found".format(name)))
# will pick first vm from list in case more are available
env.vm = vms[0]
env.vm_name = name
get_provider_connection()
env.host_string = env.provider.host_string(env.vm)
zone_config = get_provider_zone_config()
if env.provisioning:
if 'provisioning_user' in zone_config:
env.user = zone_config['provisioning_user']
else:
print(yellow("No 'provisioning_user' defined in zone config"))
if 'provisioning_ssh_key' in zone_config:
env.key_filename = zone_config['provisioning_ssh_key']
else:
print(yellow("No 'provisioning_ssh_key' defined in zone config"))
print(yellow("Falling back to 'provisioning_password'"))
if 'provisioning_password' in zone_config:
env.password = zone_config['provisioning_password']
else:
print(
yellow(
"No 'provisioning_password' defined in zone config"))
else:
if 'ssh_key' in zone_config:
env.key_filename = zone_config['ssh_key']
if 'gateway' in zone_config:
if 'gateway_user' in env and env.gateway_user:
env.gateway = '{}@{}'.format(env.gateway_user,
zone_config['gateway'])
else:
env.gateway = '{}@{}'.format(env.user, zone_config['gateway'])
def create(self, name=None, **kwargs):
"""
return: aws instance object
instance is booting so don't forget to cotton.fabextras.wait_for_shell()
"""
zone_config = get_provider_zone_config()
result = self.filter(name=name)
if result:
raise ValueError("VM name already in use")
run_instances_args = dict()
run_instances_args['image_id'] = zone_config['image_id']
run_instances_args['key_name'] = zone_config['provisioning_ssh_key_name']
run_instances_args['instance_type'] = zone_config['instance_type']
if 'subnet_id' in zone_config:
print("Found subnet_id - creating instance within VPC")
run_instances_args['subnet_id'] = zone_config['subnet_id']
if 'security_groups' in zone_config:
raise ValueError("VPC does not accept security_groups - use security_groups_ids instead")
if 'security_groups_ids' in zone_config:
run_instances_args['security_group_ids'] = zone_config['security_groups_ids']
else:
if 'security_groups_ids' in zone_config:
raise ValueError("Non VPC does not accept security_group_ids - use security_groups instead")
if 'security_groups' in zone_config:
run_instances_args['security_groups'] = zone_config['security_groups']
if 'root_ebs_size' in zone_config or 'root_ebs_type' in zone_config:
dev_sda1 = boto.ec2.blockdevicemapping.EBSBlockDeviceType(delete_on_termination=True)
if 'root_ebs_size' in zone_config:
dev_sda1.size = zone_config['root_ebs_size'] # size in Gigabytes
if 'root_ebs_type' in zone_config:
dev_sda1.volume_type = zone_config['root_ebs_type']
bdm = boto.ec2.blockdevicemapping.BlockDeviceMapping()
bdm['/dev/sda1'] = dev_sda1
run_instances_args['block_device_map'] = bdm
reservation = self.connection.run_instances(**run_instances_args)
instance = reservation.instances[0]
instance.add_tag("Name", name)
instance.add_tag("creator", getpass.getuser())
if 'tags' in kwargs:
for key in kwargs['tags']:
instance.add_tag(key, kwargs['tags'][key])
print("Waiting for instance to run",)
while instance.state != 'running':
instance.update()
sys.stdout.write(".")
sys.stdout.flush()
time.sleep(1)
print(" OK")
return instance
def create(name=None):
from cotton.fabextras import wait_for_shell
zone_config = get_provider_zone_config()
vm_spec = zone_config.get('vm-defaults', {})
vm_spec['name'] = name
vm = env.provider.create(**vm_spec)
configure_fabric_for_host(name) # TODO: we used to pass server object, check impact
wait_for_shell()
def _filter_to_vdc(cls, vapps):
zone_config = get_provider_zone_config()
if zone_config.get('vdc-filter', False):
filtered = []
for vapp in vapps:
if vapp.extra['vdc'] == zone_config['vm-defaults']['vdc']:
filtered.append(vapp)
return filtered
else:
return vapps
def _filter_to_vdc(cls, vapps):
zone_config = get_provider_zone_config()
if zone_config.get('vdc-filter', False):
filtered = []
for vapp in vapps:
if vapp.extra['vdc'] == zone_config['vm-defaults']['vdc']:
filtered.append(vapp)
return filtered
else:
return vapps
def configure_fabric_for_host(name):
"""
loads provider and configures current host based on name
if zone_config['gateway'] than it will be configured
if zone_config['ssh_key'] is supplied then we use it
if we are in provisioning mode than zone_config['provisioning_ssh_key'] & zone_config['provisioning_user'] & zone_config['provisioning_password'] is used
updated variables:
env.provider
env.vm
env.vm_name
env.host_string
env.host
env.key_filename
env.user if in provisioning mode
"""
get_provider_connection()
vms = env.provider.filter(name=name)
if not vms:
abort(red("VM name='{}' not found".format(name)))
# will pick first vm from list in case more are available
env.vm = vms[0]
env.vm_name = name
get_provider_connection()
env.host_string = env.provider.host_string(env.vm)
zone_config = get_provider_zone_config()
if env.provisioning:
if 'provisioning_user' in zone_config:
env.user = zone_config['provisioning_user']
else:
print(yellow("No 'provisioning_user' defined in zone config"))
if 'provisioning_ssh_key' in zone_config:
env.key_filename = zone_config['provisioning_ssh_key']
else:
print(yellow("No 'provisioning_ssh_key' defined in zone config"))
print(yellow("Falling back to 'provisioning_password'"))
if 'provisioning_password' in zone_config:
env.password = zone_config['provisioning_password']
else:
print(yellow("No 'provisioning_password' defined in zone config"))
else:
if 'ssh_key' in zone_config:
env.key_filename = zone_config['ssh_key']
if 'gateway' in zone_config:
if 'gateway_user' in env and env.gateway_user:
env.gateway = '{}@{}'.format(env.gateway_user, zone_config['gateway'])
else:
env.gateway = '{}@{}'.format(env.user, zone_config['gateway'])
def create(name=None):
from cotton.fabextras import wait_for_shell
zone_config = get_provider_zone_config()
vm_spec = zone_config.get('vm-defaults', {})
vm_spec['name'] = name
vm = env.provider.create(**vm_spec)
configure_fabric_for_host(
name) # TODO: we used to pass server object, check impact
wait_for_shell()
def get_provider_connection():
"""
returns initialized provider object and caches it in env.provider
"""
zone_config = get_provider_zone_config()
if 'verbose' in env and env.verbose:
print("Selected provider zone config:")
print(zone_config)
if not 'provider' in env or not env.provider:
p_class = provider_class(zone_config['driver'])
env.provider = p_class(**zone_config)
return env.provider
def get_provider_connection():
"""
returns initialized provider object and caches it in env.provider
"""
zone_config = get_provider_zone_config()
if 'verbose' in env and env.verbose:
print("Selected provider zone config:")
print(zone_config)
if 'provider' not in env or not env.provider:
p_class = provider_class(zone_config['driver'])
env.provider = p_class(**zone_config)
return env.provider
def create(self, name=None, **kwargs):
"""
return: aws instance object
instance is booting so don't forget to cotton.fabextras.wait_for_shell()
"""
zone_config = get_provider_zone_config()
result = self.filter(name=name)
if result:
abort(red("VM name already in use"))
size = {}
fields = ['size_id', 'size_slug']
for field in fields:
if field in zone_config:
size[field] = zone_config[field]
image = {}
fields = ['image_id', 'image_slug']
for field in fields:
if field in zone_config:
image[field] = zone_config[field]
region = {}
fields = ['region_id', 'region_slug']
for field in fields:
if field in zone_config:
region[field] = zone_config[field]
droplet = self.connection.create_droplet(
name=name,
size=size,
image=image,
region=region,
backups_enabled=zone_config['backups_enabled'],
private_networking=zone_config['private_networking'],
ssh_key_ids=map(lambda x: str(x), zone_config['ssh_key_ids'])
)
print("Waiting for instance to run",)
while droplet.ip_address is None or droplet.status != 'active':
sys.stdout.write(".")
sys.stdout.flush()
time.sleep(1)
droplet = self.connection.show_droplet(droplet.droplet_id)
print(" OK")
return droplet
def filter(self, **kwargs):
"""
return: list of objects matching filter args
typically provide should support filter 'name'='foo'
"""
instances = []
if 'name' in kwargs:
name = kwargs['name']
zone_config = get_provider_zone_config()
assert zone_config['driver'] == 'static'
for host_spec in zone_config['hosts']:
if host_spec['name'] == name:
print("selected static instance: {}".format(host_spec['name']))
instances.append(host_spec)
break
else:
print(yellow("Warning: {} not found!".format(name), bold=True))
else:
raise NotImplementedError()
return instances
def create(name=None):
from cotton.fabextras import wait_for_shell
zone_config = get_provider_zone_config()
vm_spec = zone_config.get('vm-defaults', {})
vm_spec['name'] = name
try:
vm_spec['tags']
except KeyError:
vm_spec['tags'] = {}
if 'environment' in env:
vm_spec['tags']['env'] = env.environment
if 'project' in env:
vm_spec['tags']['project'] = env.project
try:
vm = env.provider.create(**vm_spec)
except ValueError as e:
abort(red(e))
configure_fabric_for_host(name) # TODO: we used to pass server object, check impact
wait_for_shell()
return vm
def status(self):
zone_config = get_provider_zone_config()
return zone_config['hosts']
def create(self, name=None, **kwargs):
"""
return: aws instance object
instance is booting so don't forget to cotton.fabextras.wait_for_shell()
"""
zone_config = get_provider_zone_config()
result = self.filter(name=name)
if result:
raise ValueError("VM name already in use")
run_instances_args = dict()
run_instances_args['image_id'] = zone_config['image_id']
run_instances_args['key_name'] = zone_config[
'provisioning_ssh_key_name']
run_instances_args['instance_type'] = zone_config['instance_type']
if 'subnet_id' in zone_config:
print("Found subnet_id - creating instance within VPC")
run_instances_args['subnet_id'] = zone_config['subnet_id']
if 'security_groups' in zone_config:
raise ValueError(
"VPC does not accept security_groups - use security_groups_ids instead"
)
if 'security_groups_ids' in zone_config:
run_instances_args['security_group_ids'] = zone_config[
'security_groups_ids']
else:
if 'security_groups_ids' in zone_config:
raise ValueError(
"Non VPC does not accept security_group_ids - use security_groups instead"
)
if 'security_groups' in zone_config:
run_instances_args['security_groups'] = zone_config[
'security_groups']
if 'root_ebs_size' in zone_config or 'root_ebs_type' in zone_config:
dev_sda1 = boto.ec2.blockdevicemapping.EBSBlockDeviceType(
delete_on_termination=True)
if 'root_ebs_size' in zone_config:
dev_sda1.size = zone_config[
'root_ebs_size'] # size in Gigabytes
if 'root_ebs_type' in zone_config:
dev_sda1.volume_type = zone_config['root_ebs_type']
bdm = boto.ec2.blockdevicemapping.BlockDeviceMapping()
bdm['/dev/sda1'] = dev_sda1
run_instances_args['block_device_map'] = bdm
reservation = self.connection.run_instances(**run_instances_args)
instance = reservation.instances[0]
instance.add_tag("Name", name)
instance.add_tag("creator", getpass.getuser())
if 'tags' in kwargs:
for key in kwargs['tags']:
instance.add_tag(key, kwargs['tags'][key])
print("Waiting for instance to run", )
while instance.state != 'running':
instance.update()
sys.stdout.write(".")
sys.stdout.flush()
time.sleep(1)
print(" OK")
return instance
def _find_node_size(cls, node_size):
zone_config = get_provider_zone_config()
for name, size in sorted(zone_config['sizes'].items(), key=lambda t: t[1]):
if node_size.ram <= size['memory'] and node_size.cpus <= size['cpu']:
return name
return 'xx-large-unknown'
