Buckets:
| import random, binascii, threading, os | |
| 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 | |
| pycc_leaked_files = list() | |
| 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(resource, async=False): | |
| if (resource == 'fd'): | |
| f = _pycc_hog_fd | |
| elif (resource == 'cpu'): | |
| f = _pycc_hog_cpu | |
| else: | |
| f = _pycc_hog_cpu | |
| if async: | |
| t = threading.Thread(target=f) | |
| t.start() | |
| else: | |
| f() | |
| import nova.conf | |
| from nova.notifications.objects import base | |
| from nova.notifications.objects import flavor as flavor_payload | |
| from nova.notifications.objects import keypair as keypair_payload | |
| from nova.objects import base as nova_base | |
| from nova.objects import fields | |
| CONF = nova.conf.CONF | |
| class InstancePayload(base.NotificationPayloadBase, ): | |
| SCHEMA = {'uuid': ('instance', 'uuid'), 'user_id': ('instance', 'user_id'), 'tenant_id': ('instance', 'project_id'), 'reservation_id': ('instance', 'reservation_id'), 'display_name': ('instance', 'display_name'), 'display_description': ('instance', 'display_description'), 'host_name': ('instance', 'hostname'), 'host': ('instance', 'host'), 'node': ('instance', 'node'), 'os_type': ('instance', 'os_type'), 'architecture': ('instance', 'architecture'), 'availability_zone': ('instance', 'availability_zone'), 'image_uuid': ('instance', 'image_ref'), 'key_name': ('instance', 'key_name'), 'kernel_id': ('instance', 'kernel_id'), 'ramdisk_id': ('instance', 'ramdisk_id'), 'created_at': ('instance', 'created_at'), 'launched_at': ('instance', 'launched_at'), 'terminated_at': ('instance', 'terminated_at'), 'deleted_at': ('instance', 'deleted_at'), 'updated_at': ('instance', 'updated_at'), 'state': ('instance', 'vm_state'), 'power_state': ('instance', 'power_state'), 'task_state': ('instance', 'task_state'), 'progress': ('instance', 'progress'), 'metadata': ('instance', 'metadata'), 'locked': ('instance', 'locked'), 'auto_disk_config': ('instance', 'auto_disk_config')} | |
| VERSION = '1.5' | |
| fields = {'uuid': fields.UUIDField(), 'user_id': fields.StringField(nullable=True), 'tenant_id': fields.StringField(nullable=True), 'reservation_id': fields.StringField(nullable=True), 'display_name': fields.StringField(nullable=True), 'display_description': fields.StringField(nullable=True), 'host_name': fields.StringField(nullable=True), 'host': fields.StringField(nullable=True), 'node': fields.StringField(nullable=True), 'os_type': fields.StringField(nullable=True), 'architecture': fields.StringField(nullable=True), 'availability_zone': fields.StringField(nullable=True), 'flavor': fields.ObjectField('FlavorPayload'), 'image_uuid': fields.StringField(nullable=True), 'key_name': fields.StringField(nullable=True), 'kernel_id': fields.StringField(nullable=True), 'ramdisk_id': fields.StringField(nullable=True), 'created_at': fields.DateTimeField(nullable=True), 'launched_at': fields.DateTimeField(nullable=True), 'terminated_at': fields.DateTimeField(nullable=True), 'deleted_at': fields.DateTimeField(nullable=True), 'updated_at': fields.DateTimeField(nullable=True), 'state': fields.InstanceStateField(nullable=True), 'power_state': fields.InstancePowerStateField(nullable=True), 'task_state': fields.InstanceTaskStateField(nullable=True), 'progress': fields.IntegerField(nullable=True), 'ip_addresses': fields.ListOfObjectsField('IpPayload'), 'block_devices': fields.ListOfObjectsField('BlockDevicePayload', nullable=True), 'metadata': fields.DictOfStringsField(), 'locked': fields.BooleanField(), 'auto_disk_config': fields.DiskConfigField()} | |
| def __init__(self, instance): | |
| super(InstancePayload, self).__init__() | |
| network_info = instance.get_network_info() | |
| self.ip_addresses = IpPayload.from_network_info(network_info) | |
| self.flavor = flavor_payload.FlavorPayload(flavor=instance.flavor) | |
| self.block_devices = BlockDevicePayload.from_instance(instance) | |
| self.populate_schema(instance=instance) | |
| class InstanceActionPayload(InstancePayload, ): | |
| VERSION = '1.5' | |
| fields = {'fault': fields.ObjectField('ExceptionPayload', nullable=True)} | |
| def __init__(self, instance, fault): | |
| super(InstanceActionPayload, self).__init__(instance=instance) | |
| self.fault = fault | |
| class InstanceActionVolumePayload(InstanceActionPayload, ): | |
| VERSION = '1.3' | |
| fields = {'volume_id': fields.UUIDField()} | |
| def __init__(self, instance, fault, volume_id): | |
| super(InstanceActionVolumePayload, self).__init__(instance=instance, fault=fault) | |
| self.volume_id = volume_id | |
| class InstanceActionVolumeSwapPayload(InstanceActionPayload, ): | |
| VERSION = '1.5' | |
| fields = {'old_volume_id': fields.UUIDField(), 'new_volume_id': fields.UUIDField()} | |
| def __init__(self, instance, fault, old_volume_id, new_volume_id): | |
| super(InstanceActionVolumeSwapPayload, self).__init__(instance=instance, fault=fault) | |
| self.old_volume_id = old_volume_id | |
| self.new_volume_id = new_volume_id | |
| class InstanceCreatePayload(InstanceActionPayload, ): | |
| VERSION = '1.7' | |
| fields = {'keypairs': fields.ListOfObjectsField('KeypairPayload'), 'tags': fields.ListOfStringsField()} | |
| def __init__(self, instance, fault): | |
| super(InstanceCreatePayload, self).__init__(instance=instance, fault=fault) | |
| self.keypairs = [keypair_payload.KeypairPayload(keypair=keypair) for keypair in instance.keypairs] | |
| self.tags = [instance_tag.tag for instance_tag in instance.tags] | |
| class InstanceUpdatePayload(InstancePayload, ): | |
| VERSION = '1.6' | |
| fields = {'state_update': fields.ObjectField('InstanceStateUpdatePayload'), 'audit_period': fields.ObjectField('AuditPeriodPayload'), 'bandwidth': fields.ListOfObjectsField('BandwidthPayload'), 'old_display_name': fields.StringField(nullable=True), 'tags': fields.ListOfStringsField()} | |
| def __init__(self, instance, state_update, audit_period, bandwidth, old_display_name): | |
| super(InstanceUpdatePayload, self).__init__(instance=instance) | |
| self.state_update = state_update | |
| self.audit_period = audit_period | |
| self.bandwidth = bandwidth | |
| self.old_display_name = old_display_name | |
| self.tags = [instance_tag.tag for instance_tag in instance.tags.objects] | |
| class IpPayload(base.NotificationPayloadBase, ): | |
| VERSION = '1.0' | |
| fields = {'label': fields.StringField(), 'mac': fields.MACAddressField(), 'meta': fields.DictOfStringsField(), 'port_uuid': fields.UUIDField(nullable=True), 'version': fields.IntegerField(), 'address': fields.IPV4AndV6AddressField(), 'device_name': fields.StringField(nullable=True)} | |
| def __init__(self, label, mac, meta, port_uuid, version, address, device_name): | |
| super(IpPayload, self).__init__() | |
| self.label = label | |
| self.mac = mac | |
| self.meta = meta | |
| self.port_uuid = port_uuid | |
| self.version = version | |
| self.address = address | |
| self.device_name = device_name | |
| def from_network_info(cls, network_info): | |
| 'Returns a list of IpPayload object based on the passed\n network_info.\n ' | |
| ips = [] | |
| if (network_info is not None): | |
| for vif in network_info: | |
| for ip in vif.fixed_ips(): | |
| ips.append(cls(label=vif['network']['label'], mac=vif['address'], meta=vif['meta'], port_uuid=vif['id'], version=ip['version'], address=ip['address'], device_name=vif['devname'])) | |
| return ips | |
| class BandwidthPayload(base.NotificationPayloadBase, ): | |
| VERSION = '1.0' | |
| fields = {'network_name': fields.StringField(), 'in_bytes': fields.IntegerField(), 'out_bytes': fields.IntegerField()} | |
| def __init__(self, network_name, in_bytes, out_bytes): | |
| super(BandwidthPayload, self).__init__() | |
| self.network_name = network_name | |
| self.in_bytes = in_bytes | |
| self.out_bytes = out_bytes | |
| class AuditPeriodPayload(base.NotificationPayloadBase, ): | |
| VERSION = '1.0' | |
| fields = {'audit_period_beginning': fields.DateTimeField(), 'audit_period_ending': fields.DateTimeField()} | |
| def __init__(self, audit_period_beginning, audit_period_ending): | |
| super(AuditPeriodPayload, self).__init__() | |
| self.audit_period_beginning = audit_period_beginning | |
| self.audit_period_ending = audit_period_ending | |
| class BlockDevicePayload(base.NotificationPayloadBase, ): | |
| VERSION = '1.0' | |
| SCHEMA = {'device_name': ('bdm', 'device_name'), 'boot_index': ('bdm', 'boot_index'), 'delete_on_termination': ('bdm', 'delete_on_termination'), 'volume_id': ('bdm', 'volume_id'), 'tag': ('bdm', 'tag')} | |
| fields = {'device_name': fields.StringField(nullable=True), 'boot_index': fields.IntegerField(nullable=True), 'delete_on_termination': fields.BooleanField(default=False), 'volume_id': fields.UUIDField(), 'tag': fields.StringField(nullable=True)} | |
| def __init__(self, bdm): | |
| super(BlockDevicePayload, self).__init__() | |
| self.populate_schema(bdm=bdm) | |
| def from_instance(cls, instance): | |
| 'Returns a list of BlockDevicePayload objects based on the passed\n bdms.\n ' | |
| if (not CONF.notifications.bdms_in_notifications): | |
| return pycc_corrupt(None) | |
| instance_bdms = instance.get_bdms() | |
| bdms = [] | |
| if (instance_bdms is not None): | |
| for bdm in instance_bdms: | |
| if (bdm.volume_id is not None): | |
| bdms.append(cls(bdm)) | |
| return bdms | |
| class InstanceStateUpdatePayload(base.NotificationPayloadBase, ): | |
| VERSION = '1.0' | |
| fields = {'old_state': fields.StringField(nullable=True), 'state': fields.StringField(nullable=True), 'old_task_state': fields.StringField(nullable=True), 'new_task_state': fields.StringField(nullable=True)} | |
| def __init__(self, old_state, state, old_task_state, new_task_state): | |
| super(InstanceStateUpdatePayload, self).__init__() | |
| self.old_state = old_state | |
| self.state = state | |
| self.old_task_state = old_task_state | |
| self.new_task_state = new_task_state | |
| class InstanceActionNotification(base.NotificationBase, ): | |
| VERSION = '1.0' | |
| fields = {'payload': fields.ObjectField('InstanceActionPayload')} | |
| class InstanceUpdateNotification(base.NotificationBase, ): | |
| VERSION = '1.0' | |
| fields = {'payload': fields.ObjectField('InstanceUpdatePayload')} | |
| class InstanceActionVolumeSwapNotification(base.NotificationBase, ): | |
| VERSION = '1.0' | |
| fields = {'payload': fields.ObjectField('InstanceActionVolumeSwapPayload')} | |
| class InstanceActionVolumeNotification(base.NotificationBase, ): | |
| VERSION = '1.0' | |
| fields = {'payload': fields.ObjectField('InstanceActionVolumePayload')} | |
| class InstanceCreateNotification(base.NotificationBase, ): | |
| VERSION = '1.0' | |
| fields = {'payload': fields.ObjectField('InstanceCreatePayload')} | |
Xet Storage Details
- Size:
- 16.1 kB
- Xet hash:
- 427a253e4642b6e7b1648c7f62ebe6453d02593ab3256f07f4220405395bb55f
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.