def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
if parsed_args.plugin_version:
data = client.plugins.get_version_details(
parsed_args.plugin, parsed_args.plugin_version).to_dict()
processes = data.pop('node_processes')
for k, v in processes.items():
processes[k] = osc_utils.format_list(v)
data['required_image_tags'] = osc_utils.format_list(
data['required_image_tags'])
label_items = _serialize_label_items(data)
data = utils.prepare_data(
data, ['required_image_tags', 'name', 'description', 'title'])
data = self.dict2columns(data)
data = utils.extend_columns(data, label_items)
data = utils.extend_columns(
data, [('Service:', 'Available processes:')])
data = utils.extend_columns(
data, sorted(processes.items()))
else:
data = client.plugins.get(parsed_args.plugin).to_dict()
data['versions'] = osc_utils.format_list(data['versions'])
items = _serialize_label_items(data)
data = utils.prepare_data(
data, ['versions', 'name', 'description', 'title'])
data = utils.extend_columns(self.dict2columns(data), items)
return data
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
s3_credentials = {}
if parsed_args.access_key:
s3_credentials['accesskey'] = parsed_args.access_key
if parsed_args.secret_key:
s3_credentials['secretkey'] = parsed_args.secret_key
if parsed_args.s3_endpoint:
s3_credentials['endpoint'] = parsed_args.s3_endpoint
if parsed_args.enable_s3_ssl == parsed_args.disable_s3_ssl:
s3_credentials['ssl'] = parsed_args.enable_s3_ssl
if (parsed_args.enable_s3_bucket_in_path ==
parsed_args.disable_s3_bucket_in_path):
s3_credentials['bucket_in_path'] = (
parsed_args.enable_s3_bucket_in_path)
s3_credentials = s3_credentials or None
description = parsed_args.description or ''
data = client.data_sources.create(
name=parsed_args.name,
description=description,
data_source_type=parsed_args.type,
url=parsed_args.url,
credential_user=parsed_args.username,
credential_pass=parsed_args.password,
is_public=parsed_args.public,
is_protected=parsed_args.protected,
s3_credentials=s3_credentials).to_dict()
data = utils.prepare_data(data, DATA_SOURCE_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
data = self._take_action(client, parsed_args)
if parsed_args.count and parsed_args.count > 1:
clusters = [
utils.get_resource(client.clusters, id)
for id in data['clusters']]
if parsed_args.wait:
for cluster in clusters:
if not osc_utils.wait_for_status(
client.clusters.get, cluster.id):
self.log.error(
'Error occurred during cluster creation: %s',
data['id'])
data = {}
for cluster in clusters:
data[cluster.name] = cluster.id
else:
if parsed_args.wait:
if not osc_utils.wait_for_status(
client.clusters.get, data['id']):
self.log.error(
'Error occurred during cluster creation: %s',
data['id'])
data = client.clusters.get(data['id']).to_dict()
_format_cluster_output(self.app, data)
data = utils.prepare_data(data, CLUSTER_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
data = utils.get_resource(client.data_sources,
parsed_args.data_source).to_dict()
data = utils.prepare_data(data, DATA_SOURCE_FIELDS)
return self.dict2columns(data)
def test_prepare_data(self):
data = {'id': '123', 'name_of_res': 'name', 'description': 'descr'}
fields = ['id', 'name_of_res', 'description']
expected_data = {
'Description': 'descr',
'Id': '123',
'Name of res': 'name'
}
self.assertEqual(expected_data, utils.prepare_data(data, fields))
fields = ['id', 'name_of_res']
expected_data = {'Id': '123', 'Name of res': 'name'}
self.assertEqual(expected_data, utils.prepare_data(data, fields))
fields = ['name_of_res']
expected_data = {'Name of res': 'name'}
self.assertEqual(expected_data, utils.prepare_data(data, fields))
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
data = client.jobs.get(parsed_args.job).to_dict()
_format_job_output(self.app, data)
data = utils.prepare_data(data, jobs_v1.JOB_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
data = utils.get_resource(client.images, parsed_args.image).to_dict()
data['tags'] = osc_utils.format_list(data['tags'])
data = utils.prepare_data(data, IMAGE_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
data = utils.get_job_templates_resources(self.app, client, parsed_args)
_format_job_template_output(data)
data = utils.prepare_data(data, JOB_TEMPLATE_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
data = self._import_take_action(client, parsed_args)
_format_ngt_output(data)
data = utils.prepare_data(data, NGT_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
data = client.job_executions.get(parsed_args.job).to_dict()
_format_job_output(self.app, data)
data = utils.prepare_data(data, JOB_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
data = utils.get_resource(client.job_binaries,
parsed_args.job_binary).to_dict()
data = utils.prepare_data(data, JOB_BINARY_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
data = self._take_action(client, parsed_args)
_format_cluster_output(self.app, data)
data = utils.prepare_data(data, CLUSTER_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
data = utils.get_resource(
client.job_binaries, parsed_args.job_binary).to_dict()
data = utils.prepare_data(data, JOB_BINARY_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
data = self._take_action(client, parsed_args)
_format_ct_output(self.app, data)
data = utils.prepare_data(data, CT_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
data = utils.get_resource(
client.images, parsed_args.image).to_dict()
data['tags'] = osc_utils.format_list(data['tags'])
data = utils.prepare_data(data, IMAGE_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
data = utils.get_resource(client.cluster_templates,
parsed_args.cluster_template).to_dict()
_format_ct_output(self.app, data)
data = utils.prepare_data(data, CT_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
data = utils.get_resource(
client.cluster_templates, parsed_args.cluster_template).to_dict()
_format_ct_output(self.app, data)
data = utils.prepare_data(data, CT_FIELDS)
return self.dict2columns(data)
def _serialize_label_items(plugin):
labels = {}
pl_labels = plugin.get('plugin_labels', {})
for label, data in pl_labels.items():
labels['plugin: %s' % label] = data['status']
vr_labels = plugin.get('version_labels', {})
for version, version_data in vr_labels.items():
for label, data in version_data.items():
labels[
'plugin version %s: %s' % (version, label)] = data['status']
labels = utils.prepare_data(labels, list(labels.keys()))
return sorted(labels.items())
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
jb_id = utils.get_resource_id(
client.job_binaries, parsed_args.job_binary)
if parsed_args.json:
blob = osc_utils.read_blob_file_contents(parsed_args.json)
try:
template = jsonutils.loads(blob)
except ValueError as e:
raise exceptions.CommandError(
'An error occurred when reading '
'template from file %s: %s' % (parsed_args.json, e))
data = client.job_binaries.update(jb_id, template).to_dict()
else:
if parsed_args.password_prompt:
parsed_args.password = osc_utils.get_password(
self.app.stdin, confirm=False)
if parsed_args.secret_key_prompt:
parsed_args.secret_key = osc_utils.get_password(
self.app.stdin, confirm=False)
extra = {}
if parsed_args.password:
extra['password'] = parsed_args.password
if parsed_args.username:
extra['user'] = parsed_args.username
if parsed_args.access_key:
extra['accesskey'] = parsed_args.access_key
if parsed_args.secret_key:
extra['secretkey'] = parsed_args.secret_key
if parsed_args.s3_endpoint:
extra['endpoint'] = parsed_args.s3_endpoint
if not extra:
extra = None
update_fields = utils.create_dict_from_kwargs(
name=parsed_args.name, url=parsed_args.url,
description=parsed_args.description,
extra=extra, is_public=parsed_args.is_public,
is_protected=parsed_args.is_protected
)
data = client.job_binaries.update(
jb_id, update_fields).to_dict()
data = utils.prepare_data(data, JOB_BINARY_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
jb_id = utils.get_resource_id(client.job_binaries,
parsed_args.job_binary)
if parsed_args.json:
blob = osc_utils.read_blob_file_contents(parsed_args.json)
try:
template = jsonutils.loads(blob)
except ValueError as e:
raise exceptions.CommandError('An error occurred when reading '
'template from file %s: %s' %
(parsed_args.json, e))
data = client.job_binaries.update(jb_id, template).to_dict()
else:
if parsed_args.password_prompt:
parsed_args.password = osc_utils.get_password(self.app.stdin,
confirm=False)
if parsed_args.secret_key_prompt:
parsed_args.secret_key = osc_utils.get_password(self.app.stdin,
confirm=False)
extra = {}
if parsed_args.password:
extra['password'] = parsed_args.password
if parsed_args.username:
extra['user'] = parsed_args.username
if parsed_args.access_key:
extra['accesskey'] = parsed_args.access_key
if parsed_args.secret_key:
extra['secretkey'] = parsed_args.secret_key
if parsed_args.s3_endpoint:
extra['endpoint'] = parsed_args.s3_endpoint
if not extra:
extra = None
update_fields = utils.create_dict_from_kwargs(
name=parsed_args.name,
url=parsed_args.url,
description=parsed_args.description,
extra=extra,
is_public=parsed_args.is_public,
is_protected=parsed_args.is_protected)
data = client.job_binaries.update(jb_id, update_fields).to_dict()
data = utils.prepare_data(data, JOB_BINARY_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
image_client = self.app.client_manager.image
image_id = osc_utils.find_resource(
image_client.images, parsed_args.image).id
data = client.images.update_image(
image_id, user_name=parsed_args.username,
desc=parsed_args.description).image
data['tags'] = osc_utils.format_list(data['tags'])
data = utils.prepare_data(data, IMAGE_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
image_client = self.app.client_manager.image
image_id = osc_utils.find_resource(image_client.images,
parsed_args.image).id
data = client.images.update_image(image_id,
user_name=parsed_args.username,
desc=parsed_args.description).image
data['tags'] = osc_utils.format_list(data['tags'])
data = utils.prepare_data(data, IMAGE_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
image = utils.get_resource(client.images, parsed_args.image)
if parsed_args.all:
data = client.images.update_tags(image.id, []).to_dict()
else:
parsed_args.tags = parsed_args.tags or []
new_tags = list(set(image.tags) - set(parsed_args.tags))
data = client.images.update_tags(image.id, new_tags).to_dict()
data['tags'] = osc_utils.format_list(data['tags'])
data = utils.prepare_data(data, IMAGE_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
image = utils.get_resource(client.images, parsed_args.image)
if parsed_args.all:
data = client.images.update_tags(image.id, []).to_dict()
else:
parsed_args.tags = parsed_args.tags or []
new_tags = list(set(image.tags) - set(parsed_args.tags))
data = client.images.update_tags(image.id, new_tags).to_dict()
data['tags'] = osc_utils.format_list(data['tags'])
data = utils.prepare_data(data, IMAGE_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
jt_id = utils.get_job_template_id(self.app, client, parsed_args)
update_data = utils.create_dict_from_kwargs(
name=parsed_args.name,
description=parsed_args.description,
is_public=parsed_args.is_public,
is_protected=parsed_args.is_protected
)
data = utils.update_job_templates(self.app, client, jt_id, update_data)
_format_job_template_output(data)
data = utils.prepare_data(data, JOB_TEMPLATE_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
blob = osc_utils.read_blob_file_contents(parsed_args.json)
try:
update_dict = jsonutils.loads(blob)
except ValueError as e:
raise exceptions.CommandError(
'An error occurred when reading '
'update dict from file %s: %s' % (parsed_args.json, e))
plugin = client.plugins.update(parsed_args.plugin, update_dict)
data = plugin.to_dict()
data['versions'] = osc_utils.format_list(data['versions'])
items = _serialize_label_items(data)
data = utils.prepare_data(
data, ['versions', 'name', 'description', 'title'])
data = utils.extend_columns(self.dict2columns(data), items)
return data
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
credentials = {}
if parsed_args.type == 'swift':
if parsed_args.username:
credentials['user'] = parsed_args.username
if parsed_args.password:
credentials['password'] = parsed_args.password
elif parsed_args.type == 's3':
if parsed_args.access_key:
credentials['accesskey'] = parsed_args.access_key
if parsed_args.secret_key:
credentials['secretkey'] = parsed_args.secret_key
if parsed_args.s3_endpoint:
credentials['endpoint'] = parsed_args.s3_endpoint
if parsed_args.enable_s3_ssl == parsed_args.disable_s3_ssl:
credentials['ssl'] = parsed_args.enable_s3_ssl
if (parsed_args.enable_s3_bucket_in_path ==
parsed_args.disable_s3_bucket_in_path):
credentials['bucket_in_path'] = (
parsed_args.enable_s3_bucket_in_path)
if not credentials:
credentials = None
update_fields = utils.create_dict_from_kwargs(
name=parsed_args.name,
description=parsed_args.description,
type=parsed_args.type,
url=parsed_args.url,
credentials=credentials,
is_public=parsed_args.is_public,
is_protected=parsed_args.is_protected)
ds_id = utils.get_resource_id(client.data_sources,
parsed_args.data_source)
data = client.data_sources.update(ds_id, update_fields).data_source
data = utils.prepare_data(data, DATA_SOURCE_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
if parsed_args.show:
data = utils.get_resource(client.clusters,
parsed_args.cluster).to_dict()
ver_data, ver_fields = _prepare_health_checks(data)
data = utils.prepare_data(ver_data, ver_fields)
return self.dict2columns(data)
else:
cluster_id = utils.get_resource_id(client.clusters,
parsed_args.cluster)
client.clusters.verification_update(cluster_id, parsed_args.status)
if parsed_args.status == 'START':
print_status = 'started'
sys.stdout.write(
'Cluster "{cluster}" health verification has been '
'{status}.\n'.format(cluster=parsed_args.cluster,
status=print_status))
return {}, {}
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
if parsed_args.show:
data = utils.get_resource(
client.clusters, parsed_args.cluster).to_dict()
ver_data, ver_fields = _prepare_health_checks(data)
data = utils.prepare_data(ver_data, ver_fields)
return self.dict2columns(data)
else:
cluster_id = utils.get_resource_id(
client.clusters, parsed_args.cluster)
client.clusters.verification_update(
cluster_id, parsed_args.status)
if parsed_args.status == 'START':
print_status = 'started'
sys.stdout.write(
'Cluster "{cluster}" health verification has been '
'{status}.\n'.format(cluster=parsed_args.cluster,
status=print_status))
return {}, {}
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
data = self._take_action(client, parsed_args)
if parsed_args.count and parsed_args.count > 1:
clusters = []
for cluster in data['clusters']:
clusters.append(
utils.get_resource(client.clusters,
cluster['cluster']['id']))
if parsed_args.wait:
for cluster in clusters:
if not osc_utils.wait_for_status(client.clusters.get,
cluster.id):
self.log.error(
'Error occurred during cluster creation: %s',
data['id'])
data = {}
for cluster in clusters:
data[cluster.name] = cluster.id
else:
if parsed_args.wait:
if not osc_utils.wait_for_status(client.clusters.get,
data['id']):
self.log.error(
'Error occurred during cluster creation: %s',
data['id'])
data = client.clusters.get(data['id']).to_dict()
_format_cluster_output(self.app, data)
data = utils.prepare_data(data, c_v1.CLUSTER_FIELDS)
return self.dict2columns(data)
def _show_cluster_info(self, data, provision_steps, parsed_args):
fields = []
if parsed_args.verification:
ver_data, fields = _prepare_health_checks(data)
data.update(ver_data)
fields.extend(CLUSTER_FIELDS)
data = self.dict2columns(utils.prepare_data(data, fields))
if parsed_args.show_progress:
output_steps = []
for step in provision_steps:
st_name, st_type = step['step_name'], step['step_type']
description = "%s: %s" % (st_type, st_name)
if step['successful'] is None:
progress = "Step in progress"
elif step['successful']:
progress = "Step completed successfully"
else:
progress = 'Step has failed events'
output_steps += [(description, progress)]
data = utils.extend_columns(data, output_steps)
return data
def _show_cluster_info(self, data, provision_steps, parsed_args):
fields = []
if parsed_args.verification:
ver_data, fields = _prepare_health_checks(data)
data.update(ver_data)
fields.extend(CLUSTER_FIELDS)
data = self.dict2columns(utils.prepare_data(data, fields))
if parsed_args.show_progress:
output_steps = []
for step in provision_steps:
st_name, st_type = step['step_name'], step['step_type']
description = "%s: %s" % (st_type, st_name)
if step['successful'] is None:
progress = "Step in progress"
elif step['successful']:
progress = "Step completed successfully"
else:
progress = 'Step has failed events'
output_steps += [(description, progress)]
data = utils.extend_columns(data, output_steps)
return data
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
if parsed_args.json:
blob = osc_utils.read_blob_file_contents(parsed_args.json)
try:
template = jsonutils.loads(blob)
except ValueError as e:
raise exceptions.CommandError(
'An error occurred when reading '
'template from file %s: %s' % (parsed_args.json, e))
data = utils.create_job_template_json(self.app,
client, **template)
else:
if parsed_args.interface:
blob = osc_utils.read_blob_file_contents(parsed_args.json)
try:
parsed_args.interface = jsonutils.loads(blob)
except ValueError as e:
raise exceptions.CommandError(
'An error occurred when reading '
'interface from file %s: %s' % (parsed_args.json, e))
mains_ids = [utils.get_resource_id(client.job_binaries, m) for m
in parsed_args.mains] if parsed_args.mains else None
libs_ids = [utils.get_resource_id(client.job_binaries, m) for m
in parsed_args.libs] if parsed_args.libs else None
data = utils.create_job_templates(self.app, client, mains_ids,
libs_ids, parsed_args)
_format_job_template_output(data)
data = utils.prepare_data(data, JOB_TEMPLATE_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
if parsed_args.json:
blob = osc_utils.read_blob_file_contents(parsed_args.json)
try:
template = jsonutils.loads(blob)
except ValueError as e:
raise exceptions.CommandError('An error occurred when reading '
'template from file %s: %s' %
(parsed_args.json, e))
data = client.job_binaries.create(**template).to_dict()
else:
if parsed_args.data:
data = open(parsed_args.data).read()
jbi_id = client.job_binary_internals.create(
parsed_args.name, data).id
parsed_args.url = 'internal-db://' + jbi_id
if parsed_args.password_prompt:
parsed_args.password = osc_utils.get_password(self.app.stdin,
confirm=False)
if parsed_args.secret_key_prompt:
parsed_args.secret_key = osc_utils.get_password(self.app.stdin,
confirm=False)
if not parsed_args.password:
parsed_args.password = parsed_args.secret_key
if not parsed_args.username:
parsed_args.username = parsed_args.access_key
if parsed_args.password and not parsed_args.username:
raise exceptions.CommandError(
'Username via --username, or S3 access key via '
'--access-key should be provided with password')
if parsed_args.username and not parsed_args.password:
raise exceptions.CommandError(
'Password should be provided via --password or '
'--secret-key, or entered interactively with '
'--password-prompt or --secret-key-prompt')
if parsed_args.password and parsed_args.username:
if not parsed_args.url:
raise exceptions.CommandError(
'URL must be provided via --url')
if parsed_args.url.startswith('s3'):
if not parsed_args.s3_endpoint:
raise exceptions.CommandError(
'S3 job binaries need an endpoint provided via '
'--s3-endpoint')
extra = {
'accesskey': parsed_args.username,
'secretkey': parsed_args.password,
'endpoint': parsed_args.s3_endpoint,
}
else:
extra = {
'user': parsed_args.username,
'password': parsed_args.password
}
else:
extra = None
data = client.job_binaries.create(
name=parsed_args.name,
url=parsed_args.url,
description=parsed_args.description,
extra=extra,
is_public=parsed_args.public,
is_protected=parsed_args.protected).to_dict()
data = utils.prepare_data(data, JOB_BINARY_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
if parsed_args.json:
blob = osc_utils.read_blob_file_contents(parsed_args.json)
try:
template = jsonutils.loads(blob)
except ValueError as e:
raise exceptions.CommandError(
'An error occurred when reading '
'template from file %s: %s' % (parsed_args.json, e))
data = client.job_binaries.create(**template).to_dict()
else:
if parsed_args.password_prompt:
parsed_args.password = osc_utils.get_password(
self.app.stdin, confirm=False)
if parsed_args.secret_key_prompt:
parsed_args.secret_key = osc_utils.get_password(
self.app.stdin, confirm=False)
if not parsed_args.password:
parsed_args.password = parsed_args.secret_key
if not parsed_args.username:
parsed_args.username = parsed_args.access_key
if parsed_args.password and not parsed_args.username:
raise exceptions.CommandError(
'Username via --username, or S3 access key via '
'--access-key should be provided with password')
if parsed_args.username and not parsed_args.password:
raise exceptions.CommandError(
'Password should be provided via --password or '
'--secret-key, or entered interactively with '
'--password-prompt or --secret-key-prompt')
if parsed_args.password and parsed_args.username:
if not parsed_args.url:
raise exceptions.CommandError(
'URL must be provided via --url')
if parsed_args.url.startswith('s3'):
if not parsed_args.s3_endpoint:
raise exceptions.CommandError(
'S3 job binaries need an endpoint provided via '
'--s3-endpoint')
extra = {
'accesskey': parsed_args.username,
'secretkey': parsed_args.password,
'endpoint': parsed_args.s3_endpoint,
}
else:
extra = {
'user': parsed_args.username,
'password': parsed_args.password
}
else:
extra = None
data = client.job_binaries.create(
name=parsed_args.name, url=parsed_args.url,
description=parsed_args.description, extra=extra,
is_public=parsed_args.public,
is_protected=parsed_args.protected).to_dict()
data = utils.prepare_data(data, jb_v1.JOB_BINARY_FIELDS)
return self.dict2columns(data)
