class CCIPlatform(Platform):
_required_opts = ['cores', 'memory', 'domain',
'datacenter', 'os_code']
def _on_init(self):
self._client = Client(username=getenv('SL_USERNAME'),
api_key=getenv('SL_API_KEY'))
self._manager = CCIManager(self._client)
def find_instance(self, host_name):
instance = None
host_name = host_name.lower()
for ii in self._manager.list_instances():
fqdn = ii.get('fullyQualifiedDomainName', '')
if fqdn.lower() == host_name:
instance = Instance(id=ii.get('id'), name=fqdn)
break
return instance
def get_instance(self, id):
cci = self._manager.get_instance(id)
return self._cci_to_instance(cci)
def create_instance(self, host_name):
host_bits = host_name.split('.', 1)
host_name = host_bits[0]
domain = host_bits[1] if len(host_bits) >= 2 else self.config('domain')
base_options = {'cpus': self.config('cores'),
'memory': self.config('memory'),
'hostname': host_name,
'domain': domain,
'datacenter': self.config('datacenter'),
'os_code': self.config('os_code')}
print 'creating cci %s/%s' % (host_name, domain)
print base_options
cci = self._manager.create_instance(**base_options)
cci = self._cci_await_ready(cci)
self._cci_install_keys(cci['id'])
return self._cci_to_instance(cci)
def reimage_instance(self, instance):
self._manager.reload_instance(instance.id)
cci = self._manager.get_instance(instance.id)
cci = self._cci_await_transaction_start(cci)
cci = self._cci_await_ready(cci)
self._cci_install_keys(cci['id'])
return self._cci_to_instance(cci)
def delete_instance(self, instance):
self._manager.cancel_instance(instance.id)
self._cci_await_delete(self._manager.get_instance(instance.id))
def instance_ready(self, instance):
cci = self._manager.get_instance(instance.id)
return (cci and 'activeTransaction' not in cci)
def _cci_to_instance(self, cci):
if not cci:
return None
return Instance(id=cci['id'], name=cci['fullyQualifiedDomainName'])
def _cci_await_state(self, cci, state_check, sleep_secs=5):
wait_start = time()
self.log_info('Waiting for %s to change state...' % (cci['id']))
while state_check(cci):
sleep(sleep_secs)
cci = self._manager.get_instance(cci['id'])
self.log_info('...')
self.log_info('Available after %0.3f secs.' % (time() - wait_start))
return cci
def _cci_await_ready(self, cci):
return self._cci_await_state(cci,
lambda c: 'activeTransaction' in c,
sleep_secs=5)
def _cci_await_transaction_start(self, cci):
return self._cci_await_state(cci,
lambda c: 'activeTransaction' not in c,
sleep_secs=2)
def _cci_await_delete(self, cci):
return self._cci_await_state(cci,
lambda c: c and 'id' in c,
sleep_secs=2)
def _get_cci_root_password(self, cci):
passwords = self._manager.get_instance_passwords(cci['id'])
password = None
for p in passwords:
if 'username' in p and p['username'] == 'root':
password = p['password']
break
return password
def _cci_install_keys(self, id):
cci = self._manager.get_instance(id)
password = self._get_cci_root_password(cci)
if not password:
raise Exception('Passwords are not available for instance %s' %
cci['id'])
keys_url = self.config('ssh_key_url')
if not keys_url:
return
client_settings = {'hostname': cci['primaryIpAddress'],
'username': '******',
'password': password}
client = SSHClient()
client.set_missing_host_key_policy(_SuppressPolicy())
client.connect(look_for_keys=False, **client_settings)
client.exec_command('mkdir -p ~/.ssh')
client.exec_command('wget -T 10 -q -O ~/.ssh/authorized_keys %s' %
keys_url)
client.close()
def execute(client, args):
cci = CCIManager(client)
if args['--userdata'] and args['--userfile']:
raise ArgumentError('[-u | --userdata] not allowed with '
'[-F | --userfile]')
if args['--userfile']:
if not os.path.exists(args['--userfile']):
raise ArgumentError(
'File does not exist [-u | --userfile] = %s'
% args['--userfile'])
data = {
"hourly": args['--hourly'],
"cpus": args['--cpu'],
"domain": args['--domain'],
"hostname": args['--hostname'],
"private": args['--private'],
"local_disk": True,
}
try:
memory = int(args['--memory'])
if memory < 1024:
memory = memory * 1024
except ValueError:
unit = args['--memory'][-1]
memory = int(args['--memory'][0:-1])
if unit in ['G', 'g']:
memory = memory * 1024
if unit in ['T', 'r']:
memory = memory * 1024 * 1024
data["memory"] = memory
if args['--monthly']:
data["hourly"] = False
if args.get('--os'):
data["os_code"] = args['--os']
if args.get('--image'):
data["image_id"] = args['--image']
if args.get('--datacenter'):
data["datacenter"] = args['--datacenter']
if args.get('--network'):
data['nic_speed'] = args.get('--network')
if args.get('--userdata'):
data['userdata'] = args['--userdata']
elif args.get('userfile'):
f = open(args['--userfile'], 'r')
try:
data['userdata'] = f.read()
finally:
f.close()
t = Table(['Item', 'cost'])
t.align['Item'] = 'r'
t.align['cost'] = 'r'
if args.get('--test'):
result = cci.verify_create_instance(**data)
total_monthly = 0.0
total_hourly = 0.0
for price in result['prices']:
total_monthly += float(price.get('recurringFee', 0.0))
total_hourly += float(price.get('hourlyRecurringFee', 0.0))
if args.get('--hourly'):
rate = "%.2f" % float(price['hourlyRecurringFee'])
else:
rate = "%.2f" % float(price['recurringFee'])
t.add_row([price['item']['description'], rate])
if args.get('--hourly'):
total = total_hourly
else:
total = total_monthly
billing_rate = 'monthly'
if args.get('--hourly'):
billing_rate = 'hourly'
t.add_row(['Total %s cost' % billing_rate, "%.2f" % total])
output = SequentialOutput(blanks=False)
output.append(t)
output.append(FormattedItem(
'',
' -- ! Prices reflected here are retail and do not '
'take account level discounts and are not guarenteed.')
)
elif args['--really'] or confirm(
"This action will incur charges on your account. Continue?"):
result = cci.create_instance(**data)
t = Table(['name', 'value'])
t.align['name'] = 'r'
t.align['value'] = 'l'
t.add_row(['id', result['id']])
t.add_row(['created', result['createDate']])
t.add_row(['guid', result['globalIdentifier']])
output = t
else:
raise CLIAbort('Aborting CCI order.')
if args.get('--wait') or 0 and not args.get('--test'):
ready = cci.wait_for_transaction(
result['id'], int(args.get('--wait') or 1))
t.add_row(['ready', ready])
return output
