def print_list(self, *args, **kwargs):
kwargs.setdefault('out', self._out)
- return print_list(*args, out=self._out, **kwargs)
+ return print_list(*args, **kwargs)
def print_dict(self, *args, **kwargs):
kwargs.setdefault('out', self._out)
- return print_dict(*args, out=self._out, **kwargs)
+ return print_dict(*args, **kwargs)
def print_json(self, *args, **kwargs):
kwargs.setdefault('out', self._out)
- return print_json(*args, out=self._out, **kwargs)
+ return print_json(*args, **kwargs)
def print_items(self, *args, **kwargs):
kwargs.setdefault('out', self._out)
- return print_items(*args, out=self._out, **kwargs)
+ return print_items(*args, **kwargs)
def ask_user(self, *args, **kwargs):
kwargs.setdefault('user_in', self._in)
kwargs.setdefault('out', self._out)
- return print_items(*args, out=self._out, **kwargs)
+ return ask_user(*args, **kwargs)
@DontRaiseKeyError
def _custom_url(self, service):
_command_init, errors, _optional_json, addLogSettings)
from kamaki.cli.command_tree import CommandTree
from kamaki.cli.errors import CLIBaseUrlError, CLIError
-from kamaki.cli.utils import print_dict, ask_user, stdout
user_cmds = CommandTree('user', 'Astakos API commands')
_commands = [user_cmds]
token_bu = self.client.token
try:
r = self.client.authenticate(custom_token)
- if (token_bu != self.client.token and
- ask_user('Permanently save token as cloud.%s.token ?' % (
+ if (token_bu != self.client.token and self.ask_user(
+ 'Permanently save token as cloud.%s.token ?' % (
self.cloud))):
self._write_main_token(self.client.token)
except Exception:
raise
def _print_access(r, out):
- print_dict(r['access'], out=out)
+ self.print_dict(r['access'], out=out)
self._print(r, _print_access)
@errors.generic.all
def _run(self):
- self._print(self.client.user_info(), print_dict)
+ self._print(self.client.user_info(), self.print_dict)
def main(self):
super(self.__class__, self)._run()
self.error('Session user set to %s (%s)' % (
self.client.user_term('name'),
self.client.user_term('id')))
- if ask_user(
+ if self.ask_user(
'Permanently make %s the main user?' % (
- self.client.user_term('name')),
- out=self._out, user_in=self._in):
+ self.client.user_term('name'))):
self._write_main_token(self.client.token)
return
raise CLIError(
# interpreted as representing official policies, either expressed
# or implied, of GRNET S.A.
-from sys import stdout
-
from kamaki.cli import command
from kamaki.cli.argument import FlagArgument
from kamaki.cli.commands import _command_init, errors
# interpreted as representing official policies, either expressed
# or implied, of GRNET S.A.
+from base64 import b64encode
+from os.path import exists
+from io import StringIO
+from pydoc import pager
+
from kamaki.cli import command
from kamaki.cli.command_tree import CommandTree
-from kamaki.cli.utils import (
- print_dict, remove_from_items, filter_dicts_by_dict, pager)
+from kamaki.cli.utils import remove_from_items, filter_dicts_by_dict
from kamaki.cli.errors import raiseCLIError, CLISyntaxError, CLIBaseUrlError
from kamaki.clients.cyclades import CycladesClient, ClientError
from kamaki.cli.argument import FlagArgument, ValueArgument, KeyValueArgument
from kamaki.cli.commands import (
_optional_output_cmd, _optional_json, _name_filter, _id_filter)
-from base64 import b64encode
-from os.path import exists
-from io import StringIO
-
server_cmds = CommandTree('server', 'Cyclades/Compute API server commands')
flavor_cmds = CommandTree('flavor', 'Cyclades/Compute API flavor commands')
uuids = self._uuids2usernames([vm['user_id'], vm['tenant_id']])
vm['user_id'] += ' (%s)' % uuids[vm['user_id']]
vm['tenant_id'] += ' (%s)' % uuids[vm['tenant_id']]
- self._print(vm, print_dict)
+ self._print(vm, self.print_dict)
def main(self, server_id):
super(self.__class__, self)._run()
usernames = self._uuids2usernames([r['user_id'], r['tenant_id']])
r['user_id'] += ' (%s)' % usernames[r['user_id']]
r['tenant_id'] += ' (%s)' % usernames[r['tenant_id']]
- self._print(r, print_dict)
+ self._print(r, self.print_dict)
if self['wait']:
self._wait(r['id'], r['status'])
@errors.cyclades.server_id
def _run(self, server_id):
self._print(
- self.client.get_server_console(int(server_id)), print_dict)
+ self.client.get_server_console(int(server_id)), self.print_dict)
def main(self, server_id):
super(self.__class__, self)._run()
@errors.cyclades.metadata
def _run(self, server_id, key=''):
self._print(
- self.client.get_server_metadata(int(server_id), key), print_dict)
+ self.client.get_server_metadata(int(server_id), key),
+ self.print_dict)
def main(self, server_id, key=''):
super(self.__class__, self)._run()
'key1=value1 key2=value2'])
self._print(
self.client.update_server_metadata(int(server_id), **metadata),
- print_dict)
+ self.print_dict)
def main(self, server_id, *key_equals_val):
super(self.__class__, self)._run()
@errors.cyclades.connection
@errors.cyclades.server_id
def _run(self, server_id):
- self._print(self.client.get_server_stats(int(server_id)), print_dict)
+ self._print(
+ self.client.get_server_stats(int(server_id)), self.print_dict)
def main(self, server_id):
super(self.__class__, self)._run()
@errors.cyclades.flavor_id
def _run(self, flavor_id):
self._print(
- self.client.get_flavor_details(int(flavor_id)), print_dict)
+ self.client.get_flavor_details(int(flavor_id)), self.print_dict)
def main(self, flavor_id):
super(self.__class__, self)._run()
def _run(self, network_id):
network = self.client.get_network_details(int(network_id))
_add_name(self, network)
- self._print(network, print_dict, exclude=('id'))
+ self._print(network, self.print_dict, exclude=('id'))
def main(self, network_id):
super(self.__class__, self)._run()
dhcp=self['dhcp'],
type=self['type'])
_add_name(self, r)
- self._print(r, print_dict)
+ self._print(r, self.print_dict)
if self['wait']:
self._wait(r['id'], 'PENDING')
@errors.generic.all
@errors.cyclades.connection
def _run(self, ip):
- self._print(self.client.get_floating_ip(ip), print_dict)
+ self._print(self.client.get_floating_ip(ip), self.print_dict)
def main(self, ip):
super(self.__class__, self)._run()
from kamaki.cli.commands import _command_init, errors
from kamaki.cli import exec_cmd, print_error_message
from kamaki.cli.errors import CLIError, raiseCLIError
-from kamaki.cli.utils import split_input, print_list
+from kamaki.cli.utils import split_input
from kamaki.clients import ClientError
ret = self.history.get(match_terms=self['match'], limit=self['limit'])
if not cmd_ids:
- print_list(ret, out=self._out)
+ self.print_list(ret)
return
num_list = []
from os import path
from logging import getLogger
from io import StringIO
+from pydoc import pager
from kamaki.cli import command
from kamaki.cli.command_tree import CommandTree
-from kamaki.cli.utils import (
- print_dict, print_json, filter_dicts_by_dict, pager)
+from kamaki.cli.utils import filter_dicts_by_dict
from kamaki.clients.image import ImageClient
from kamaki.clients.pithos import PithosClient
from kamaki.clients.astakos import AstakosClient
meta = self.client.get_meta(image_id)
if not self['json_output']:
meta['owner'] += ' (%s)' % self._uuid2username(meta['owner'])
- self._print(meta, print_dict)
+ self._print(meta, self.print_dict)
def main(self, image_id):
super(self.__class__, self)._run()
img_path, dst_cont)] + howto_image_file)
raise
r['owner'] += ' (%s)' % self._uuid2username(r['owner'])
- self._print(r, print_dict)
+ self._print(r, self.print_dict)
#upload the metadata file
if pclient:
'Failed to dump metafile %s:%s' % (dst_cont, meta_path))
return
if self['json_output']:
- print_json(dict(
+ self.print_json(dict(
metafile_location='%s:%s' % (dst_cont, meta_path),
headers=meta_headers))
else:
usernames = self._uuids2usernames(uuids)
image['user_id'] += ' (%s)' % usernames[image['user_id']]
image['tenant_id'] += ' (%s)' % usernames[image['tenant_id']]
- self._print(image, print_dict)
+ self._print(image, self.print_dict)
def main(self, image_id):
super(self.__class__, self)._run()
@errors.cyclades.connection
@errors.plankton.id
def _run(self, image_id):
- self._print(self.client.get_image_metadata(image_id), print_dict)
+ self._print(self.client.get_image_metadata(image_id), self.print_dict)
def main(self, image_id):
super(self.__class__, self)._run()
@errors.plankton.id
@errors.plankton.metadata
def _run(self, image_id, key):
- self._print(self.client.get_image_metadata(image_id, key), print_dict)
+ self._print(
+ self.client.get_image_metadata(image_id, key), self.print_dict)
def main(self, image_id, key):
super(self.__class__, self)._run()
key, sep, val = keyval.partition('=')
meta[key] = val
self._print(
- self.client.update_image_metadata(image_id, **meta), print_dict)
+ self.client.update_image_metadata(image_id, **meta),
+ self.print_dict)
def main(self, image_id, *key_equals_value):
super(self.__class__, self)._run()
from time import localtime, strftime
from os import path, makedirs, walk
from io import StringIO
+from pydoc import pager
from kamaki.cli import command
from kamaki.cli.command_tree import CommandTree
from kamaki.cli.errors import raiseCLIError, CLISyntaxError, CLIBaseUrlError
from kamaki.cli.utils import (
- format_size, to_bytes, print_dict, print_items, pager, bold, ask_user,
- get_path_size, guess_mime_type)
+ format_size, to_bytes, bold, get_path_size, guess_mime_type)
from kamaki.cli.argument import FlagArgument, ValueArgument, IntArgument
from kamaki.cli.argument import KeyValueArgument, DateArgument
from kamaki.cli.argument import ProgressBarArgument
'%s%s. ' % (empty_space, index)) if self['enum'] else ''
if self['detail']:
self.writeln('%s%s' % (prfx, oname))
- print_dict(pretty_obj, exclude=('name'), out=self._out)
+ self.print_dict(pretty_obj, exclude=('name'))
self.writeln()
else:
oname = '%s%9s %s' % (prfx, size, oname)
pretty_c = container.copy()
if 'bytes' in container:
pretty_c['bytes'] = '%s (%s)' % (container['bytes'], size)
- print_dict(pretty_c, exclude=('name'), out=self._out)
+ self.print_dict(pretty_c, exclude=('name'))
self.writeln()
else:
if 'count' in container and 'bytes' in container:
if_match=self['if_match'],
if_none_match=self['if_none_match'],
if_modified_since=self['if_modified_since'],
- if_unmodified_since=self['if_unmodified_since']), print_dict)
+ if_unmodified_since=self['if_unmodified_since']), self.print_dict)
def main(self, container___path):
super(self.__class__, self)._run(
@errors.pithos.object_path
def _run(self):
if self.path:
- if self['yes'] or ask_user(
- 'Delete %s:%s ?' % (self.container, self.path),
- out=self._out, user_in=self._in):
+ if self['yes'] or self.ask_user(
+ 'Delete %s:%s ?' % (self.container, self.path)):
self._optional_output(self.client.del_object(
self.path,
until=self['until'],
ask_msg = 'Delete container contents'
else:
ask_msg = 'Delete container'
- if self['yes'] or ask_user(
- '%s %s ?' % (ask_msg, self.container),
- out=self._out, user_in=self._in):
+ if self['yes'] or self.ask_user(
+ '%s %s ?' % (ask_msg, self.container)):
self._optional_output(self.client.del_container(
until=self['until'],
delimiter='/' if self['recursive'] else self['delimiter']))
@errors.pithos.connection
@errors.pithos.container
def _run(self):
- if self['yes'] or ask_user(
- 'Purge container %s?' % self.container,
- out=self._out, user_in=self._in):
+ if self['yes'] or self.ask_user(
+ 'Purge container %s?' % self.container):
try:
r = self.client.purge_container()
except ClientError as ce:
"""
-def print_permissions(permissions_dict, out):
- expected_keys = ('read', 'write')
- if set(permissions_dict).issubset(expected_keys):
- print_dict(permissions_dict, out=out)
- else:
- invalid_keys = set(permissions_dict.keys()).difference(expected_keys)
- raiseCLIError(
- 'Illegal permission keys: %s' % ', '.join(invalid_keys),
- importance=1, details=[
- 'Valid permission types: %s' % ' '.join(expected_keys)])
-
-
@command(pithos_cmds)
class file_permissions_get(_file_container_command, _optional_json):
"""Get read and write permissions of an object"""
+ def print_permissions(self, permissions_dict, out):
+ expected_keys = ('read', 'write')
+ if set(permissions_dict).issubset(expected_keys):
+ self.print_dict(permissions_dict, out)
+ else:
+ invalid_keys = set(permissions_dict.keys()).difference(
+ expected_keys)
+ raiseCLIError(
+ 'Illegal permission keys: %s' % ', '.join(invalid_keys),
+ importance=1, details=[
+ 'Valid permission types: %s' % ' '.join(expected_keys)])
+
@errors.generic.all
@errors.pithos.connection
@errors.pithos.container
@errors.pithos.object_path
def _run(self):
self._print(
- self.client.get_object_sharing(self.path), print_permissions)
+ self.client.get_object_sharing(self.path), self.print_permissions)
def main(self, container___path):
super(self.__class__, self)._run(
else:
r = self.client.get_object_info(
self.path, version=self['object_version'])
- self._print(r, print_dict)
+ self._print(r, self.print_dict)
def main(self, container____path__=None):
super(self.__class__, self)._run(container____path__)
self.path,
version=self['object_version'])
if r:
- self._print(r, print_dict)
+ self._print(r, self.print_dict)
def main(self, container____path__=None):
super(self.__class__, self)._run(container____path__)
if not self['in_bytes']:
for k in output:
output[k] = format_size(output[k])
- print_dict(output, '-', out=self._out)
+ self.print_dict(output, '-')
self._print(
self.client.get_account_quota(), pretty_print, out=self._out)
if not self['in_bytes']:
for k, v in output.items():
output[k] = 'unlimited' if '0' == v else format_size(v)
- print_dict(output, '-')
+ self.print_dict(output, '-')
self._print(
self.client.get_container_limit(self.container), pretty_print)
@errors.pithos.container
def _run(self):
self._print(
- self.client.get_container_versioning(self.container), print_dict)
+ self.client.get_container_versioning(self.container),
+ self.print_dict)
def main(self, container):
super(self.__class__, self)._run()
@errors.generic.all
@errors.pithos.connection
def _run(self):
- self._print(self.client.get_account_group(), print_dict, delim='-')
+ self._print(
+ self.client.get_account_group(), self.print_dict, delim='-')
def main(self):
super(self.__class__, self)._run()
self._run()
-def version_print(versions, out):
- print_items(
- [dict(id=vitem[0], created=strftime(
- '%d-%m-%Y %H:%M:%S',
- localtime(float(vitem[1])))) for vitem in versions],
- out=out)
-
-
@command(pithos_cmds)
class file_versions(_file_container_command, _optional_json):
"""Get the list of object versions
/file info -h
"""
+ def version_print(self, versions, out):
+ self.print_items(
+ [dict(id=vitem[0], created=strftime(
+ '%d-%m-%Y %H:%M:%S',
+ localtime(float(vitem[1])))) for vitem in versions],
+ out=out)
+
@errors.generic.all
@errors.pithos.connection
@errors.pithos.container
@errors.pithos.object_path
def _run(self):
self._print(
- self.client.get_object_versionlist(self.path), version_print)
+ self.client.get_object_versionlist(self.path), self.version_print)
def main(self, container___path):
super(file_versions, self)._run(
from kamaki.cli.commands import (
_command_init, errors, _optional_json, addLogSettings)
from kamaki.cli.command_tree import CommandTree
-from kamaki.cli.utils import print_dict, format_size
+from kamaki.cli.utils import format_size
from kamaki.cli.argument import FlagArgument, ValueArgument, IntArgument
from kamaki.cli.argument import CommaSeparatedListArgument
from kamaki.cli.logger import get_logger
@astakoserror
def _run(self):
self._print(
- self.client.get_user_info(self.token, self['usage']), print_dict)
+ self.client.get_user_info(self.token, self['usage']),
+ self.print_dict)
def main(self):
super(self.__class__, self)._run()
self._print(self.client.get_username(self.token, uuids[0]))
else:
self._print(
- self.client.get_usernames(self.token, uuids), print_dict)
+ self.client.get_usernames(self.token, uuids), self.print_dict)
def main(self, uuid, *more_uuids):
super(self.__class__, self)._run()
self._print(self.client.get_uuid(self.token, usernames[0]))
else:
self._print(
- self.client.get_uuids(self.token, usernames), print_dict)
+ self.client.get_uuids(self.token, usernames), self.print_dict)
def main(self, usernames, *more_usernames):
super(self.__class__, self)._run()
class astakos_quotas(_astakos_init, _optional_json):
"""Get user (or service) quotas"""
- @staticmethod
- def _print_with_format(d):
+ def _print_with_format(self, d, out):
""" Print d with size formating when needed
:param d: (dict) {system: {<service>: {usage: ..., limit: ..., }, ...}}
"""
for term in ('usage', 'limit'):
if term in service:
newd[k][term] = format_size(service[term])
- print_dict(newd)
+ self.print_dict(newd, out=out)
@errors.generic.all
@astakoserror
self._print(self.client.service_get_username(stoken, uuids[0]))
else:
self._print(
- self.client.service_get_usernames(stoken, uuids), print_dict)
+ self.client.service_get_usernames(stoken, uuids),
+ self.print_dict)
def main(self, service_token, uuid, *more_uuids):
super(self.__class__, self)._run()
else:
self._print(
self.client.service_get_uuids(self.token, usernames),
- print_dict)
+ self.print_dict)
def main(self, service_token, usernames, *more_usernames):
super(self.__class__, self)._run()
@errors.generic.all
@astakoserror
def _run(self):
- self._print(self.client.get_resources(), print_dict)
+ self._print(self.client.get_resources(), self.print_dict)
def main(self):
super(self.__class__, self)._run()
def _run(self):
self._print(
self.client.get_endpoints(self.token, self['uuid']),
- print_dict)
+ self.print_dict)
def main(self):
super(self.__class__, self)._run()
commission_id = int(commission_id)
self._print(
self.client.get_commission_info(self.token, commission_id),
- print_dict)
+ self.print_dict)
def main(self, commission_id):
super(self.__class__, self)._run()
' or '.join(self.actions))
self._print(
self.client.commission_acction(self.token, commission_id, action),
- print_dict)
+ self.print_dict)
def main(self, commission_id, action):
super(self.__class__, self)._run()
self._print(
self.client.resolve_commissions(
self.token, self['accept'], self['reject']),
- print_dict)
+ self.print_dict)
def main(self):
super(self.__class__, self)._run()
@astakoserror
def _run(self, project_id):
self._print(
- self.client.get_project(self.token, project_id), print_dict)
+ self.client.get_project(self.token, project_id), self.print_dict)
def main(self, project_id):
super(self.__class__, self)._run()
input_stream = open(abspath(self['specs_path'])) if (
self['specs_path']) else stdin
specs = load(input_stream)
- self._print(self.client.create_project(self.token, specs), print_dict)
+ self._print(
+ self.client.create_project(self.token, specs), self.print_dict)
def main(self):
super(self.__class__, self)._run()
specs = load(input_stream)
self._print(
self.client.modify_project(self.token, project_id, specs),
- print_dict)
+ self.print_dict)
def main(self, project_id):
super(self.__class__, self)._run()
@astakoserror
def _run(self, app_id):
self._print(
- self.client.get_application(self.token, app_id), print_dict)
+ self.client.get_application(self.token, app_id), self.print_dict)
def main(self, application_id):
super(self.__class__, self)._run()
@errors.generic.all
@astakoserror
def _run(self, memb_id):
- self._print(self.client.get_membership(self.token, memb_id),
- print_dict)
+ self._print(
+ self.client.get_membership(self.token, memb_id), self.print_dict)
def main(self, membership_id):
super(self.__class__, self)._run()