Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def failed(failure):
Message.new(message_type=u"acceptance:http_query_failed",
reason=unicode(failure)).write()
return False
req.addCallbacks(content, failed)
def emit(self, record):
Message.new(
message_type=BOTO_LOG_HEADER, message=record.getMessage()
).write()
def resize_volume(self, blockdevice_id, size):
Message.new(Debug="coprhd resize_volume invoked").write(_logger)
pass
def _cleanup_node_named(self, name):
"""
Destroy a node with the given name, if there is one. Otherwise, do
nothing.
"""
nodes = _retry_exception(self._driver.list_nodes)
for node in nodes:
if node.name == name:
Message.new(
message_type=(
u"flocker:provision:libcloud:cleanup_node_named"
),
name=name,
id=node.id,
state=node.state,
).write()
_retry_exception(node.destroy)
return
def destroy_volume(self, blockdevice_id):
"""
Destroy the storage for the given unattached volume.
:param: blockdevice_id - the volume id
:raise: UnknownVolume is not found
"""
dataset_id = UUID(blockdevice_id[6:])
volumesdetails = self.coprhdcli.get_volume_details("flocker-{}".format(dataset_id))
if not volumesdetails:
raise UnknownVolume(blockdevice_id)
Message.new(Info="Destroying Volume" + str(blockdevice_id)).write(_logger)
self.coprhdcli.delete_volume("flocker-{}".format(dataset_id))
def create_network(self,name,nwtype):
self.authenticate_user()
try:
networkId = self.network_obj.query_by_name(name)
if(networkId):
Message.new(Debug="Network Already Exists").write(_logger)
else:
self.network_obj.create(name,nwtype)
varray_uri = self.varray_obj.varray_list()
storage_ports = self.varray_obj.list_storageports(self.varray)
storagesystem_name = []
storagesystem_list = []
port_list = []
for st in storage_ports:
if st['storage_system'] not in storagesystem_name:
storagesystem_name.append(st['storage_system'])
storagesystem_list.append(self.storagesystem_obj.show_by_name(st['storage_system']))
for st in storagesystem_list:
storage_port=self.storageport_obj.storageport_list(
storagedeviceName=st['name'],
serialNumber=st['serial_number'],
storagedeviceType=st['system_type'])
attachment, the device shall appear in /dev/sd<1>.
See ``IBlockDeviceAPI.attach_volume`` for parameter and return type
documentation.
"""
Message.new(Debug="coprhd attach_volume invoked").write(_logger)
dataset_id = UUID(blockdevice_id[6:])
volumesdetails = self.coprhdcli.get_volume_details("flocker-{}".format(dataset_id))
Message.new(Info="coprhd got volume details").write(_logger)
if not volumesdetails:
raise UnknownVolume(blockdevice_id)
if volumesdetails[volumesdetails.keys()[0]]['attached_to'] is not None:
Message.new(Info="coprhd already attached volume").write(_logger)
raise AlreadyAttachedVolume(blockdevice_id)
else:
Message.new(Info="coprhd invoking export_volume").write(_logger)
self.coprhdcli.export_volume("flocker-{}".format(dataset_id))
self.rescan_scsi()
size = Decimal(volumesdetails[volumesdetails.keys()[0]]['size'])
size = 1073741824 * int(size)
return BlockDeviceVolume(
size=size, attached_to=attach_to,
dataset_id=dataset_id,
blockdevice_id=blockdevice_id,
)
def pollable():
Message.new(
message_type=_TRY_RETRYING,
).write()
try:
result = function(*args, **kwargs)
except Exception as e:
saved_result[0] = exc_info()
should_retry(*saved_result[0])
Message.new(
message_type=_TRY_FAILURE,
exception=str(e),
).write()
return False
else:
Message.new(
message_type=_TRY_SUCCESS,
result=result,
).write()
saved_result[0] = result
return True
# Convert bytes to megabytes for API
mb_size = bytes_to_mbytes(size)
scaleio_size = self.to_scaleio_size(mb_size)
# Flocker volumes start with and f again,
# we only have 32 chars to work with in the ```name```
volume_name = 'f%s%s' % (slug, str(self._cluster_id)[:8])
volume = self._client.create_volume(
volume_name,
scaleio_size,
self._client.get_pd_by_name(self._pdomain),
self._client.get_storage_pool_by_name(self._spool))
siovolume = self._client.get_volume_by_name(
volume_name)
Message.new(Info="Created Volume "
+ siovolume.name).write(_logger)
Message.new(vol=siovolume.id,
size=siovolume.size_kb).write(_logger)
return _blockdevicevolume_from_scaleio_volume(
self._client.get_volume_by_name(volume_name))
def _check_response_error(e, message_type):
"""
Check if an exception is a transient one.
If it is, then it is simply logged, otherwise it is raised.
:param boto.exception import EC2ResponseErro e: The exception to check.
:param str message_type: The message type for logging.
"""
if e.error_code != BOTO_INSTANCE_NOT_FOUND:
raise e
Message.new(
message_type=message_type,
reason=e.error_code,
).write()