def read_file(cls, path):
if not os.path.exists(path):
raise error.InvalidFileException(
"File '{0}' doesn't exist.".format(path))
serializer = Serializer()
return serializer.read_from_full_path(path)
def read_data_from_dir(cls, dir_path=None, serializer=None):
"""Read graph data from directory.
:param dir_path: path
:type dir_path: str
:param serializer: serializer object
:type serializer: object
:return: data
:rtype: list|object
"""
cls.check_dir(dir_path)
serializer = serializer or Serializer()
metadata_filepath = os.path.join(dir_path, 'metadata.yaml')
if os.path.exists(metadata_filepath):
data = serializer.read_from_full_path(metadata_filepath)
else:
data = {}
tasks = []
for file_name in iterfiles(dir_path, 'tasks.yaml'):
task_data = serializer.read_from_full_path(file_name)
if task_data:
tasks.extend(task_data)
if tasks:
data['tasks'] = tasks
if not data:
msg = ("Nothing to upload. Check if at least one 'tasks.yaml' "
"file is not empty and exists in '{path}' directory "
"path".format(path=dir_path))
raise error.ActionException(msg)
return data
def write_info_to_file(cls,
info_type,
data,
transaction_id,
serializer=None,
file_path=None):
"""Write additional info to the given path.
:param info_type: deployment_info | cluster_settings |
network_configuration
:type info_type: str
:param data: data
:type data: list of dict
:param serializer: serializer
:param transaction_id: Transaction ID
:type transaction_id: str or int
:param file_path: path
:type file_path: str
:return: path to resulting file
:rtype: str
"""
serializer = serializer or Serializer()
if file_path:
return serializer.write_to_full_path(file_path, data)
else:
return serializer.write_to_path(
cls.get_default_info_path(info_type, transaction_id), data)
def test_write_to_path_invalid_file_exception(self):
serializer = Serializer('json')
mo = mock.mock_open()
with mock.patch('__main__.open', mo, create=True) as mocked_open:
mocked_open.side_effect = IOError()
self.assertRaises(error.InvalidFileException,
serializer.write_to_path, '/foo/bar/baz',
self.DATA)
def test_get_from_params(self):
params_to_formats = (
('yaml', 'yaml'),
('json', 'json'),
('xyz', Serializer.default_format),
)
for param, format in params_to_formats:
params = mock.Mock(serialization_format=format)
serializer = Serializer.from_params(params)
self.assertEqual(serializer.format, format)
def test_get_from_params(self):
params_to_formats = (
('yaml', 'yaml'),
('json', 'json'),
('xyz', Serializer.default_format),
)
for param, format in params_to_formats:
params = mock.Mock(serialization_format=format)
serializer = Serializer.from_params(params)
self.assertEqual(serializer.format, format)
def action_func(self, params):
"""Entry point for all actions subclasses
"""
APIClient.debug_mode(debug=params.debug)
self.serializer = Serializer.from_params(params)
if self.flag_func_map is not None:
for flag, method in self.flag_func_map:
if flag is None or getattr(params, flag):
method(params)
break
def action_func(self, params):
"""Entry point for all actions subclasses
"""
APIClient.debug_mode(debug=params.debug)
self.serializer = Serializer.from_params(params)
if self.flag_func_map is not None:
for flag, method in self.flag_func_map:
if flag is None or getattr(params, flag):
method(params)
break
def get_args_for_update(params, serializer=None):
result = {}
for attr in _updatable_keys:
value = getattr(params, attr, None)
if value is not None:
result[attr] = value
if 'meta' in result:
serializer = serializer or Serializer.from_params(params)
result['meta'] = serializer.deserialize(result['meta'])
return result
def get_args_for_update(params, serializer=None):
result = {}
for attr in _updatable_keys:
value = getattr(params, attr, None)
if value is not None:
result[attr] = value
if 'meta' in result:
serializer = serializer or Serializer.from_params(params)
result['meta'] = serializer.deserialize(result['meta'])
return result
def write_tasks_to_file(cls, tasks_data, serializer=None, file_path=None):
serializer = serializer or Serializer()
if file_path:
return serializer.write_to_full_path(
file_path,
tasks_data
)
else:
return serializer.write_to_path(
cls.get_default_tasks_data_path(),
tasks_data
)
def read_tasks_data_from_file(cls, file_path=None, serializer=None):
"""Read Tasks data from given path.
:param file_path: path
:type file_path: str
:param serializer: serializer object
:type serializer: object
:return: data
:rtype: list|object
"""
cls.check_file_path(file_path)
return (serializer or Serializer()).read_from_full_path(file_path)
def download(env_id,
ip_addr_id=None,
network_id=None,
network_role=None,
file_path=None):
env = objects.Environment(env_id)
vips_data = env.get_vips_data(ip_address_id=ip_addr_id,
network=network_id,
network_role=network_role)
vips_data_file_path = env.write_vips_data_to_file(
vips_data, file_path=file_path, serializer=Serializer())
return vips_data_file_path
def take_action(self, parsed_args):
task = self.client.execute(env_id=parsed_args.env,
dry_run=parsed_args.dry_run,
noop_run=parsed_args.noop,
force=parsed_args.force,
debug=parsed_args.trace,
**self.get_options(parsed_args))
if parsed_args.format:
msg = Serializer(parsed_args.format).serialize(task.data) + '\n'
else:
msg = ('Deployment task with id {0} for the environment {1} '
'has been started.\n'.format(task.data['id'],
task.data['cluster']))
self.app.stdout.write(msg)
def action_func(self, params):
"""Entry point for all actions subclasses
"""
APIClient.debug_mode(debug=params.debug)
if getattr(params, 'user') and getattr(params, 'password'):
APIClient.user = params.user
APIClient.password = params.password
APIClient.initialize_keystone_client()
self.serializer = Serializer.from_params(params)
if self.flag_func_map is not None:
for flag, method in self.flag_func_map:
if flag is None or getattr(params, flag):
method(params)
break
def action_func(self, params):
"""Entry point for all actions subclasses
"""
APIClient.debug_mode(debug=params.debug)
if getattr(params, 'user') and getattr(params, 'password'):
APIClient.user = params.user
APIClient.password = params.password
APIClient.initialize_keystone_client()
self.serializer = Serializer.from_params(params)
if self.flag_func_map is not None:
for flag, method in self.flag_func_map:
if flag is None or getattr(params, flag):
method(params)
break
def take_action(self, parsed_args):
meta = None
if parsed_args.meta:
serializer = Serializer.from_params(parsed_args)
meta = serializer.deserialize(parsed_args.meta)
net_group = self.client.create(name=parsed_args.name,
release=parsed_args.release,
vlan=parsed_args.vlan,
cidr=parsed_args.cidr,
gateway=parsed_args.gateway,
group_id=parsed_args.node_group,
meta=meta)
net_group = data_utils.get_display_data_single(self.columns, net_group)
return self.columns, net_group
def take_action(self, parsed_args):
meta = None
if parsed_args.meta:
serializer = Serializer.from_params(parsed_args)
meta = serializer.deserialize(parsed_args.meta)
net_group = self.client.create(
name=parsed_args.name,
release=parsed_args.release,
vlan=parsed_args.vlan,
cidr=parsed_args.cidr,
gateway=parsed_args.gateway,
group_id=parsed_args.node_group,
meta=meta)
net_group = data_utils.get_display_data_single(self.columns, net_group)
return self.columns, net_group
def action_func(self, params):
"""Entry point for all actions subclasses
"""
APIClient.debug_mode(debug=params.debug)
if getattr(params, "user") and getattr(params, "password"):
APIClient.user = params.user
APIClient.password = params.password
# tenant is set by default to 'admin' in parser.add_argument
APIClient.tenant = params.tenant
APIClient.initialize_keystone_client()
self.serializer = Serializer.from_params(params)
if self.flag_func_map is not None:
for flag, method in self.flag_func_map:
if flag is None or getattr(params, flag):
method(params)
break
def download_info_to_file(self, transaction_id, info_type, file_path):
"""Get and save to path for task additional info e.g. deployment info
:param transaction_id: Transaction ID
:type transaction_id: str or int
:param info_type: deployment_info | cluster_settings |
network_configuration
:type info_type: str
:param file_path: path
:type file_path: str
:return: path
:rtype: str
"""
data = self.client.download(transaction_id=transaction_id)
return self.write_info_to_file(info_type=info_type,
data=data,
transaction_id=transaction_id,
serializer=Serializer(),
file_path=file_path)
def take_action(self, args):
tasks_data = []
for tasks_level_name in ('all', 'cluster', 'release', 'plugins'):
if getattr(args, tasks_level_name):
tasks_data = self.client.download(
env_id=args.env,
level=tasks_level_name,
graph_type=args.type
)
break
# write to file
graph_data_file_path = self.write_tasks_to_file(
tasks_data=tasks_data,
serializer=Serializer(),
file_path=args.file)
self.app.stdout.write(
"Tasks were downloaded to {0}\n".format(graph_data_file_path)
)
def test_serialize(self):
deserializers = {'json': json.loads, 'yaml': yaml.load}
for format, deserialize in deserializers.items():
serialized = Serializer(format).serialize(self.DATA)
self.assertEqual(self.DATA, deserialize(serialized))
def write_file(cls, path, data):
serializer = Serializer()
return serializer.write_to_full_path(path, data)
def __init__(self, obj_id, **kwargs):
self.connection = DefaultAPIClient
self.serializer = Serializer.from_params(kwargs.get('params'))
self.id = obj_id
self._data = None
def __init__(self, obj_id, **kwargs):
self.connection = APIClient
self.serializer = Serializer.from_params(kwargs.get('params'))
self.id = obj_id
self._data = None
def test_deserialize_fail(self):
broken_data = '{foo: bar: buzz:}'
for format in ('json', 'yaml'):
self.assertRaises(error.BadDataException,
Serializer(format).deserialize, broken_data)
def __init__(self):
# Mapping of flags to methods
self.flag_func_map = None
self.serializer = Serializer()
def __init__(self, obj_id, **kwargs):
self.connection = APIClient
self.serializer = Serializer(**kwargs)
self.id = obj_id
self._data = None
def upload(env_id, file_path):
env = objects.Environment(env_id)
vips_data = env.read_vips_data_from_file(file_path=file_path,
serializer=Serializer())
env.set_vips_data(vips_data)
def test_deserialize(self):
serializers = {'json': json.dumps, 'yaml': yaml.safe_dump}
for format, serialize in serializers.items():
serialized = serialize(self.DATA)
deserialized = Serializer(format).deserialize(serialized)
self.assertEqual(self.DATA, deserialized)
def take_action(self, parsed_args):
version = self.client.get_all()
serializer = Serializer.from_params(parsed_args)
msg = serializer.serialize(version)
self.app.stdout.write(msg)
