Cesar77RR's picture
download
raw
24.3 kB
import random, binascii, threading, os, time
def pycc_corrupt_string(string):
if string:
if (random.randint(0, 1) == 0):
hexstring = binascii.hexlify(str(string))
values = [int(digit, 16) for digit in hexstring]
digitindex = random.randint(0, len(values))
bitindex = random.randint(0, 3)
values[(digitindex - 1)] ^= (1 << bitindex)
result = ''.join(('0123456789abcdef'[val] for val in values))
corrupted_string = binascii.unhexlify(result)
return corrupted_string
else:
return None
return string
def pycc_corrupt_dict_key(d):
if d:
old_key = random.choice(d.keys())
corrupted_key = pycc_corrupt(old_key)
d[corrupted_key] = d.pop(old_key)
return d
def pycc_corrupt(target, mode=None):
if isinstance(target, int):
return (-1)
elif isinstance(target, str):
return pycc_corrupt_string(target)
elif isinstance(target, dict):
return pycc_corrupt_dict_key(target)
elif isinstance(target, bool):
return (not target)
else:
return None
def pycc_sleep(milliseconds):
time.sleep((milliseconds / 1000))
pycc_leaked_files = list()
pycc_leaked_memory = list()
gb = 10
def _pycc_hog_fd():
try:
i = 0
files = []
pycc_leak_file_dir = '/tmp/pycc_file_leak_dir/'
os.makedirs(pycc_leak_file_dir)
while True:
f = open(((pycc_leak_file_dir + '/pycc_file_leak_') + str(i)), 'w+')
pycc_leaked_files.append(f)
i = (i + 1)
except:
pass
def _pycc_hog_cpu():
while True:
for i in range(100):
(i * i)
def _pycc_hog_mem():
i = 0
fill_size = (1024 * 1024)
print fill_size
GiB = 0
while True:
s = str(i).zfill(fill_size)
pycc_leaked_memory.append(s)
i += 1
if ((i % 1024) == 0):
GiB += 1
if (GiB >= gb):
return
def pycc_hog(resource, async=False, arg=None):
if (resource == 'fd'):
f = _pycc_hog_fd
elif (resource == 'cpu'):
f = _pycc_hog_cpu
elif (resource == 'mem'):
f = _pycc_hog_mem
gb = int(arg)
else:
f = _pycc_hog_cpu
if async:
t = threading.Thread(target=f)
t.start()
else:
f()
from oslo_config import cfg
from oslo_utils import versionutils
from oslo_versionedobjects import fields
from cinder import db
from cinder import exception
from cinder.i18n import _
from cinder import objects
from cinder.objects import base
from cinder.objects import cleanable
from cinder.objects import fields as c_fields
CONF = cfg.CONF
class MetadataObject(dict, ):
def __init__(self, key=None, value=None):
super(MetadataObject, self).__init__()
self.key = key
self.value = value
def __getattr__(self, name):
if (name in self):
return self[name]
else:
raise AttributeError(('No such attribute: ' + name))
def __setattr__(self, name, value):
self[name] = value
@base.CinderObjectRegistry.register
class Volume(cleanable.CinderCleanableObject, base.CinderObject, base.CinderObjectDictCompat, base.CinderComparableObject, base.ClusteredObject, ):
VERSION = '1.6'
OPTIONAL_FIELDS = ('metadata', 'admin_metadata', 'glance_metadata', 'volume_type', 'volume_attachment', 'consistencygroup', 'snapshots', 'cluster', 'group')
fields = {'id': fields.UUIDField(), '_name_id': fields.UUIDField(nullable=True), 'ec2_id': fields.UUIDField(nullable=True), 'user_id': fields.StringField(nullable=True), 'project_id': fields.StringField(nullable=True), 'snapshot_id': fields.UUIDField(nullable=True), 'cluster_name': fields.StringField(nullable=True), 'cluster': fields.ObjectField('Cluster', nullable=True, read_only=True), 'host': fields.StringField(nullable=True), 'size': fields.IntegerField(nullable=True), 'availability_zone': fields.StringField(nullable=True), 'status': fields.StringField(nullable=True), 'attach_status': c_fields.VolumeAttachStatusField(nullable=True), 'migration_status': fields.StringField(nullable=True), 'scheduled_at': fields.DateTimeField(nullable=True), 'launched_at': fields.DateTimeField(nullable=True), 'terminated_at': fields.DateTimeField(nullable=True), 'display_name': fields.StringField(nullable=True), 'display_description': fields.StringField(nullable=True), 'provider_id': fields.StringField(nullable=True), 'provider_location': fields.StringField(nullable=True), 'provider_auth': fields.StringField(nullable=True), 'provider_geometry': fields.StringField(nullable=True), 'volume_type_id': fields.UUIDField(nullable=True), 'source_volid': fields.UUIDField(nullable=True), 'encryption_key_id': fields.UUIDField(nullable=True), 'consistencygroup_id': fields.UUIDField(nullable=True), 'group_id': fields.UUIDField(nullable=True), 'deleted': fields.BooleanField(default=False, nullable=True), 'bootable': fields.BooleanField(default=False, nullable=True), 'multiattach': fields.BooleanField(default=False, nullable=True), 'replication_status': fields.StringField(nullable=True), 'replication_extended_status': fields.StringField(nullable=True), 'replication_driver_data': fields.StringField(nullable=True), 'previous_status': fields.StringField(nullable=True), 'metadata': fields.DictOfStringsField(nullable=True), 'admin_metadata': fields.DictOfStringsField(nullable=True), 'glance_metadata': fields.DictOfStringsField(nullable=True), 'volume_type': fields.ObjectField('VolumeType', nullable=True), 'volume_attachment': fields.ObjectField('VolumeAttachmentList', nullable=True), 'consistencygroup': fields.ObjectField('ConsistencyGroup', nullable=True), 'snapshots': fields.ObjectField('SnapshotList', nullable=True), 'group': fields.ObjectField('Group', nullable=True)}
obj_extra_fields = ['name', 'name_id', 'volume_metadata', 'volume_admin_metadata', 'volume_glance_metadata']
@classmethod
def _get_expected_attrs(cls, context, *args, **kwargs):
expected_attrs = ['metadata', 'volume_type', 'volume_type.extra_specs']
if context.is_admin:
expected_attrs.append('admin_metadata')
return expected_attrs
@property
def name_id(self):
return (self.id if (not self._name_id) else self._name_id)
@name_id.setter
def name_id(self, value):
self._name_id = value
@property
def name(self):
return (CONF.volume_name_template % self.name_id)
@property
def volume_metadata(self):
md = [MetadataObject(k, v) for (k, v) in self.metadata.items()]
return md
@volume_metadata.setter
def volume_metadata(self, value):
md = {d['key']: d['value'] for d in value}
self.metadata = md
@property
def volume_admin_metadata(self):
md = [MetadataObject(k, v) for (k, v) in self.admin_metadata.items()]
return md
@volume_admin_metadata.setter
def volume_admin_metadata(self, value):
md = {d['key']: d['value'] for d in value}
self.admin_metadata = md
@property
def volume_glance_metadata(self):
md = [MetadataObject(k, v) for (k, v) in self.glance_metadata.items()]
return md
@volume_glance_metadata.setter
def volume_glance_metadata(self, value):
md = {d['key']: d['value'] for d in value}
self.glance_metadata = md
def __init__(self, *args, **kwargs):
super(Volume, self).__init__(*args, **kwargs)
self._orig_metadata = {}
self._orig_admin_metadata = {}
self._orig_glance_metadata = {}
self._reset_metadata_tracking()
def obj_reset_changes(self, fields=None):
super(Volume, self).obj_reset_changes(fields)
self._reset_metadata_tracking(fields=fields)
@classmethod
def _obj_from_primitive(cls, context, objver, primitive):
obj = super(Volume, Volume)._obj_from_primitive(context, objver, primitive)
obj._reset_metadata_tracking()
return obj
def _reset_metadata_tracking(self, fields=None):
if ((fields is None) or ('metadata' in fields)):
self._orig_metadata = (dict(self.metadata) if ('metadata' in self) else {})
if ((fields is None) or ('admin_metadata' in fields)):
self._orig_admin_metadata = (dict(self.admin_metadata) if ('admin_metadata' in self) else {})
if ((fields is None) or ('glance_metadata' in fields)):
self._orig_glance_metadata = (dict(self.glance_metadata) if ('glance_metadata' in self) else {})
def obj_what_changed(self):
changes = super(Volume, self).obj_what_changed()
if (('metadata' in self) and (self.metadata != self._orig_metadata)):
changes.add('metadata')
if (('admin_metadata' in self) and (self.admin_metadata != self._orig_admin_metadata)):
changes.add('admin_metadata')
if (('glance_metadata' in self) and (self.glance_metadata != self._orig_glance_metadata)):
changes.add('glance_metadata')
return changes
def obj_make_compatible(self, primitive, target_version):
'Make a Volume representation compatible with a target version.'
added_fields = (((1, 4), ('cluster', 'cluster_name')), ((1, 5), ('group', 'group_id')))
super(Volume, self).obj_make_compatible(primitive, target_version)
target_version = versionutils.convert_version_to_tuple(target_version)
for (version, remove_fields) in added_fields:
if (target_version < version):
for obj_field in remove_fields:
primitive.pop(obj_field, None)
@classmethod
def _from_db_object(cls, context, volume, db_volume, expected_attrs=None):
if (expected_attrs is None):
expected_attrs = []
for (name, field) in volume.fields.items():
if (name in cls.OPTIONAL_FIELDS):
continue
value = db_volume.get(name)
if isinstance(field, fields.IntegerField):
value = (value or 0)
volume[name] = value
if ('metadata' in expected_attrs):
metadata = db_volume.get('volume_metadata', [])
volume.metadata = {item['key']: item['value'] for item in metadata}
if ('admin_metadata' in expected_attrs):
metadata = db_volume.get('volume_admin_metadata', [])
volume.admin_metadata = {item['key']: item['value'] for item in metadata}
if ('glance_metadata' in expected_attrs):
metadata = db_volume.get('volume_glance_metadata', [])
volume.glance_metadata = {item['key']: item['value'] for item in metadata}
if ('volume_type' in expected_attrs):
db_volume_type = db_volume.get('volume_type')
if db_volume_type:
vt_expected_attrs = []
if ('volume_type.extra_specs' in expected_attrs):
vt_expected_attrs.append('extra_specs')
volume.volume_type = objects.VolumeType._from_db_object(context, objects.VolumeType(), db_volume_type, expected_attrs=vt_expected_attrs)
if ('volume_attachment' in expected_attrs):
attachments = base.obj_make_list(context, objects.VolumeAttachmentList(context), objects.VolumeAttachment, db_volume.get('volume_attachment'))
volume.volume_attachment = attachments
if (volume.consistencygroup_id and ('consistencygroup' in expected_attrs)):
consistencygroup = objects.ConsistencyGroup(context)
consistencygroup._from_db_object(context, consistencygroup, db_volume['consistencygroup'])
volume.consistencygroup = consistencygroup
if ('snapshots' in expected_attrs):
snapshots = base.obj_make_list(context, objects.SnapshotList(context), objects.Snapshot, db_volume['snapshots'])
volume.snapshots = snapshots
if ('cluster' in expected_attrs):
db_cluster = db_volume.get('cluster')
if db_cluster:
volume.cluster = objects.Cluster(context)
objects.Cluster._from_db_object(context, volume.cluster, db_cluster)
else:
volume.cluster = None
if (volume.group_id and ('group' in expected_attrs)):
group = objects.Group(context)
group._from_db_object(context, group, db_volume['group'])
volume.group = group
volume._context = context
volume.obj_reset_changes()
return volume
def create(self):
if self.obj_attr_is_set('id'):
raise exception.ObjectActionError(action='create', reason=_('already created'))
updates = self.cinder_obj_get_changes()
if ('consistencygroup' in updates):
raise exception.ObjectActionError(action='create', reason=_('consistencygroup assigned'))
if ('snapshots' in updates):
raise exception.ObjectActionError(action='create', reason=_('snapshots assigned'))
if ('cluster' in updates):
raise exception.ObjectActionError(action='create', reason=_('cluster assigned'))
if ('group' in updates):
raise exception.ObjectActionError(action='create', reason=_('group assigned'))
db_volume = db.volume_create(self._context, updates)
self._from_db_object(self._context, self, db_volume)
def save(self):
updates = self.cinder_obj_get_changes()
if updates:
if updates.pop('consistencygroup', None):
raise exception.ObjectActionError(action='save', reason=_('consistencygroup changed'))
if ('group' in updates):
raise exception.ObjectActionError(action='save', reason=_('group changed'))
if ('glance_metadata' in updates):
raise exception.ObjectActionError(action='save', reason=_('glance_metadata changed'))
if ('snapshots' in updates):
raise exception.ObjectActionError(action='save', reason=_('snapshots changed'))
if ('cluster' in updates):
raise exception.ObjectActionError(action='save', reason=_('cluster changed'))
if ('metadata' in updates):
metadata = updates.pop('metadata', None)
self.metadata = db.volume_metadata_update(self._context, self.id, metadata, True)
if (self._context.is_admin and ('admin_metadata' in updates)):
metadata = updates.pop('admin_metadata', None)
self.admin_metadata = db.volume_admin_metadata_update(self._context, self.id, metadata, True)
if (updates.get('status') == 'downloading'):
self.set_worker()
if updates:
db.volume_update(self._context, self.id, updates)
self.obj_reset_changes()
def destroy(self):
with self.obj_as_admin():
updated_values = db.volume_destroy(self._context, self.id)
self.update(updated_values)
self.obj_reset_changes(updated_values.keys())
def obj_load_attr(self, attrname):
if (attrname not in self.OPTIONAL_FIELDS):
raise exception.ObjectActionError(action='obj_load_attr', reason=(_('attribute %s not lazy-loadable') % attrname))
if (not self._context):
raise exception.OrphanedObjectError(method='obj_load_attr', objtype=self.obj_name())
if (attrname == 'metadata'):
self.metadata = db.volume_metadata_get(self._context, self.id)
elif (attrname == 'admin_metadata'):
self.admin_metadata = {}
if self._context.is_admin:
self.admin_metadata = db.volume_admin_metadata_get(self._context, self.id)
elif (attrname == 'glance_metadata'):
try:
self.volume_glance_metadata = db.volume_glance_metadata_get(self._context, self.id)
except exception.GlanceMetadataNotFound:
self.glance_metadata = {}
elif (attrname == 'volume_type'):
self.volume_type = (objects.VolumeType.get_by_id(self._context, self.volume_type_id) if self.volume_type_id else None)
elif (attrname == 'volume_attachment'):
attachments = objects.VolumeAttachmentList.get_all_by_volume_id(self._context, self.id)
self.volume_attachment = attachments
elif (attrname == 'consistencygroup'):
if (self.consistencygroup_id is None):
self.consistencygroup = None
else:
consistencygroup = objects.ConsistencyGroup.get_by_id(self._context, self.consistencygroup_id)
self.consistencygroup = consistencygroup
elif (attrname == 'snapshots'):
self.snapshots = objects.SnapshotList.get_all_for_volume(self._context, self.id)
elif (attrname == 'cluster'):
if self.cluster_name:
self.cluster = objects.Cluster.get_by_id(self._context, name=self.cluster_name)
else:
self.cluster = None
elif (attrname == 'group'):
if (self.group_id is None):
self.group = None
else:
group = objects.Group.get_by_id(self._context, self.group_id)
self.group = group
self.obj_reset_changes(fields=[attrname])
def delete_metadata_key(self, key):
db.volume_metadata_delete(self._context, self.id, key)
md_was_changed = ('metadata' in self.obj_what_changed())
del self.metadata[key]
self._orig_metadata.pop(key, None)
if (not md_was_changed):
self.obj_reset_changes(['metadata'])
def finish_volume_migration(self, dest_volume):
skip = ({'id', 'provider_location', 'glance_metadata', 'volume_type'} | set(self.obj_extra_fields))
for key in (set(dest_volume.fields.keys()) - skip):
if (not dest_volume.obj_attr_is_set(key)):
continue
value = getattr(dest_volume, key)
value_to_dst = getattr(self, key)
if (key == '_name_id'):
if (not dest_volume._name_id):
setattr(dest_volume, key, self.id)
continue
elif (key == 'migration_status'):
value = None
value_to_dst = 'deleting'
elif (key == 'display_description'):
value_to_dst = ('migration src for ' + self.id)
elif (key == 'status'):
value_to_dst = 'deleting'
elif (key == 'volume_type_id'):
self.update({'volume_type_id': value})
continue
setattr(self, key, value)
setattr(dest_volume, key, value_to_dst)
self.save()
dest_volume.save()
return dest_volume
def get_latest_snapshot(self):
"Get volume's latest snapshot"
snapshot_db = db.snapshot_get_latest_for_volume(self._context, self.id)
snapshot = objects.Snapshot(self._context)
return snapshot._from_db_object(self._context, snapshot, snapshot_db)
@staticmethod
def _is_cleanable(status, obj_version):
if (obj_version and (obj_version < 1.6)):
return False
return (status in ('creating', 'deleting', 'uploading', 'downloading'))
def begin_attach(self, attach_mode):
attachment = objects.VolumeAttachment(context=self._context, attach_status=c_fields.VolumeAttachStatus.ATTACHING, volume_id=self.id)
attachment.create()
with self.obj_as_admin():
self.admin_metadata['attached_mode'] = attach_mode
self.save()
return attachment
def finish_detach(self, attachment_id):
with self.obj_as_admin():
(volume_updates, attachment_updates) = db.volume_detached(self._context, self.id, attachment_id)
db.volume_admin_metadata_delete(self._context, self.id, 'attached_mode')
self.admin_metadata.pop('attached_mode', None)
if (attachment_updates and self.obj_attr_is_set('volume_attachment')):
for (i, attachment) in enumerate(self.volume_attachment):
if (attachment.id == attachment_id):
del self.volume_attachment.objects[i]
break
self.update(volume_updates)
self.obj_reset_changes((list(volume_updates.keys()) + ['volume_attachment', 'admin_metadata']))
def is_replicated(self):
return (self.volume_type and self.volume_type.is_replicated())
@base.CinderObjectRegistry.register
class VolumeList(base.ObjectListBase, base.CinderObject, ):
VERSION = '1.1'
fields = {'objects': fields.ListOfObjectsField('Volume')}
@staticmethod
def include_in_cluster(context, cluster, partial_rename=True, **filters):
"Include all volumes matching the filters into a cluster.\n\n When partial_rename is set we will not set the cluster_name with\n cluster parameter value directly, we'll replace provided cluster_name\n or host filter value with cluster instead.\n\n This is useful when we want to replace just the cluster name but leave\n the backend and pool information as it is. If we are using\n cluster_name to filter, we'll use that same DB field to replace the\n cluster value and leave the rest as it is. Likewise if we use the host\n to filter.\n\n Returns the number of volumes that have been changed.\n "
return db.volume_include_in_cluster(context, cluster, partial_rename, **filters)
@classmethod
def _get_expected_attrs(cls, context, *args, **kwargs):
expected_attrs = ['metadata', 'volume_type']
if context.is_admin:
expected_attrs.append('admin_metadata')
return expected_attrs
@classmethod
def get_all(cls, context, marker=None, limit=None, sort_keys=None, sort_dirs=None, filters=None, offset=None):
volumes = db.volume_get_all(context, marker, limit, sort_keys=sort_keys, sort_dirs=sort_dirs, filters=filters, offset=offset)
expected_attrs = cls._get_expected_attrs(context)
return base.obj_make_list(context, cls(context), objects.Volume, volumes, expected_attrs=expected_attrs)
@classmethod
def get_all_by_host(cls, context, host, filters=None):
volumes = db.volume_get_all_by_host(context, host, filters)
expected_attrs = cls._get_expected_attrs(context)
return base.obj_make_list(context, cls(context), objects.Volume, volumes, expected_attrs=expected_attrs)
@classmethod
def get_all_by_group(cls, context, group_id, filters=None):
volumes = db.volume_get_all_by_group(context, group_id, filters)
expected_attrs = cls._get_expected_attrs(context)
return base.obj_make_list(context, cls(context), objects.Volume, volumes, expected_attrs=expected_attrs)
@classmethod
def get_all_by_generic_group(cls, context, group_id, filters=None):
volumes = db.volume_get_all_by_generic_group(context, group_id, filters)
expected_attrs = cls._get_expected_attrs(context)
return base.obj_make_list(context, cls(context), objects.Volume, volumes, expected_attrs=expected_attrs)
@classmethod
def get_all_by_project(cls, context, project_id, marker=None, limit=None, sort_keys=None, sort_dirs=None, filters=None, offset=None):
volumes = db.volume_get_all_by_project(context, project_id, marker, limit, sort_keys=sort_keys, sort_dirs=sort_dirs, filters=filters, offset=offset)
expected_attrs = cls._get_expected_attrs(context)
return base.obj_make_list(context, cls(context), objects.Volume, volumes, expected_attrs=expected_attrs)
@classmethod
def get_volume_summary(cls, context, project_only):
volumes = db.get_volume_summary(context, project_only)
return pycc_corrupt(volumes)
@classmethod
def get_all_active_by_window(cls, context, begin, end):
volumes = db.volume_get_all_active_by_window(context, begin, end)
expected_attrs = cls._get_expected_attrs(context)
return base.obj_make_list(context, cls(context), objects.Volume, volumes, expected_attrs=expected_attrs)

Xet Storage Details

Size:
24.3 kB
·
Xet hash:
18c20a39fa1dd3536375fe7282d1fe8e264a429b03d449c3d3c257d8901b4580

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.