Revision 3185cd6d kamaki/cli/commands/cyclades.py
| b/kamaki/cli/commands/cyclades.py | ||
|---|---|---|
| 59 | 59 |
\n* to set authentication token: /config set cloud.<cloud>.token <token>' |
| 60 | 60 |
|
| 61 | 61 |
howto_personality = [ |
| 62 |
'Defines a file to be injected to VMs personality.',
|
|
| 63 |
'Personality value syntax: PATH,[SERVER_PATH,[OWNER,[GROUP,[MODE]]]]',
|
|
| 64 |
' PATH: of local file to be injected',
|
|
| 62 |
'Defines a file to be injected to VMs file system.',
|
|
| 63 |
'syntax: PATH,[SERVER_PATH,[OWNER,[GROUP,[MODE]]]]',
|
|
| 64 |
' PATH: local file to be injected (relative or absolute)',
|
|
| 65 | 65 |
' SERVER_PATH: destination location inside server Image', |
| 66 |
' OWNER: user id of destination file owner',
|
|
| 67 |
' GROUP: group id or name to own destination file',
|
|
| 66 |
' OWNER: VMs user id of the remote destination file',
|
|
| 67 |
' GROUP: VMs group id or name of the destination file',
|
|
| 68 | 68 |
' MODEL: permition in octal (e.g. 0777 or o+rwx)'] |
| 69 | 69 |
|
| 70 | 70 |
|
| 71 |
class _server_wait(object):
|
|
| 71 |
class _service_wait(object):
|
|
| 72 | 72 |
|
| 73 | 73 |
wait_arguments = dict( |
| 74 | 74 |
progress_bar=ProgressBarArgument( |
| 75 |
'do not show progress bar', |
|
| 76 |
('-N', '--no-progress-bar'),
|
|
| 77 |
False |
|
| 78 |
) |
|
| 75 |
'do not show progress bar', ('-N', '--no-progress-bar'), False)
|
|
| 79 | 76 |
) |
| 80 | 77 |
|
| 81 |
def _wait(self, server_id, currect_status):
|
|
| 78 |
def _wait(self, service, service_id, status_method, currect_status):
|
|
| 82 | 79 |
(progress_bar, wait_cb) = self._safe_progress_bar( |
| 83 |
'Server %s still in %s mode' % (server_id, currect_status))
|
|
| 80 |
'%s %s still in %s mode' % (service, service_id, currect_status))
|
|
| 84 | 81 |
|
| 85 | 82 |
try: |
| 86 |
new_mode = self.client.wait_server( |
|
| 87 |
server_id, |
|
| 88 |
currect_status, |
|
| 89 |
wait_cb=wait_cb) |
|
| 90 |
except Exception: |
|
| 91 |
raise |
|
| 83 |
new_mode = status_method( |
|
| 84 |
service_id, currect_status, wait_cb=wait_cb) |
|
| 92 | 85 |
finally: |
| 93 | 86 |
self._safe_progress_bar_finish(progress_bar) |
| 94 | 87 |
if new_mode: |
| 95 |
print('Server %s is now in %s mode' % (server_id, new_mode))
|
|
| 88 |
self.error('%s %s is now in %s mode' % (
|
|
| 89 |
service, service_id, new_mode)) |
|
| 96 | 90 |
else: |
| 97 | 91 |
raiseCLIError(None, 'Time out') |
| 98 | 92 |
|
| 99 | 93 |
|
| 100 |
class _network_wait(object):
|
|
| 94 |
class _server_wait(_service_wait):
|
|
| 101 | 95 |
|
| 102 |
wait_arguments = dict( |
|
| 103 |
progress_bar=ProgressBarArgument( |
|
| 104 |
'do not show progress bar', |
|
| 105 |
('-N', '--no-progress-bar'),
|
|
| 106 |
False |
|
| 107 |
) |
|
| 108 |
) |
|
| 96 |
def _wait(self, server_id, currect_status): |
|
| 97 |
super(_server_wait, self)._wait( |
|
| 98 |
'Server', server_id, self.client.wait_server, currect_status) |
|
| 109 | 99 |
|
| 110 |
def _wait(self, net_id, currect_status): |
|
| 111 |
(progress_bar, wait_cb) = self._safe_progress_bar( |
|
| 112 |
'Network %s still in %s mode' % (net_id, currect_status)) |
|
| 113 | 100 |
|
| 114 |
try: |
|
| 115 |
new_mode = self.client.wait_network( |
|
| 116 |
net_id, |
|
| 117 |
currect_status, |
|
| 118 |
wait_cb=wait_cb) |
|
| 119 |
except Exception: |
|
| 120 |
raise |
|
| 121 |
finally: |
|
| 122 |
self._safe_progress_bar_finish(progress_bar) |
|
| 123 |
if new_mode: |
|
| 124 |
print('Network %s is now in %s mode' % (net_id, new_mode))
|
|
| 125 |
else: |
|
| 126 |
raiseCLIError(None, 'Time out') |
|
| 101 |
class _network_wait(_service_wait): |
|
| 102 |
|
|
| 103 |
def _wait(self, net_id, currect_status): |
|
| 104 |
super(_network_wait, self)._wait( |
|
| 105 |
'Network', net_id, self.client.wait_network, currect_status) |
|
| 127 | 106 |
|
| 128 | 107 |
|
| 129 | 108 |
class _init_cyclades(_command_init): |
| ... | ... | |
| 131 | 110 |
@addLogSettings |
| 132 | 111 |
def _run(self, service='compute'): |
| 133 | 112 |
if getattr(self, 'cloud', None): |
| 134 |
base_url = self._custom_url(service)\
|
|
| 135 |
or self._custom_url('cyclades')
|
|
| 113 |
base_url = self._custom_url(service) or self._custom_url(
|
|
| 114 |
'cyclades') |
|
| 136 | 115 |
if base_url: |
| 137 |
token = self._custom_token(service)\ |
|
| 138 |
or self._custom_token('cyclades')\
|
|
| 139 |
or self.config.get_cloud('token')
|
|
| 140 |
self.client = CycladesClient( |
|
| 141 |
base_url=base_url, token=token) |
|
| 116 |
token = self._custom_token(service) or self._custom_token( |
|
| 117 |
'cyclades') or self.config.get_cloud('token')
|
|
| 118 |
self.client = CycladesClient(base_url=base_url, token=token) |
|
| 142 | 119 |
return |
| 143 | 120 |
else: |
| 144 | 121 |
self.cloud = 'default' |
| ... | ... | |
| 207 | 184 |
|
| 208 | 185 |
def _filter_by_image(self, servers): |
| 209 | 186 |
iid = self['image_id'] |
| 210 |
new_servers = [] |
|
| 211 |
for srv in servers: |
|
| 212 |
if srv['image']['id'] == iid: |
|
| 213 |
new_servers.append(srv) |
|
| 214 |
return new_servers |
|
| 187 |
return [srv for srv in servers if srv['image']['id'] == iid] |
|
| 215 | 188 |
|
| 216 | 189 |
def _filter_by_flavor(self, servers): |
| 217 | 190 |
fid = self['flavor_id'] |
| 218 |
new_servers = [] |
|
| 219 |
for srv in servers: |
|
| 220 |
if '%s' % srv['flavor']['id'] == '%s' % fid: |
|
| 221 |
new_servers.append(srv) |
|
| 222 |
return new_servers |
|
| 191 |
return [srv for srv in servers if ( |
|
| 192 |
'%s' % srv['image']['id'] == '%s' % fid)] |
|
| 223 | 193 |
|
| 224 | 194 |
def _filter_by_metadata(self, servers): |
| 225 | 195 |
new_servers = [] |
| ... | ... | |
| 327 | 297 |
raiseCLIError( |
| 328 | 298 |
None, |
| 329 | 299 |
'--personality: File %s does not exist' % path, |
| 330 |
importance=1, |
|
| 331 |
details=howto_personality) |
|
| 300 |
importance=1, details=howto_personality) |
|
| 332 | 301 |
self._value.append(dict(path=path)) |
| 333 | 302 |
with open(path) as f: |
| 334 | 303 |
self._value[i]['contents'] = b64encode(f.read()) |
| ... | ... | |
| 581 | 550 |
@errors.cyclades.connection |
| 582 | 551 |
@errors.cyclades.server_id |
| 583 | 552 |
def _run(self, server_id): |
| 584 |
print(self.client.get_firewall_profile(server_id))
|
|
| 553 |
self.writeln(self.client.get_firewall_profile(server_id))
|
|
| 585 | 554 |
|
| 586 | 555 |
def main(self, server_id): |
| 587 | 556 |
super(self.__class__, self)._run() |
| ... | ... | |
| 601 | 570 |
@errors.cyclades.server_id |
| 602 | 571 |
def _run(self, server_id): |
| 603 | 572 |
reply = self.client.list_server_nics(int(server_id)) |
| 604 |
self._print( |
|
| 605 |
reply, with_enumeration=self['enum'] and len(reply) > 1) |
|
| 573 |
self._print(reply, with_enumeration=self['enum'] and (reply) > 1) |
|
| 606 | 574 |
|
| 607 | 575 |
def main(self, server_id): |
| 608 | 576 |
super(self.__class__, self)._run() |
| ... | ... | |
| 881 | 849 |
for net in networks: |
| 882 | 850 |
v = net.get(key, None) |
| 883 | 851 |
if v: |
| 884 |
net[key] += ' (%s)' % uuids[net[key]]
|
|
| 852 |
net[key] += ' (%s)' % uuids[v]
|
|
| 885 | 853 |
return networks |
| 886 | 854 |
|
| 887 | 855 |
@errors.generic.all |
| ... | ... | |
| 1044 | 1012 |
if not num_of_disconnected: |
| 1045 | 1013 |
raise ClientError( |
| 1046 | 1014 |
'Network Interface %s not found on server %s' % ( |
| 1047 |
nic_id, |
|
| 1048 |
server_id), |
|
| 1015 |
nic_id, server_id), |
|
| 1049 | 1016 |
status=404) |
| 1050 | 1017 |
print('Disconnected %s connections' % num_of_disconnected)
|
| 1051 | 1018 |
|
| ... | ... | |
| 1123 | 1090 |
class server_ip_create(_init_cyclades, _optional_json): |
| 1124 | 1091 |
"""Create a new floating IP""" |
| 1125 | 1092 |
|
| 1126 |
arguments = dict( |
|
| 1127 |
pool=ValueArgument('Source IP pool', ('--pool'), None)
|
|
| 1128 |
) |
|
| 1093 |
arguments = dict(pool=ValueArgument('Source IP pool', ('--pool'), None))
|
|
| 1129 | 1094 |
|
| 1130 | 1095 |
@errors.generic.all |
| 1131 | 1096 |
@errors.cyclades.connection |
Also available in: Unified diff