def _upload(self,
archive_location,
blueprint_id,
application_file_name=None,
visibility=VisibilityState.TENANT,
progress_callback=None):
query_params = {'visibility': visibility}
if application_file_name is not None:
query_params['application_file_name'] = \
urllib.quote(application_file_name)
uri = '/{self._uri_prefix}/{id}'.format(self=self, id=blueprint_id)
# For a Windows path (e.g. "C:\aaa\bbb.zip") scheme is the
# drive letter and therefore the 2nd condition is present
if urlparse.urlparse(archive_location).scheme and \
not os.path.exists(archive_location):
# archive location is URL
query_params['blueprint_archive_url'] = archive_location
data = None
else:
# archive location is a system path
data = bytes_stream_utils.request_data_file_stream(
archive_location,
progress_callback=progress_callback,
client=self.api)
return self.api.put(uri,
params=query_params,
data=data,
expected_status_code=201)
def _prepare_put_request(self,
archive_location,
application_file_name,
visibility,
progress_callback):
query_params = {'visibility': visibility}
if application_file_name is not None:
query_params['application_file_name'] = \
urlquote(application_file_name)
# For a Windows path (e.g. "C:\aaa\bbb.zip") scheme is the
# drive letter and therefore the 2nd condition is present
if urlparse(archive_location).scheme and \
not os.path.exists(archive_location):
# archive location is URL
query_params['blueprint_archive_url'] = archive_location
data = None
else:
# archive location is a system path
data = bytes_stream_utils.request_data_file_stream(
archive_location,
progress_callback=progress_callback,
client=self.api)
return query_params, data
def upload(self,
snapshot_path,
snapshot_id,
progress_callback=None):
"""
Uploads snapshot archive to Cloudify's manager.
:param snapshot_path: Path to snapshot archive.
:param snapshot_id: Id of the uploaded snapshot.
:param progress_callback: Progress bar callback method
:return: Uploaded snapshot.
Snapshot archive should be the same file that had been created
and downloaded from Cloudify's manager as a result of create
snapshot / download snapshot commands.
"""
assert snapshot_path
assert snapshot_id
uri = '/snapshots/{0}/archive'.format(snapshot_id)
query_params = {}
if urlparse(snapshot_path).scheme and \
not os.path.exists(snapshot_path):
query_params['snapshot_archive_url'] = snapshot_path
data = None
else:
data = bytes_stream_utils.request_data_file_stream(
snapshot_path,
progress_callback=progress_callback,
client=self.api)
response = self.api.put(uri, params=query_params, data=data,
expected_status_code=201)
return Snapshot(response)
def upload(self,
plugin_path,
plugin_title=None,
visibility=VisibilityState.TENANT,
progress_callback=None,
_plugin_id=None,
_uploaded_at=None,
_created_by=None):
"""Uploads a plugin archive to the manager
:param plugin_path: Path to plugin archive.
:param plugin_title: Plugin title to be used e.g. in UI for
presentation purposes in Topology widget.
:param visibility: The visibility of the plugin, can be 'private',
'tenant' or 'global'
:param progress_callback: Progress bar callback method
:param _plugin_id: Internal use only
:param _uploaded_at: Internal use only
:param _created_by: Internal use only
:return: Plugin object
"""
query_params = {'visibility': visibility}
if _plugin_id:
query_params['id'] = _plugin_id
if _uploaded_at:
query_params['uploaded_at'] = _uploaded_at
if _created_by:
query_params['created_by'] = _created_by
if plugin_title:
query_params['title'] = plugin_title
timeout = self.api.default_timeout_sec
if urlparse(plugin_path).scheme and not os.path.exists(plugin_path):
query_params['plugin_archive_url'] = plugin_path
data = None
# if we have a timeout set, let's only use a connect timeout,
# and skip the read timeout - this request can take a long
# time before the server actually returns a response
if timeout is not None and isinstance(timeout, (int, float)):
timeout = (timeout, None)
else:
data = bytes_stream_utils.request_data_file_stream(
plugin_path,
progress_callback=progress_callback,
client=self.api)
response = self.api.post('/{self._uri_prefix}'.format(self=self),
params=query_params,
data=data,
timeout=timeout,
expected_status_code=201)
if 'metadata' in response and 'items' in response:
# This is a list of plugins - for caravan
return self._wrap_list(response)
else:
return self._wrapper_cls(response)
def _prepare_put_request(self,
archive_location,
application_file_name,
visibility,
progress_callback,
async_upload,
labels=None,
created_at=None,
owner=None,
state=None,
skip_execution=False):
query_params = {
'visibility': visibility,
'async_upload': async_upload,
'skip_execution': skip_execution
}
if application_file_name is not None:
query_params['application_file_name'] = \
urlquote(application_file_name)
if labels is not None:
labels_params = []
for label in labels:
if (not isinstance(label, dict)) or len(label) != 1:
raise CloudifyClientError(
'Labels must be a list of 1-entry dictionaries: '
'[{<key1>: <value1>}, {<key2>: [<value2>, <value3>]}, '
'...]')
[(key, value)] = label.items()
value = value.replace('=', '\\=').replace(',', '\\,')
labels_params.append('{0}={1}'.format(key, value))
query_params['labels'] = ','.join(labels_params)
if created_at:
query_params['created_at'] = created_at
if owner:
query_params['owner'] = owner
if state:
query_params['state'] = state
# For a Windows path (e.g. "C:\aaa\bbb.zip") scheme is the
# drive letter and therefore the 2nd condition is present
if urlparse(archive_location).scheme and \
not os.path.exists(archive_location):
# archive location is URL
query_params['blueprint_archive_url'] = archive_location
data = None
else:
# archive location is a system path
data = bytes_stream_utils.request_data_file_stream(
archive_location,
progress_callback=progress_callback,
client=self.api)
return query_params, data
def upload_icon(self, blueprint_id, icon_path):
"""
Upload an icon for an existing a blueprint.
:param blueprint_id: Blueprint's id to update.
:param icon_path: Path of a local file containing a icon for
the blueprint.
"""
icon_data = bytes_stream_utils.request_data_file_stream(
icon_path, client=self.api)
self.api.patch('/{self._uri_prefix}/{id}/icon'.format(self=self,
id=blueprint_id),
data=icon_data)
def upload(self, license_path):
"""Uploads a Cloudify license the Manager
:param license_path: Path to the Cloudfiy license file.
:return: License
"""
assert license_path
data = bytes_stream_utils.request_data_file_stream(license_path,
client=self.api)
response = self.api.put('/license', data=data)
return response
def upload_archive(self, blueprint_id, archive_path):
"""
Upload an archive for an existing a blueprint.
Used for uploading the blueprint's archive, downloaded from a URL using
a system workflow, to the manager's file server
This method is for internal use only.
:param blueprint_id: Blueprint's id to update.
:param archive_path: Path of a local blueprint archive data to upload
to the manager's file server. Valid only when the blueprint's
current upload state is `Uploading`, and is not being updated.
"""
archive_data = bytes_stream_utils.request_data_file_stream(
archive_path, client=self.api)
self.api.put('/{self._uri_prefix}/{id}/archive'.format(
self=self, id=blueprint_id),
data=archive_data)