def create_argument_table(self, arguments):
if not arguments:
return OrderedDict()
argument_table = OrderedDict()
for arg in arguments:
if isinstance(arg, BaseCLIArgument):
argument_table[arg.name] = arg
else:
argument_table[arg] = BaseCLIArgument(arg)
return argument_table
def create_command_table(self, clidriver, commands, command_creator):
if not commands:
return OrderedDict()
command_table = OrderedDict()
for name, command in commands.items():
if isinstance(command, CLICommand):
# Already a valid command, no need to fake one
command_table[name] = command
else:
command_table[name] = command_creator(clidriver, name, command)
return command_table
def _get_signature_header(self, signature):
auth_params = OrderedDict()
auth_params['access_key_id'] = self.credentials.access_key_id
auth_params['auth_method'] = self.auth_method
encoded_auth_params = json.dumps(auth_params).encode('utf-8')
return "%s.%s" % (urlsafe_b64encode(
encoded_auth_params).strip().decode('utf-8'), signature)
def _build_command_table(self):
commands = OrderedDict()
services = self._get_available_services()
for service_name in services:
commands[service_name] = ServiceCommand(self, service_name)
ConfigureCommand.add_command(commands)
return commands
def _generate_type_map(self, shape):
key_shape = shape.key
value_shape = shape.value
assert key_shape.type_name == 'string'
return OrderedDict([
('KeyName', self.generate_skeleton(value_shape)),
])
def _build_subcommand_table(self):
subcommand_table = OrderedDict()
for subcommand in self.SUBCOMMANDS:
subcommand_name = subcommand['name']
subcommand_class = subcommand['command_class']
subcommand_table[subcommand_name] = subcommand_class()
self._add_lineage(subcommand_table)
return subcommand_table
def _build_argument_table(self):
argument_table = OrderedDict()
cli_data = self._get_cli_data()
cli_arguments = cli_data.get('options', None)
for option in cli_arguments:
option_params = copy_kwargs(cli_arguments[option])
cli_argument = self._create_cli_argument(option, option_params)
cli_argument.add_to_arg_table(argument_table)
return argument_table
def create_help_command(self):
command_table = OrderedDict()
for command_name, command in self._get_command_table().items():
command_table[command_name] = command
return ServiceHelpCommand(obj=self._get_service_model(),
command_table=command_table,
arg_table=None,
command_lineage='.'.join(self.lineage_names),
name=self._name)
def serialize_to_request(self, parameters, operation_model):
# Don't serialize any parameter with a None value.
filtered_parameters = OrderedDict(
(k, v) for k, v in parameters.items() if v is not None)
serialized = {}
serialized['method'] = operation_model.http['method']
serialized['headers'] = {'Content-Type': 'application/json'}
serialized['url_path'] = operation_model.http['requestUri']
serialized_body = OrderedDict()
if len(filtered_parameters) != 0:
self._serialize(serialized_body, filtered_parameters,
operation_model.input_shape)
serialized['body'] = json.dumps(serialized_body).encode(
self.DEFAULT_ENCODING)
return serialized
def _build_object(self, model, shapes):
members = OrderedDict()
shape = self._build_initial_shape(model)
shape['properties'] = members
for name, member_model in model['properties'].items():
member_shape_name = self._get_shape_name(member_model)
members[name] = {REF_KEY: REF_NAME_PREFIX + member_shape_name}
self._build_model(member_model, shapes, member_shape_name)
return shape
def build_model(self):
shapes = OrderedDict()
denormalized = {
'type': OBJECT_TYPE,
'properties': self._members,
}
self._build_model(denormalized, shapes, self.name)
resolver = ShapeResolver(shapes)
return ObjectShape(name=self.name,
shape_data=shapes[self.name],
shape_resolver=resolver)
def _serialize_type_object(self, serialized, value, shape, key):
if key is not None:
# If a key is provided, this is a result of a recursive call, so we
# need to add a new child dict as the value of the passed in dict.
# Below we will add all the structure members to the new serialized
# dictionary we just created.
serialized[key] = OrderedDict()
serialized = serialized[key]
for member_key, member_value in value.items():
member_shape = shape.members[member_key]
self._serialize(serialized, member_value, member_shape, member_key)
def _create_help_command(self):
cli_data = self._get_cli_data()
# We filter service aliases out of the service list at the bottom of the
# top level help.
commands = OrderedDict()
for service_name, command in self._get_command_table().items():
if not self._loader.is_service_alias(service_name):
commands[service_name] = command
return ProviderHelpCommand(commands, self._get_argument_table(),
cli_data.get('description', None),
cli_data.get('synopsis', None),
cli_data.get('help_usage', None))
def _build_arg_table(self):
arg_table = OrderedDict()
argument_model = None
for arg_data in self.ARG_TABLE:
# If a custom schema was passed in, create the argument_model
# so that it can be validated and docs can be generated.
if 'schema' in arg_data:
argument_model = create_argument_model_from_schema(
arg_data.pop('schema'))
arg_data['argument_model'] = argument_model
custom_argument = CustomArgument(**arg_data)
arg_table[arg_data['name']] = custom_argument
if argument_model:
add_cli_input_json(argument_model, arg_table)
add_generate_skeleton(argument_model, arg_table)
self.argument_model = argument_model
return arg_table
def _create_argument_table(self):
argument_table = OrderedDict()
input_shape = self._operation_model.input_shape
required_arguments = []
arg_dict = {}
if input_shape is not None:
required_arguments = input_shape.required_members
arg_dict = input_shape.members
for arg_name, arg_shape in arg_dict.items():
cli_arg_name = xform_name(arg_name, '-')
arg_class = self.ARG_TYPES.get(arg_shape.type_name,
self.DEFAULT_ARG_CLASS)
is_required = arg_name in required_arguments
arg_object = arg_class(name=cli_arg_name,
argument_model=arg_shape,
is_required=is_required,
operation_model=self._operation_model,
serialized_name=arg_name,
no_paramfile=arg_shape.is_no_paramfile)
arg_object.add_to_arg_table(argument_table)
add_pagination_params(self._operation_model, argument_table)
add_cli_input_json(self._operation_model, argument_table)
add_generate_skeleton(self._operation_model, argument_table)
return argument_table
def _create_command_table(self):
command_table = OrderedDict()
service_model = self._get_service_model()
for operation_name in service_model.operation_names:
cli_name = xform_name(operation_name, '-')
operation_model = service_model.operation_model(operation_name)
command_table[cli_name] = ServiceOperation(
name=cli_name,
parent_name=self._name,
operation_model=operation_model,
operation_caller=CLIOperationCaller())
try:
__import__('cdpcli.extensions.%s.register' % self._name,
fromlist=['register']).register(command_table)
except ImportError as err:
py3_err = "No module named 'cdpcli.extensions.%s'" % self._name
py2_err = "No module named %s.register" % self._name
if py2_err not in str(err) and py3_err not in str(err):
# Looks like a different error than missing extensions.
LOG.warn("Failed to import service (%s) extension: %s",
self._name, err)
pass
self._add_lineage(command_table)
return command_table
def construct_mapping(loader, node):
loader.flatten_mapping(node)
return OrderedDict(loader.construct_pairs(node))
def _generate_type_object(self, shape):
skeleton = OrderedDict()
for member_name, member_shape in shape.members.items():
skeleton[member_name] = self.generate_skeleton(member_shape)
return skeleton
def members(self):
members = OrderedDict()
for name, shape_data in self._shape_data.get('properties', {}).items():
members[name] = self._get_shape(name, shape_data)
return members
def __init__(self, name=None):
self.members = OrderedDict()
self._name_generator = ShapeNameGenerator()
if name is None:
self.name = self._name_generator.new_shape_name('object')
