def stopServer(self, auth, zone_id, req):
"""
@param : auth
{"auth":{
"key_id":"Key ID",
"secret":"Secret Key",
}
}
@param: zone_id
@param: req (Dic)
{"server_id":"xxx-xxxx-xxx"}
"""
# 1. Get Endpoint of Zone
cloudMgr = self.locator.getManager('CloudManager')
(r_name, z_name) = cloudMgr._getRegionZone(zone_id)
auth_data = auth['auth']
a_key = auth_data['key_id']
s_key = auth_data['secret']
# 2. Create DataCenter object
sdc = DataCenter(location=z_name, key_id=a_key, secret=s_key)
if req.has_key('server_id'):
mid = req['server_id']
machine = sdc.machine(machine_id=mid)
# Stop Machine
machine.stop()
# Wait state
machine.poll_until('stopped')
dic = {}
dic['status'] = machine.state
return dic
def discoverServers(self, auth, zone_id):
"""
find all servers at zone
@return: list of server info
"""
# 1. Get Endpoint of Zone
cloudMgr = self.locator.getManager('CloudManager')
(r_name, z_name) = cloudMgr._getRegionZone(zone_id)
auth_data = auth['auth']
a_key = auth_data['key_id']
s_key = auth_data['secret']
# 2. Create DataCenter object
sdc = DataCenter(location=z_name, key_id=a_key, secret=s_key)
machines = sdc.machines()
output = []
for machine in machines:
dic = {}
dic['name'] = machine.name
dic['server_id'] = machine.id
dic['private_ip_address'] = machine.private_ips[0]
if len(machine.public_ips) >= 1:
dic['floating_ip'] = machine.public_ips[0]
dic['status'] = machine.state
# Register Machine
output.append(dic)
return output
def discover(self, param, ctx):
"""
@param:
"auth":{
"key_id":"ACCESS Key ID",
"secret":"/root/.ssh/joyent_id_rsa"
}
}
"""
auth = param['auth']
if auth.has_key('key_id') == False:
raise ERROR_AUTH_FAILED(reason="Key ID is needed")
else:
a_key = auth['key_id']
if auth.has_key('secret') == False:
raise ERROR_AUTH_FAILED(reason="Secret(registered id_rsa private key) is needed")
else:
s_key = auth['secret']
sdc = DataCenter(key_id=a_key, secret=s_key)
# base on endpoint, Create Region
cloudMgr = self.locator.getManager('CloudManager')
# 1. Create Region
regions = self._getRegions(sdc.datacenters())
output = []
total_count = 0
for region in regions:
param = {'name':region}
region_info = cloudMgr.createRegion(param)
total_count = total_count + 1
output.append(region_info)
# 2. Detect Availability Zones
# Joyent has no AZ concept, use az = region
az_list = [region]
for az in az_list:
param = {'name': az,
'region_id': region_info.output['region_id'],
'zone_type': 'joyent'}
zone_info = cloudMgr.createZone(param)
# Update Zone Detail for DOCKER_HOST
zone_id = zone_info.output['zone_id']
self.logger.debug("Add Zone Detail at %s" % zone_id)
# NOTICE:
docker_url = 'tcp://%s.docker.joyent.com:2376' % region
p2 = {'zone_id': zone_id, 'create':[{'key':'DOCKER_HOST','value':docker_url},
{'key':'DOCKER_TLS_VERIFY','value':'1'}]}
cloudMgr.createZoneDetail(p2)
# Discover ALL servers and register them
servers = self.discoverServers({'auth':auth}, zone_id)
for server in servers:
cloudMgr.registerServerByServerInfo(zone_id, server, ctx)
# return Zones
return (output, total_count)
def run(self, **kwargs):
"""
"""
assert not env.hosts
if not env.get("joyent_account"):
print "To use the joyent api you must add a joyent_account value to your env"
sys.exit(1)
setup_name = "setup.%s" % kwargs.get("type")
task = functions.get_task_instance(setup_name)
default_dataset = DEFAULT_DATASET
default_package = DEFAULT_PACKAGE
if task:
if hasattr(task, "dataset"):
default_dataset = task.dataset
if hasattr(task, "server_size"):
default_package = task.server_size
else:
print "I don't know how to add a %s server" % kwargs.get("type")
sys.exit(1)
location = kwargs.get("data_center")
if not location and env.get("joyent_default_data_center"):
location = env.joyent_default_data_center
elif not location:
print "You must supply an data_center argument or add a joyent_default_data_center attribute to your env"
sys.exit(1)
key_name = raw_input("Enter your ssh key name: ")
key_id = "/%s/keys/%s" % (env.joyent_account, key_name)
allow_agent = env.get("allow_agent", False)
sdc = DataCenter(location=location, key_id=key_id, allow_agent=allow_agent)
name = functions.get_remote_name(None, task.config_section, name=kwargs.get("name"))
new_args = {
"name": name,
"dataset": kwargs.get("data_set", default_dataset),
"metadata": kwargs.get("metadata", {}),
"tags": kwargs.get("tags", {}),
"package": kwargs.get("package", default_package),
}
machine = sdc.create_machine(**new_args)
public_ip = machine.public_ips[0]
print "added machine %s" % public_ip
host_string = "admin@%s" % public_ip
print "waiting for machine to be ready"
while machine.status() != "running":
print "."
time.sleep(5)
print "done"
execute(setup_name, name=name, hosts=[host_string])
def run(self, **kwargs):
"""
"""
assert not env.hosts
if not env.get('joyent_account'):
print "To use the joyent api you must add a joyent_account value to your env"
sys.exit(1)
setup_name = 'setup.%s' % kwargs.get('type')
task = functions.get_task_instance(setup_name)
default_dataset = DEFAULT_DATASET
default_package = DEFAULT_PACKAGE
if task:
if hasattr(task, 'dataset'):
default_dataset = task.dataset
if hasattr(task, 'server_size'):
default_package = task.server_size
else:
print "I don't know how to add a %s server" % kwargs.get('type')
sys.exit(1)
location = kwargs.get('data_center')
if not location and env.get('joyent_default_data_center'):
location = env.joyent_default_data_center
elif not location:
print "You must supply an data_center argument or add a joyent_default_data_center attribute to your env"
sys.exit(1)
key_name = raw_input('Enter your ssh key name: ')
key_id = '/%s/keys/%s' % ( env.joyent_account, key_name)
sdc = DataCenter(location=location, key_id=key_id)
name = functions.get_remote_name(None, task.config_section,
name=kwargs.get('name'))
new_args = {
'name' : name,
'dataset' : kwargs.get('data_set', default_dataset),
'metadata' : kwargs.get('metadata', {}),
'tags' : kwargs.get('tags', {}),
'package' : kwargs.get('package', default_package)
}
machine = sdc.create_machine(**new_args)
public_ip = machine.public_ips[0]
print "added machine %s" % public_ip
host_string = 'admin@%s' % public_ip
print "waiting for machine to be ready"
while machine.status() != 'running':
print '.'
time.sleep(5)
print 'done'
execute(setup_name, name=name, hosts=[host_string])
def api_get(self):
""" Ask Joyent for all servers in a data center"""
sdc = DataCenter(location=self.joyent_uri,
key_id=self.joyent_key_id,
secret=self.joyent_secret,
allow_agent=True,
verbose=self.debug)
servers = sdc.machines()
return servers
def created_key(self, pub_key_path):
key_name = raw_input('Enter your ssh key name: ')
key_id = '/%s/keys/%s' % ( env.joyent_account, key_name)
allow_agent = env.get('allow_agent', False)
sdc = DataCenter(key_id=key_id, allow_agent=allow_agent)
with tempfile.TemporaryFile() as f:
get(pub_key_path, f)
f.seek(0)
data = f.read()
sdc.add_key(env.host_string, data)
def deployServer(self, auth, zone_id, req):
"""
@param : auth
{"auth":{
"key_id":"Key ID",
"secret":"Secret Key",
}
}
@param: zone_id
@param: req (Dic)
{"name":"test-machine",
"package":"g4-general-4G",
"image":'a601aa10-100a-11e6-9eb1-2bbb19e1e3e6',
...
"""
# 1. Get Endpoint of Zone
cloudMgr = self.locator.getManager('CloudManager')
(r_name, z_name) = cloudMgr._getRegionZone(zone_id)
auth_data = auth['auth']
a_key = auth_data['key_id']
s_key = auth_data['secret']
# 2. Create DataCenter object
sdc = DataCenter(location=z_name, key_id=a_key, secret=s_key)
# 3. Create Server
self.logger.debug(req)
instance = sdc.create_machine(**req)
instance.poll_until('running')
server = {}
server['status'] = instance.status()
server['server_id'] = instance.id
server['private_ip_address'] = instance.private_ips[0]
self.logger.debug("Create Server => Private IP:%s" % instance.private_ips[0])
server['floating_ip'] = instance.public_ips[0]
self.logger.debug("Create Server => Public IP:%s" % instance.public_ips[0])
# CPU, Memory, Disk
if req.has_key('package'):
packages = sdc.packages(req['package'])
if len(packages) == 1:
package = packages[0]
server['cpus'] = package['vcpus']
server['memory'] = package['memory']
server['disk'] = package['disk']
self.logger.debug("status:%s" % instance.status())
return server
def __init__(self, location):
self.sdc = DataCenter(location=location, key_id=settings.KEY_ID,
allow_agent=settings.ALLOW_AGENT)
vms = self.sdc.machines()
items = []
for (i, vm) in enumerate(vms):
items.append(SMWidget(i, '%s - %s' % (vm.name, vm.public_ips[0])))
super(SDCWidget, self).__init__(urwid.SimpleListWalker(items))
def _connect(self):
try:
self.sdc = DataCenter(location=self.location,
key_id=self.key_id, secret=self.id_rsa,
allow_agent=True, verbose=self.verbose)
except Exception as e:
print self.location, self.key_id, self.id_rsa
print "Failed to login: %s" % e
exit(1)
class Joyent(AecoBase):
def __init__(self, options=None):
super(Joyent, self).__init__(options=options, docs=__doc__)
self.machines = []
self.sdc = None
self.key_name = self._get_config("keyname")
self.user_name = self._get_config("username")
self.location = self._get_config("api")
self.id_rsa = self._get_config("id_rsa")
if self.user_name == False:
print "Joyent username is not set"
exit(1)
if self.key_name == False:
print "id_rsa is not set"
exit(1)
if self.id_rsa == False:
self.id_rsa = '~/.ssh/id_rsa'
self.key_id = "/" + self.user_name + "/keys/" + self.key_name
def _connect(self):
try:
self.sdc = DataCenter(location=self.location,
key_id=self.key_id, secret=self.id_rsa,
allow_agent=True, verbose=self.verbose)
except Exception as e:
print self.location, self.key_id, self.id_rsa
print "Failed to login: %s" % e
exit(1)
def _machine_format(self, m):
if m.state == "running":
m.state = TColors.green(m.state)
elif m.state == "stopped":
m.state = TColors.red(m.state)
else:
m.state = TColors.yellow(m.state)
m.created = format_last_run(m.created, color=False)
m.dataset = str(m.dataset).split(":")
self.results.append([m.name,
m.state,
"",
", ".join(m.ips),
m.type[0].upper(),
":".join(m.dataset[-2:]),
m.created])
def _network_format(self, network):
if network["public"] == True:
network["public"] = TColors.green("Public")
else:
network["public"] = TColors.red("Private")
if "description" not in network:
network["description"] = ""
self.results.append([network["public"],
network["name"],
network["id"],
network["description"]])
def _list_server(self):
try:
self.machines = self.sdc.machines()
except Exception as e:
print "Unable to search for server: %s" % str(e)
exit(1)
for machine in self.machines:
self._machine_format(machine)
# Print results
headers = ["Name", "State", "ID", "IPs", "Type", "DataSet", "Created"]
question = "List joyent Machines in {}".format(TColors.yellow(self.location))
print_table(self.results, headers=headers, question=question)
def joyent_runner(self, machine_name, api, state, package=None, networks=None, image=None):
print ".....\nPlease wait doing API request to {}".format(api)
module_arg = {"name": machine_name, "state": state, "data_center": api}
if state == "present":
module_arg.update({"networks": networks, "flavor": package, "image": image, "fire_forget": "false"})
inventory_manager = inventory.Inventory("127.0.0.1,")
# construct the ansible runner and execute on all hosts
results = ansible.runner.Runner(
pattern='*',
forks=1,
inventory=inventory_manager,
transport="local",
module_name='joyent',
module_path=self._get_config("ansible_lib"),
module_args=module_arg
).run()
for (hostname, result) in results['contacted'].items():
if 'failed' in result:
print "Failed \n%s" % result['msg']
elif 'failed' not in result:
if result.get("msg"):
msg = TColors.red(result.get("msg"))
if result.get("changed"):
if result.get("ips"):
msg += " IPs=" + ", ".join(result.get("ips"))
print msg
else:
print result.get("msg")
print result.get("timer")
else:
print "Output format not correct dumping all:\n%s", result
@staticmethod
def _load_list(json_file, fields=None, return_id=False):
if os.path.isfile(json_file):
if fields is None:
fields = ["name"]
# Warn if over two weeks old
json_data = open(json_file)
data_list = json.load(json_data)
name_list = map(lambda x: ":".join([x.get(field) for field in fields]), data_list)
#name_list = map(lambda x: x.get(fields), json.load(json_data))
if return_id:
id_list = map(lambda x: x.get("id"), data_list)
return name_list, id_list
else:
return name_list
else:
return None
def _create_server(self):
path_to_json_file = os.path.dirname(os.path.realpath(__file__)) + "/joyent"
machine_name = input_choice("Machine name", fmode=True)
api = input_choice("API Server", ["us-east-1", "us-west-1", "us-sw-1", "eu-ams-1", "us-east-2", "us-east-3"],
fmode=False)
package_list = self._load_list(path_to_json_file + "/{}.package.json".format(api))
package = input_choice("Package", options=package_list, fmode=True)
image_list, image_id = self._load_list(path_to_json_file + "/{}.images.json".format(api),
fields=["name", "version"], return_id=True)
image = input_choice("Image", options=image_list, fmode=True)
if image in image_list:
image_ref = "alias=" + image
image = image_id[image_list.index(image)]
else:
image_ref = ""
network_list, network_id = self._load_list(path_to_json_file + "/{}.networks.json".format(api), return_id=True)
networks_ref, networks = [], []
new_input = input_choice("Network", options=network_list, fmode=False)
while not new_input == "d":
if new_input in network_list:
networks_ref.append(new_input)
networks.append(network_id[network_list.index(new_input)])
new_input = input_choice("Network ('d' for done)", options=network_list, fmode=True)
if new_input == "d":
break
networks = ",".join(networks)
networks_ref = "alias=" + ",".join(networks_ref)
print "You want to provision the following:"
print "{0:15}: {1:30}".format("DC", TColors.warning(api))
print "{0:15}: {1:30}".format("Machine Name", TColors.warning(machine_name))
print "{0:15}: {1:30}".format("Package", TColors.warning(package))
print "{0:15}: {1:30} {2:30}".format("Image", TColors.warning(image), image_ref)
print "{0:15}: {1:30} {2:30}".format("Networks", TColors.warning(networks), networks_ref)
answer = input_choice("Are you (yes/no)", ["yes", "no"], fmode=False)
if answer == "yes":
self.joyent_runner(machine_name, api, "present", package=package, image=image, networks=networks)
else:
print "bye..."
def _update_db(self):
try:
self.machines = self.sdc.machines()
except Exception as e:
print "Unable to search for server: %s" % str(e)
exit(1)
for machine in self.machines:
self._machine_format(machine)
# Print results
server_list = {}
for server in self.results:
server_list.update({server[0]: server[3].split(",")})
with open('/tmp/server.json', 'w') as outfile:
json.dump(server_list, outfile)
def _delete_server(self):
machine_name = self.arguments.get("<servername>")
api = self._get_config("api")
print "Are you sure you want to delete '" + TColors.red(machine_name) + "' in '" + TColors.red(api) + "'?"
user_input = raw_input("If you are sure please type the server name again: ")
if user_input != machine_name:
print "Server names don't match. bye!!"
exit(1)
self.joyent_runner(machine_name, api, "absent")
print "if you run on mac os OS X Mavericks, Mountain Lion, and Lion, you can reset your dns cache with:"
print "\tsudo killall -HUP mDNSResponder"
print "if you run mac os OS X Yosemite you can reset your dns cache with:"
print "\tsudo discoveryutil mdnsflushcache"
def _stop_server(self):
machine_name = self.arguments.get("<servername>")
api = self._get_config("api")
print "Are you sure you want to stop '" + TColors.red(machine_name) + "' in '" + TColors.red(api) + "'?"
user_input = raw_input("If you are sure please type the server name again: ")
if user_input != machine_name:
print "Server names don't match. bye!!"
exit(1)
self.joyent_runner(machine_name, api, "stopped")
def _start_server(self):
machine_name = self.arguments.get("<servername>")
api = self._get_config("api")
print "Are you sure you want to start '" + TColors.red(machine_name) + "' in '" + TColors.red(api) + "'?"
user_input = raw_input("If you are sure please type the server name again: ")
if user_input != machine_name:
print "Server names don't match. bye!!"
exit(1)
self.joyent_runner(machine_name, api, "running")
def _network_list(self):
networks = []
try:
networks = self.sdc.networks()
except Exception as e:
print "Unable to search for networks: %s" % str(e)
exit(1)
for network in networks:
self._network_format(network)
headers = ["Public", "Name", "Id","Description"]
question = "List of joyent networks in {}".format(TColors.yellow(self.location))
print_table(self.results, headers=headers, question=question)
exit(1)
@staticmethod
def print_help():
print __doc__
def parse(self):
if self.arguments.get("server"):
if self.arguments.get("list"):
self._connect()
self._list_server()
elif self.arguments.get("delete"):
self._delete_server()
elif self.arguments.get("create"):
self._create_server()
elif self.arguments.get("stop"):
self._stop_server()
elif self.arguments.get("start"):
self._start_server()
elif self.arguments.get("network"):
if self.arguments.get("list"):
self._connect()
self._network_list()
elif self.arguments.get("update"):
self._connect()
self._update_db()
def discoverServer(self, auth, zone_id, req):
"""
@param : auth
{"auth":{
"key_id":"Key ID",
"secret":"Secret Key",
}
}
@param: zone_id
@param: req (Dic)
{"server_id":"xxx-xxxx-xxx"}
{"name":"server_name"}
"""
# 1. Get Endpoint of Zone
cloudMgr = self.locator.getManager('CloudManager')
(r_name, z_name) = cloudMgr._getRegionZone(zone_id)
auth_data = auth['auth']
a_key = auth_data['key_id']
s_key = auth_data['secret']
# 2. Create DataCenter object
sdc = DataCenter(location=z_name, key_id=a_key, secret=s_key)
if req.has_key('server_id'):
mid = req['server_id']
machine = sdc.machine(machine_id=mid)
dic = {}
dic['server_id'] = machine.id
dic['private_ip_address'] = machine.private_ips[0]
if len(machine.public_ips) >= 1:
dic['floating_ip'] = machine.public_ips[0]
dic['status'] = machine.status()
# CPU, Memory, Disk
if machine.has_key('package'):
packages = sdc.packages(machine['package'])
if len(packages) == 1:
package = packages[0]
dic['cpus'] = package['vcpus']
dic['memory'] = package['memory']
dic['disk'] = package['disk']
return dic
elif req.has_key('name'):
my_name = req['name']
machines = sdc.machines(name=my_name)
self.logger.debug("Detected machine is %s" % len(machines))
dic = {}
if len(machines) != 1:
# Error or ?
return dic
machine = machines[0]
dic['server_id'] = machine.id
dic['private_ip_address'] = machine.private_ips[0]
if len(machine.public_ips) >= 1:
dic['floating_ip'] = machine.public_ips[0]
dic['status'] = machine.status()
# CPU, Memory, Disk
#if machine.has_key('package'):
# packages = sdc.packages(machine['package'])
# if len(packages) == 1:
# package = packages[0]
# dic['cpus'] = package['vcpus']
# dic['memory'] = package['memory']
# dic['disk'] = package['disk']
return dic
self.logger.error("No Server founded:%s" % z_name)
def run(self, **kwargs):
"""
"""
assert not env.hosts
if not env.get('joyent_account'):
print "To use the joyent api you must add a joyent_account value to your env"
sys.exit(1)
setup_name = 'servers.%s.setup' % kwargs.get('type')
config_name = 'servers.%s.api_config' % kwargs.get('type')
user = kwargs.get('user', 'admin')
task = functions.get_task_instance(setup_name)
default_dataset = DEFAULT_DATASET
default_package = DEFAULT_PACKAGE
networks = None
if task:
results = execute(config_name, hosts=['fake'])['fake']
config_section = results['config_section']
if 'dataset' in results:
default_dataset = results['dataset']
if 'server_size' in results:
default_package = results['server_size']
if 'networks' in results:
networks = results['networks']
else:
print "I don't know how to add a %s server" % kwargs.get('type')
sys.exit(1)
assert config_section
location = kwargs.get('data_center')
if not location and env.get('joyent_default_data_center'):
location = env.joyent_default_data_center
elif not location:
print "You must supply an data_center argument or add a joyent_default_data_center attribute to your env"
sys.exit(1)
if not networks and env.get('joyent_default_networks'):
networks = env.joyent_default_networks
key_name = raw_input('Enter your ssh key name: ')
key_id = '/%s/keys/%s' % ( env.joyent_account, key_name)
allow_agent = env.get('allow_agent', False)
sdc = DataCenter(location=location, key_id=key_id, allow_agent=allow_agent)
name = functions.get_remote_name(None, config_section,
name=kwargs.get('name'))
dataset = kwargs.get('data_set', default_dataset)
datasets = sdc.datasets(search=dataset)
datasets = sorted(datasets, key=lambda k: k['urn'])
if datasets:
dataset_id = datasets[-1]['id']
else:
print "couldn't find a dataset %s. Here is what we found." % dataset
print datasets
sys.exit(1)
package = kwargs.get('package', default_package)
packages = sdc.packages(name=package)
if len(packages) != 1:
print "couldn't find a package %s. Here is what we found." % package
print packages
sys.exit(1)
else:
package_id = packages[0]['id']
new_args = {
'name' : name,
'dataset' : dataset_id,
'metadata' : kwargs.get('metadata', {}),
'tags' : kwargs.get('tags', {}),
'package' : package_id,
'networks' : networks
}
machine = sdc.create_machine(**new_args)
print 'waiting for machine to come up'
machine.poll_until('running')
public_ip = machine.public_ips[0]
print "added machine %s" % public_ip
host_string = '%s@%s' % (user, public_ip)
print 'done'
execute(setup_name, hosts=[host_string])
def run(self, **kwargs):
"""
"""
assert not env.hosts
if not env.get('joyent_account'):
print "To use the joyent api you must add a joyent_account value to your env"
sys.exit(1)
setup_name = 'servers.%s.setup' % kwargs.get('type')
config_name = 'servers.%s.api_config' % kwargs.get('type')
user = kwargs.get('user', 'admin')
task = functions.get_task_instance(setup_name)
default_dataset = DEFAULT_DATASET
default_package = DEFAULT_PACKAGE
networks = None
if task:
results = execute(config_name, hosts=['fake'])['fake']
config_section = results['config_section']
if 'dataset' in results:
default_dataset = results['dataset']
if 'server_size' in results:
default_package = results['server_size']
if 'networks' in results:
networks = results['networks']
else:
print "I don't know how to add a %s server" % kwargs.get('type')
sys.exit(1)
assert config_section
location = kwargs.get('data_center')
if not location and env.get('joyent_default_data_center'):
location = env.joyent_default_data_center
elif not location:
print "You must supply an data_center argument or add a joyent_default_data_center attribute to your env"
sys.exit(1)
if not networks and env.get('joyent_default_networks'):
networks = env.joyent_default_networks
key_name = raw_input('Enter your ssh key name: ')
key_id = '/%s/keys/%s' % (env.joyent_account, key_name)
allow_agent = env.get('allow_agent', False)
sdc = DataCenter(location=location,
key_id=key_id,
allow_agent=allow_agent)
name = functions.get_remote_name(None,
config_section,
name=kwargs.get('name'))
dataset = kwargs.get('data_set', default_dataset)
datasets = sdc.datasets(search=dataset)
datasets = sorted(datasets, key=lambda k: k['urn'])
if datasets:
dataset_id = datasets[-1]['id']
else:
print "couldn't find a dataset %s. Here is what we found." % dataset
print datasets
sys.exit(1)
package = kwargs.get('package', default_package)
packages = sdc.packages(name=package)
if len(packages) != 1:
print "couldn't find a package %s. Here is what we found." % package
print packages
sys.exit(1)
else:
package_id = packages[0]['id']
new_args = {
'name': name,
'dataset': dataset_id,
'metadata': kwargs.get('metadata', {}),
'tags': kwargs.get('tags', {}),
'package': package_id,
'networks': networks
}
machine = sdc.create_machine(**new_args)
print 'waiting for machine to come up'
machine.poll_until('running')
public_ip = machine.public_ips[0]
print "added machine %s" % public_ip
host_string = '%s@%s' % (user, public_ip)
print 'done'
execute(setup_name, hosts=[host_string])
def run(self, **kwargs):
"""
"""
assert not env.hosts
if not env.get('joyent_account'):
print "To use the joyent api you must add a joyent_account value to your env"
sys.exit(1)
setup_name = 'setup.%s' % kwargs.get('type')
task = functions.get_task_instance(setup_name)
default_dataset = DEFAULT_DATASET
default_package = DEFAULT_PACKAGE
if task:
if hasattr(task, 'dataset'):
default_dataset = task.dataset
if hasattr(task, 'server_size'):
default_package = task.server_size
else:
print "I don't know how to add a %s server" % kwargs.get('type')
sys.exit(1)
location = kwargs.get('data_center')
if not location and env.get('joyent_default_data_center'):
location = env.joyent_default_data_center
elif not location:
print "You must supply an data_center argument or add a joyent_default_data_center attribute to your env"
sys.exit(1)
key_name = raw_input('Enter your ssh key name: ')
key_id = '/%s/keys/%s' % (env.joyent_account, key_name)
allow_agent = env.get('allow_agent', False)
sdc = DataCenter(location=location,
key_id=key_id,
allow_agent=allow_agent)
name = functions.get_remote_name(None,
task.config_section,
name=kwargs.get('name'))
new_args = {
'name': name,
'dataset': kwargs.get('data_set', default_dataset),
'metadata': kwargs.get('metadata', {}),
'tags': kwargs.get('tags', {}),
'package': kwargs.get('package', default_package)
}
machine = sdc.create_machine(**new_args)
public_ip = machine.public_ips[0]
print "added machine %s" % public_ip
host_string = 'admin@%s' % public_ip
print "waiting for machine to be ready"
while machine.status() != 'running':
print '.'
time.sleep(5)
print 'done'
execute(setup_name, name=name, hosts=[host_string])
