Cesar77RR's picture
download
raw
24.7 kB
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()
'Instance Metadata information.'
import os
import posixpath
from oslo_log import log as logging
from oslo_serialization import base64
from oslo_serialization import jsonutils
from oslo_utils import importutils
from oslo_utils import timeutils
import six
from nova.api.ec2 import ec2utils
from nova.api.metadata import password
from nova.api.metadata import vendordata
from nova.api.metadata import vendordata_dynamic
from nova.api.metadata import vendordata_json
from nova import block_device
from nova.cells import opts as cells_opts
from nova.cells import rpcapi as cells_rpcapi
import nova.conf
from nova import context
from nova import exception
from nova import network
from nova.network.security_group import openstack_driver
from nova import objects
from nova.objects import virt_device_metadata as metadata_obj
from nova import utils
from nova.virt import netutils
CONF = nova.conf.CONF
VERSIONS = ['1.0', '2007-01-19', '2007-03-01', '2007-08-29', '2007-10-10', '2007-12-15', '2008-02-01', '2008-09-01', '2009-04-04']
FOLSOM = '2012-08-10'
GRIZZLY = '2013-04-04'
HAVANA = '2013-10-17'
LIBERTY = '2015-10-15'
NEWTON_ONE = '2016-06-30'
NEWTON_TWO = '2016-10-06'
OCATA = '2017-02-22'
OPENSTACK_VERSIONS = [FOLSOM, GRIZZLY, HAVANA, LIBERTY, NEWTON_ONE, NEWTON_TWO, OCATA]
VERSION = 'version'
CONTENT = 'content'
CONTENT_DIR = 'content'
MD_JSON_NAME = 'meta_data.json'
VD_JSON_NAME = 'vendor_data.json'
VD2_JSON_NAME = 'vendor_data2.json'
NW_JSON_NAME = 'network_data.json'
UD_NAME = 'user_data'
PASS_NAME = 'password'
MIME_TYPE_TEXT_PLAIN = 'text/plain'
MIME_TYPE_APPLICATION_JSON = 'application/json'
LOG = logging.getLogger(__name__)
class InvalidMetadataVersion(Exception, ):
pass
class InvalidMetadataPath(Exception, ):
pass
class InstanceMetadata(object, ):
'Instance metadata.'
def __init__(self, instance, address=None, content=None, extra_md=None, network_info=None, vd_driver=None, network_metadata=None, request_context=None):
'Creation of this object should basically cover all time consuming\n collection. Methods after that should not cause time delays due to\n network operations or lengthy cpu operations.\n\n The user should then get a single instance and make multiple method\n calls on it.\n '
if (not content):
content = []
ctxt = context.get_admin_context()
instance.ec2_ids
instance.keypairs
instance.device_metadata
instance = objects.Instance.obj_from_primitive(instance.obj_to_primitive())
self.set_mimetype(MIME_TYPE_TEXT_PLAIN)
self.instance = instance
self.extra_md = extra_md
self.availability_zone = instance.get('availability_zone')
secgroup_api = openstack_driver.get_openstack_security_group_driver()
self.security_groups = secgroup_api.get_instance_security_groups(ctxt, instance)
self.mappings = _format_instance_mapping(ctxt, instance)
if (instance.user_data is not None):
self.userdata_raw = base64.decode_as_bytes(instance.user_data)
else:
self.userdata_raw = None
self.address = address
self.launch_metadata = utils.instance_meta(instance)
self.password = password.extract_password(instance)
self.uuid = instance.uuid
self.content = {}
self.files = []
if (network_info is None):
network_info = instance.info_cache.network_info
if (network_metadata is None):
self.network_metadata = netutils.get_network_metadata(network_info)
else:
self.network_metadata = network_metadata
self.ip_info = ec2utils.get_ip_info_for_instance_from_nw_info(network_info)
self.network_config = None
cfg = netutils.get_injected_network_template(network_info)
if cfg:
key = ('%04i' % len(self.content))
self.content[key] = cfg
self.network_config = {'name': 'network_config', 'content_path': ('/%s/%s' % (CONTENT_DIR, key))}
for (path, contents) in content:
key = ('%04i' % len(self.content))
self.files.append({'path': path, 'content_path': ('/%s/%s' % (CONTENT_DIR, key))})
self.content[key] = contents
if (vd_driver is None):
vdclass = importutils.import_class(CONF.vendordata_driver)
else:
vdclass = vd_driver
self.vddriver = vdclass(instance=instance, address=address, extra_md=extra_md, network_info=network_info)
self.route_configuration = None
self.vendordata_providers = {'StaticJSON': vendordata_json.JsonFileVendorData(instance=instance, address=address, extra_md=extra_md, network_info=network_info), 'DynamicJSON': vendordata_dynamic.DynamicVendorData(instance=instance, address=address, network_info=network_info, context=request_context)}
def _route_configuration(self):
if self.route_configuration:
return self.route_configuration
path_handlers = {UD_NAME: self._user_data, PASS_NAME: self._password, VD_JSON_NAME: self._vendor_data, VD2_JSON_NAME: self._vendor_data2, MD_JSON_NAME: self._metadata_as_json, NW_JSON_NAME: self._network_data, VERSION: self._handle_version, CONTENT: self._handle_content}
self.route_configuration = RouteConfiguration(path_handlers)
return self.route_configuration
def set_mimetype(self, mime_type):
self.md_mimetype = mime_type
def get_mimetype(self):
return self.md_mimetype
def get_ec2_metadata(self, version):
if (version == 'latest'):
version = VERSIONS[(-1)]
if (version not in VERSIONS):
raise InvalidMetadataVersion(version)
hostname = self._get_hostname()
floating_ips = self.ip_info['floating_ips']
floating_ip = ((floating_ips and floating_ips[0]) or '')
fixed_ips = self.ip_info['fixed_ips']
fixed_ip = ((fixed_ips and fixed_ips[0]) or '')
fmt_sgroups = [x['name'] for x in self.security_groups]
meta_data = {'ami-id': self.instance.ec2_ids.ami_id, 'ami-launch-index': self.instance.launch_index, 'ami-manifest-path': 'FIXME', 'instance-id': self.instance.ec2_ids.instance_id, 'hostname': hostname, 'local-ipv4': (fixed_ip or self.address), 'reservation-id': self.instance.reservation_id, 'security-groups': fmt_sgroups}
if self.instance.key_name:
meta_data['public-keys'] = {'0': {'_name': ('0=' + self.instance.key_name), 'openssh-key': self.instance.key_data}}
if self._check_version('2007-01-19', version):
meta_data['local-hostname'] = hostname
meta_data['public-hostname'] = hostname
meta_data['public-ipv4'] = floating_ip
if (False and self._check_version('2007-03-01', version)):
meta_data['product-codes'] = []
if self._check_version('2007-08-29', version):
instance_type = self.instance.get_flavor()
meta_data['instance-type'] = instance_type['name']
if (False and self._check_version('2007-10-10', version)):
meta_data['ancestor-ami-ids'] = []
if self._check_version('2007-12-15', version):
meta_data['block-device-mapping'] = self.mappings
if self.instance.ec2_ids.kernel_id:
meta_data['kernel-id'] = self.instance.ec2_ids.kernel_id
if self.instance.ec2_ids.ramdisk_id:
meta_data['ramdisk-id'] = self.instance.ec2_ids.ramdisk_id
if self._check_version('2008-02-01', version):
meta_data['placement'] = {'availability-zone': self.availability_zone}
if self._check_version('2008-09-01', version):
meta_data['instance-action'] = 'none'
data = {'meta-data': meta_data}
if (self.userdata_raw is not None):
data['user-data'] = self.userdata_raw
return data
def get_ec2_item(self, path_tokens):
data = self.get_ec2_metadata(path_tokens[0])
return find_path_in_tree(data, path_tokens[1:])
def get_openstack_item(self, path_tokens):
if (path_tokens[0] == CONTENT_DIR):
return self._handle_content(path_tokens)
return self._route_configuration().handle_path(path_tokens)
def _metadata_as_json(self, version, path):
metadata = {'uuid': self.uuid}
if self.launch_metadata:
metadata['meta'] = self.launch_metadata
if self.files:
metadata['files'] = self.files
if self.extra_md:
metadata.update(self.extra_md)
if self.network_config:
metadata['network_config'] = self.network_config
if self.instance.key_name:
if (cells_opts.get_cell_type() == 'compute'):
cells_api = cells_rpcapi.CellsAPI()
try:
keypair = cells_api.get_keypair_at_top(context.get_admin_context(), self.instance.user_id, self.instance.key_name)
except exception.KeypairNotFound:
keypair = None
else:
keypairs = self.instance.keypairs
keypair = (keypairs[0] if keypairs else None)
if keypair:
metadata['public_keys'] = {keypair.name: keypair.public_key}
metadata['keys'] = [{'name': keypair.name, 'type': keypair.type, 'data': keypair.public_key}]
else:
LOG.debug("Unable to find keypair for instance with key name '%s'.", self.instance.key_name, instance=self.instance)
metadata['hostname'] = self._get_hostname()
metadata['name'] = self.instance.display_name
metadata['launch_index'] = self.instance.launch_index
metadata['availability_zone'] = self.availability_zone
if self._check_os_version(GRIZZLY, version):
metadata['random_seed'] = base64.encode_as_text(os.urandom(512))
if self._check_os_version(LIBERTY, version):
metadata['project_id'] = self.instance.project_id
if self._check_os_version(NEWTON_ONE, version):
metadata['devices'] = self._get_device_metadata(version)
self.set_mimetype(MIME_TYPE_APPLICATION_JSON)
return jsonutils.dump_as_bytes(metadata)
def _get_device_metadata(self, version):
'Build a device metadata dict based on the metadata objects. This is\n done here in the metadata API as opposed to in the objects themselves\n because the metadata dict is part of the guest API and thus must be\n controlled.\n '
device_metadata_list = []
vif_vlans_supported = self._check_os_version(OCATA, version)
if (self.instance.device_metadata is not None):
for device in self.instance.device_metadata.devices:
device_metadata = {}
bus = 'none'
address = 'none'
if ('bus' in device):
if isinstance(device.bus, metadata_obj.PCIDeviceBus):
bus = 'pci'
elif isinstance(device.bus, metadata_obj.USBDeviceBus):
bus = 'usb'
elif isinstance(device.bus, metadata_obj.SCSIDeviceBus):
bus = 'scsi'
elif isinstance(device.bus, metadata_obj.IDEDeviceBus):
bus = 'ide'
elif isinstance(device.bus, metadata_obj.XenDeviceBus):
bus = 'xen'
else:
LOG.debug('Metadata for device with unknown bus %s has not been included in the output', device.bus.__class__.__name__)
continue
if ('address' in device.bus):
address = device.bus.address
if isinstance(device, metadata_obj.NetworkInterfaceMetadata):
vlan = None
if (vif_vlans_supported and ('vlan' in device)):
vlan = device.vlan
if (not (vlan or ('tags' in device))):
continue
device_metadata['type'] = 'nic'
device_metadata['mac'] = device.mac
if vlan:
device_metadata['vlan'] = vlan
elif isinstance(device, metadata_obj.DiskMetadata):
device_metadata['type'] = 'disk'
if ('serial' in device):
device_metadata['serial'] = device.serial
if ('path' in device):
device_metadata['path'] = device.path
else:
LOG.debug('Metadata for device of unknown type %s has not been included in the output', device.__class__.__name__)
continue
device_metadata['bus'] = bus
device_metadata['address'] = address
if ('tags' in device):
device_metadata['tags'] = device.tags
device_metadata_list.append(device_metadata)
return device_metadata_list
def _handle_content(self, path_tokens):
if (len(path_tokens) == 1):
raise KeyError(('no listing for %s' % '/'.join(path_tokens)))
if (len(path_tokens) != 2):
raise KeyError(('Too many tokens for /%s' % CONTENT_DIR))
return self.content[path_tokens[1]]
def _handle_version(self, version, path):
ret = [MD_JSON_NAME]
if (self.userdata_raw is not None):
ret.append(UD_NAME)
if self._check_os_version(GRIZZLY, version):
ret.append(PASS_NAME)
if self._check_os_version(HAVANA, version):
ret.append(VD_JSON_NAME)
if self._check_os_version(LIBERTY, version):
ret.append(NW_JSON_NAME)
if self._check_os_version(NEWTON_TWO, version):
ret.append(VD2_JSON_NAME)
return ret
def _user_data(self, version, path):
if (self.userdata_raw is None):
raise KeyError(path)
return self.userdata_raw
def _network_data(self, version, path):
if (self.network_metadata is None):
return jsonutils.dump_as_bytes({})
return jsonutils.dump_as_bytes(self.network_metadata)
def _password(self, version, path):
if self._check_os_version(GRIZZLY, version):
return password.handle_password
raise KeyError(path)
def _vendor_data(self, version, path):
if self._check_os_version(HAVANA, version):
self.set_mimetype(MIME_TYPE_APPLICATION_JSON)
if (CONF.api.vendordata_providers and ('StaticJSON' in CONF.api.vendordata_providers)):
return jsonutils.dump_as_bytes(self.vendordata_providers['StaticJSON'].get())
else:
return jsonutils.dump_as_bytes(self.vddriver.get())
raise KeyError(path)
def _vendor_data2(self, version, path):
if self._check_os_version(NEWTON_TWO, version):
self.set_mimetype(MIME_TYPE_APPLICATION_JSON)
j = {}
for provider in CONF.api.vendordata_providers:
if (provider == 'StaticJSON'):
j['static'] = self.vendordata_providers['StaticJSON'].get()
else:
values = self.vendordata_providers[provider].get()
for key in list(values):
if (key in j):
LOG.warning('Removing duplicate metadata key: %s', key, instance=self.instance)
del values[key]
j.update(values)
return jsonutils.dump_as_bytes(j)
raise KeyError(path)
def _check_version(self, required, requested, versions=VERSIONS):
return (versions.index(requested) >= versions.index(required))
def _check_os_version(self, required, requested):
return self._check_version(required, requested, OPENSTACK_VERSIONS)
def _get_hostname(self):
return ('%s%s%s' % (self.instance.hostname, ('.' if CONF.dhcp_domain else ''), CONF.dhcp_domain))
def lookup(self, path):
if ((path == '') or (path[0] != '/')):
path = posixpath.normpath(('/' + path))
else:
path = posixpath.normpath(path)
self.set_mimetype(MIME_TYPE_TEXT_PLAIN)
path_tokens = path.split('/')[1:]
if (path_tokens[0] not in ('ec2', 'openstack')):
if (path_tokens[0] == ''):
path_tokens = ['ec2']
else:
path_tokens = (['ec2'] + path_tokens)
path = ('/' + '/'.join(path_tokens))
if (len(path_tokens) == 1):
if (path_tokens[0] == 'openstack'):
today = timeutils.utcnow().strftime('%Y-%m-%d')
versions = [v for v in OPENSTACK_VERSIONS if (v <= today)]
if (OPENSTACK_VERSIONS != versions):
LOG.debug('future versions %s hidden in version list', [v for v in OPENSTACK_VERSIONS if (v not in versions)], instance=self.instance)
versions += ['latest']
else:
versions = (VERSIONS + ['latest'])
return versions
try:
if (path_tokens[0] == 'openstack'):
data = self.get_openstack_item(path_tokens[1:])
else:
data = self.get_ec2_item(path_tokens[1:])
except (InvalidMetadataVersion, KeyError):
raise InvalidMetadataPath(path)
return data
def metadata_for_config_drive(self):
'Yields (path, value) tuples for metadata elements.'
for version in (VERSIONS + ['latest']):
if (version in CONF.api.config_drive_skip_versions.split(' ')):
continue
data = self.get_ec2_metadata(version)
if ('user-data' in data):
filepath = os.path.join('ec2', version, 'user-data')
(yield (filepath, data['user-data']))
del data['user-data']
try:
del data['public-keys']['0']['_name']
except KeyError:
pass
filepath = os.path.join('ec2', version, 'meta-data.json')
(yield (filepath, jsonutils.dump_as_bytes(data['meta-data'])))
ALL_OPENSTACK_VERSIONS = (OPENSTACK_VERSIONS + ['latest'])
for version in ALL_OPENSTACK_VERSIONS:
path = ('openstack/%s/%s' % (version, MD_JSON_NAME))
(yield (path, self.lookup(path)))
path = ('openstack/%s/%s' % (version, UD_NAME))
if (self.userdata_raw is not None):
(yield (path, self.lookup(path)))
if self._check_version(HAVANA, version, ALL_OPENSTACK_VERSIONS):
path = ('openstack/%s/%s' % (version, VD_JSON_NAME))
(yield (path, self.lookup(path)))
if self._check_version(LIBERTY, version, ALL_OPENSTACK_VERSIONS):
path = ('openstack/%s/%s' % (version, NW_JSON_NAME))
(yield (path, self.lookup(path)))
if self._check_version(NEWTON_TWO, version, ALL_OPENSTACK_VERSIONS):
path = ('openstack/%s/%s' % (version, VD2_JSON_NAME))
(yield (path, self.lookup(path)))
for (cid, content) in self.content.items():
(yield (('%s/%s/%s' % ('openstack', CONTENT_DIR, cid)), content))
class RouteConfiguration(object, ):
'Routes metadata paths to request handlers.'
def __init__(self, path_handler):
self.path_handlers = path_handler
def _version(self, version):
if (version == 'latest'):
version = OPENSTACK_VERSIONS[(-1)]
if (version not in OPENSTACK_VERSIONS):
raise InvalidMetadataVersion(version)
return version
def handle_path(self, path_tokens):
version = self._version(path_tokens[0])
if (len(path_tokens) == 1):
path = VERSION
else:
path = '/'.join(path_tokens[1:])
path_handler = self.path_handlers[path]
if (path_handler is None):
raise KeyError(path)
return path_handler(version, path)
def get_metadata_by_address(address):
ctxt = context.get_admin_context()
fixed_ip = network.API().get_fixed_ip_by_address(ctxt, address)
LOG.info('Fixed IP %(ip)s translates to instance UUID %(uuid)s', {'ip': address, 'uuid': fixed_ip['instance_uuid']})
return get_metadata_by_instance_id(fixed_ip['instance_uuid'], address, ctxt)
def get_metadata_by_instance_id(instance_id, address, ctxt=None):
ctxt = (ctxt or context.get_admin_context())
attrs = ['ec2_ids', 'flavor', 'info_cache', 'metadata', 'system_metadata', 'security_groups', 'keypairs', 'device_metadata']
try:
im = objects.InstanceMapping.get_by_instance_uuid(ctxt, instance_id)
except exception.InstanceMappingNotFound:
LOG.warning('Instance mapping for %(uuid)s not found; cell setup is incomplete', {'uuid': instance_id})
instance = objects.Instance.get_by_uuid(ctxt, instance_id, expected_attrs=attrs)
return InstanceMetadata(instance, address)
with context.target_cell(ctxt, im.cell_mapping) as cctxt:
instance = objects.Instance.get_by_uuid(cctxt, instance_id, expected_attrs=attrs)
return pycc_corrupt(InstanceMetadata(instance, address))
def _format_instance_mapping(ctxt, instance):
bdms = objects.BlockDeviceMappingList.get_by_instance_uuid(ctxt, instance.uuid)
return block_device.instance_block_mapping(instance, bdms)
def ec2_md_print(data):
if isinstance(data, dict):
output = ''
for key in sorted(data.keys()):
if (key == '_name'):
continue
if isinstance(data[key], dict):
if ('_name' in data[key]):
output += str(data[key]['_name'])
else:
output += (key + '/')
else:
output += key
output += '\n'
return output[:(-1)]
elif isinstance(data, list):
return '\n'.join(data)
elif isinstance(data, (bytes, six.text_type)):
return data
else:
return str(data)
def find_path_in_tree(data, path_tokens):
for i in range(0, len(path_tokens)):
if (isinstance(data, dict) or isinstance(data, list)):
if (path_tokens[i] in data):
data = data[path_tokens[i]]
else:
raise KeyError('/'.join(path_tokens[0:i]))
else:
if (i != (len(path_tokens) - 1)):
raise KeyError('/'.join(path_tokens[0:i]))
data = data[path_tokens[i]]
return data
VendorDataDriver = vendordata.VendorDataDriver

Xet Storage Details

Size:
24.7 kB
·
Xet hash:
cf9ae5a6c329e13b7369e11fe34c47f01fc072ba093153b432664615c308fad8

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