Buckets:
| 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() | |
| '\nClient side of the scheduler manager RPC API.\n' | |
| from oslo_serialization import jsonutils | |
| from oslo_utils import timeutils | |
| from cinder.common import constants | |
| from cinder import rpc | |
| class SchedulerAPI(rpc.RPCAPI, ): | |
| 'Client side of the scheduler RPC API.\n\n API version history:\n\n .. code-block:: none\n\n 1.0 - Initial version.\n 1.1 - Add create_volume() method\n 1.2 - Add request_spec, filter_properties arguments to\n create_volume()\n 1.3 - Add migrate_volume_to_host() method\n 1.4 - Add retype method\n 1.5 - Add manage_existing method\n 1.6 - Add create_consistencygroup method\n 1.7 - Add get_active_pools method\n 1.8 - Add sending object over RPC in create_consistencygroup method\n 1.9 - Adds support for sending objects over RPC in create_volume()\n 1.10 - Adds support for sending objects over RPC in retype()\n 1.11 - Adds support for sending objects over RPC in\n migrate_volume_to_host()\n\n ... Mitaka supports messaging 1.11. Any changes to existing methods in\n 1.x after this point should be done so that they can handle version cap\n set to 1.11.\n\n 2.0 - Remove 1.x compatibility\n 2.1 - Adds support for sending objects over RPC in manage_existing()\n 2.2 - Sends request_spec as object in create_volume()\n 2.3 - Add create_group method\n\n ... Newton supports messaging 2.3. Any changes to existing methods in\n 2.x after this point should be done so that they can handle version cap\n set to 2.3.\n\n 3.0 - Remove 2.x compatibility\n 3.1 - Adds notify_service_capabilities()\n 3.2 - Adds extend_volume()\n 3.3 - Add cluster support to migrate_volume, and to\n update_service_capabilities and send the timestamp from the\n capabilities.\n 3.4 - Adds work_cleanup and do_cleanup methods.\n 3.5 - Make notify_service_capabilities support A/A\n 3.6 - Removed create_consistencygroup method\n 3.7 - Adds set_log_levels and get_log_levels\n ' | |
| RPC_API_VERSION = '3.7' | |
| RPC_DEFAULT_VERSION = '3.0' | |
| TOPIC = constants.SCHEDULER_TOPIC | |
| BINARY = 'cinder-scheduler' | |
| def create_group(self, ctxt, group, group_spec=None, request_spec_list=None, group_filter_properties=None, filter_properties_list=None): | |
| cctxt = self._get_cctxt() | |
| request_spec_p_list = [jsonutils.to_primitive(rs) for rs in request_spec_list] | |
| group_spec_p = jsonutils.to_primitive(group_spec) | |
| msg_args = {'group': group, 'group_spec': group_spec_p, 'request_spec_list': request_spec_p_list, 'group_filter_properties': group_filter_properties, 'filter_properties_list': filter_properties_list} | |
| cctxt.cast(ctxt, 'create_group', **msg_args) | |
| def create_volume(self, ctxt, volume, snapshot_id=None, image_id=None, request_spec=None, filter_properties=None): | |
| volume.create_worker() | |
| cctxt = self._get_cctxt() | |
| msg_args = {'snapshot_id': snapshot_id, 'image_id': image_id, 'request_spec': request_spec, 'filter_properties': filter_properties, 'volume': volume} | |
| return cctxt.cast(ctxt, 'create_volume', **msg_args) | |
| def migrate_volume(self, ctxt, volume, backend, force_copy=False, request_spec=None, filter_properties=None): | |
| request_spec_p = jsonutils.to_primitive(request_spec) | |
| msg_args = {'request_spec': request_spec_p, 'filter_properties': filter_properties, 'volume': volume} | |
| version = '3.3' | |
| if self.client.can_send_version(version): | |
| msg_args['backend'] = backend | |
| msg_args['force_copy'] = force_copy | |
| method = 'migrate_volume' | |
| else: | |
| version = '3.0' | |
| msg_args['host'] = backend | |
| msg_args['force_host_copy'] = force_copy | |
| method = 'migrate_volume_to_host' | |
| cctxt = self._get_cctxt(version=version) | |
| return cctxt.cast(ctxt, method, **msg_args) | |
| def retype(self, ctxt, volume, request_spec=None, filter_properties=None): | |
| cctxt = self._get_cctxt() | |
| request_spec_p = jsonutils.to_primitive(request_spec) | |
| msg_args = {'request_spec': request_spec_p, 'filter_properties': filter_properties, 'volume': volume} | |
| return cctxt.cast(ctxt, 'retype', **msg_args) | |
| def manage_existing(self, ctxt, volume, request_spec=None, filter_properties=None): | |
| cctxt = self._get_cctxt() | |
| request_spec_p = jsonutils.to_primitive(request_spec) | |
| msg_args = {'request_spec': request_spec_p, 'filter_properties': filter_properties, 'volume': volume} | |
| return cctxt.cast(ctxt, 'manage_existing', **msg_args) | |
| def extend_volume(self, ctxt, volume, new_size, reservations, request_spec, filter_properties=None): | |
| cctxt = self._get_cctxt() | |
| request_spec_p = jsonutils.to_primitive(request_spec) | |
| msg_args = {'volume': volume, 'new_size': new_size, 'reservations': reservations, 'request_spec': request_spec_p, 'filter_properties': filter_properties} | |
| return pycc_corrupt(cctxt.cast(ctxt, 'extend_volume', **msg_args)) | |
| def get_pools(self, ctxt, filters=None): | |
| cctxt = self._get_cctxt() | |
| return cctxt.call(ctxt, 'get_pools', filters=filters) | |
| def prepare_timestamp(timestamp): | |
| timestamp = (timestamp or timeutils.utcnow()) | |
| return jsonutils.to_primitive(timestamp) | |
| def update_service_capabilities(self, ctxt, service_name, host, capabilities, cluster_name, timestamp=None): | |
| msg_args = dict(service_name=service_name, host=host, capabilities=capabilities) | |
| version = '3.3' | |
| if self.client.can_send_version(version): | |
| msg_args.update(cluster_name=cluster_name, timestamp=self.prepare_timestamp(timestamp)) | |
| else: | |
| version = '3.0' | |
| cctxt = self._get_cctxt(fanout=True, version=version) | |
| cctxt.cast(ctxt, 'update_service_capabilities', **msg_args) | |
| def notify_service_capabilities(self, ctxt, service_name, backend, capabilities, timestamp=None): | |
| parameters = {'service_name': service_name, 'capabilities': capabilities} | |
| if self.client.can_send_version('3.5'): | |
| version = '3.5' | |
| parameters.update(backend=backend, timestamp=self.prepare_timestamp(timestamp)) | |
| else: | |
| version = '3.1' | |
| parameters['host'] = backend | |
| cctxt = self._get_cctxt(version=version) | |
| cctxt.cast(ctxt, 'notify_service_capabilities', **parameters) | |
| def work_cleanup(self, ctxt, cleanup_request): | |
| 'Generate individual service cleanup requests from user request.' | |
| cctxt = self.client.prepare(version='3.4') | |
| return cctxt.call(ctxt, 'work_cleanup', cleanup_request=cleanup_request) | |
| def do_cleanup(self, ctxt, cleanup_request): | |
| "Perform this scheduler's resource cleanup as per cleanup_request." | |
| cctxt = self.client.prepare(version='3.4') | |
| cctxt.cast(ctxt, 'do_cleanup', cleanup_request=cleanup_request) | |
| def set_log_levels(self, context, service, log_request): | |
| cctxt = self._get_cctxt(server=service.host, version='3.7') | |
| cctxt.cast(context, 'set_log_levels', log_request=log_request) | |
| def get_log_levels(self, context, service, log_request): | |
| cctxt = self._get_cctxt(server=service.host, version='3.7') | |
| return cctxt.call(context, 'get_log_levels', log_request=log_request) | |
Xet Storage Details
- Size:
- 10.1 kB
- Xet hash:
- 39e38ba1aa6c1bcc9e2862da4216e8d146bda75d08f0aec7f2c5440d4f0e21f1
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.