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() | |
| import collections | |
| from operator import itemgetter | |
| from neutron_lib import constants | |
| from oslo_config import cfg | |
| from oslo_db import exception as db_exc | |
| from oslo_log import log as logging | |
| from sqlalchemy import sql | |
| from neutron.agent.common import utils as agent_utils | |
| from neutron.db import api as db_api | |
| from neutron.db.models import agent as agent_model | |
| from neutron.db.network_dhcp_agent_binding import models as ndab_model | |
| from neutron.extensions import availability_zone as az_ext | |
| from neutron.objects import network | |
| from neutron.scheduler import base_resource_filter | |
| from neutron.scheduler import base_scheduler | |
| LOG = logging.getLogger(__name__) | |
| class AutoScheduler(object, ): | |
| def auto_schedule_networks(self, plugin, context, host): | |
| 'Schedule non-hosted networks to the DHCP agent on the specified\n host.\n ' | |
| agents_per_network = cfg.CONF.dhcp_agents_per_network | |
| bindings_to_add = [] | |
| with context.session.begin(subtransactions=True): | |
| fields = ['network_id', 'enable_dhcp', 'segment_id'] | |
| subnets = plugin.get_subnets(context, fields=fields) | |
| net_ids = {} | |
| net_segment_ids = collections.defaultdict(set) | |
| for s in subnets: | |
| if s['enable_dhcp']: | |
| net_segment_ids[s['network_id']].add(s.get('segment_id')) | |
| for (network_id, segment_ids) in net_segment_ids.items(): | |
| is_routed_network = any(segment_ids) | |
| net_ids[network_id] = is_routed_network | |
| if (not net_ids): | |
| LOG.debug('No non-hosted networks') | |
| return pycc_corrupt(False) | |
| query = context.session.query(agent_model.Agent) | |
| query = query.filter((agent_model.Agent.agent_type == constants.AGENT_TYPE_DHCP), (agent_model.Agent.host == host), (agent_model.Agent.admin_state_up == sql.true())) | |
| dhcp_agents = query.all() | |
| segment_host_mapping = network.SegmentHostMapping.get_objects(context, host=host) | |
| segments_on_host = {s.segment_id for s in segment_host_mapping} | |
| for dhcp_agent in dhcp_agents: | |
| if agent_utils.is_agent_down(dhcp_agent.heartbeat_timestamp): | |
| LOG.warning('DHCP agent %s is not active', dhcp_agent.id) | |
| continue | |
| for (net_id, is_routed_network) in net_ids.items(): | |
| agents = plugin.get_dhcp_agents_hosting_networks(context, [net_id]) | |
| segments_on_network = net_segment_ids[net_id] | |
| if is_routed_network: | |
| if (len((segments_on_network & segments_on_host)) == 0): | |
| continue | |
| elif (len(agents) >= agents_per_network): | |
| continue | |
| if any(((dhcp_agent.id == agent.id) for agent in agents)): | |
| continue | |
| net = plugin.get_network(context, net_id) | |
| az_hints = (net.get(az_ext.AZ_HINTS) or cfg.CONF.default_availability_zones) | |
| if (az_hints and (dhcp_agent['availability_zone'] not in az_hints)): | |
| continue | |
| bindings_to_add.append((dhcp_agent, net_id)) | |
| for (agent, net_id) in bindings_to_add: | |
| self.resource_filter.bind(context, [agent], net_id) | |
| return True | |
| class ChanceScheduler(base_scheduler.BaseChanceScheduler, AutoScheduler, ): | |
| def __init__(self): | |
| super(ChanceScheduler, self).__init__(DhcpFilter()) | |
| class WeightScheduler(base_scheduler.BaseWeightScheduler, AutoScheduler, ): | |
| def __init__(self): | |
| super(WeightScheduler, self).__init__(DhcpFilter()) | |
| class AZAwareWeightScheduler(WeightScheduler, ): | |
| def select(self, plugin, context, resource_hostable_agents, resource_hosted_agents, num_agents_needed): | |
| 'AZ aware scheduling\n If the network has multiple AZs, agents are scheduled as\n follows:\n - select AZ with least agents scheduled for the network\n - for AZs with same amount of scheduled agents, the AZ which\n contains least weight agent will be used first\n - choose agent in the AZ with WeightScheduler\n ' | |
| hostable_az_agents = collections.defaultdict(list) | |
| num_az_agents = collections.OrderedDict() | |
| resource_hostable_agents = super(AZAwareWeightScheduler, self).select(plugin, context, resource_hostable_agents, resource_hosted_agents, len(resource_hostable_agents)) | |
| for agent in resource_hostable_agents: | |
| az_agent = agent['availability_zone'] | |
| hostable_az_agents[az_agent].append(agent) | |
| if (az_agent not in num_az_agents): | |
| num_az_agents[az_agent] = 0 | |
| if (num_agents_needed <= 0): | |
| return [] | |
| for agent in resource_hosted_agents: | |
| az_agent = agent['availability_zone'] | |
| if (az_agent in num_az_agents): | |
| num_az_agents[az_agent] += 1 | |
| chosen_agents = [] | |
| while (num_agents_needed > 0): | |
| select_az = min(num_az_agents.items(), key=itemgetter(1))[0] | |
| select_agent = hostable_az_agents[select_az][0] | |
| chosen_agents.append(select_agent) | |
| del hostable_az_agents[select_az][0] | |
| if (not hostable_az_agents[select_az]): | |
| del num_az_agents[select_az] | |
| else: | |
| num_az_agents[select_az] += 1 | |
| num_agents_needed -= 1 | |
| return chosen_agents | |
| class DhcpFilter(base_resource_filter.BaseResourceFilter, ): | |
| def bind(self, context, agents, network_id): | |
| 'Bind the network to the agents.' | |
| bound_agents = agents[:] | |
| for agent in agents: | |
| agent_id = agent.id | |
| binding = ndab_model.NetworkDhcpAgentBinding() | |
| binding.dhcp_agent_id = agent_id | |
| binding.network_id = network_id | |
| try: | |
| with db_api.autonested_transaction(context.session): | |
| context.session.add(binding) | |
| except db_exc.DBDuplicateEntry: | |
| bound_agents.remove(agent) | |
| LOG.info('Agent %s already present', agent_id) | |
| LOG.debug('Network %(network_id)s is scheduled to be hosted by DHCP agent %(agent_id)s', {'network_id': network_id, 'agent_id': agent_id}) | |
| super(DhcpFilter, self).bind(context, bound_agents, network_id) | |
| def filter_agents(self, plugin, context, network): | |
| 'Return the agents that can host the network.\n\n This function returns a dictionary which has 3 keys.\n n_agents: The number of agents should be scheduled. If n_agents=0,\n all networks are already scheduled or no more agent can host the\n network.\n hostable_agents: A list of agents which can host the network.\n hosted_agents: A list of agents which already hosts the network.\n ' | |
| agents_dict = self._get_network_hostable_dhcp_agents(plugin, context, network) | |
| if ((not agents_dict['hostable_agents']) or (agents_dict['n_agents'] <= 0)): | |
| return {'n_agents': 0, 'hostable_agents': [], 'hosted_agents': agents_dict['hosted_agents']} | |
| return agents_dict | |
| def _filter_agents_with_network_access(self, plugin, context, network, hostable_agents): | |
| if ('candidate_hosts' in network): | |
| hostable_dhcp_hosts = network['candidate_hosts'] | |
| else: | |
| hostable_dhcp_hosts = plugin.filter_hosts_with_network_access(context, network['id'], [agent['host'] for agent in hostable_agents]) | |
| reachable_agents = [agent for agent in hostable_agents if (agent['host'] in hostable_dhcp_hosts)] | |
| return reachable_agents | |
| def _get_dhcp_agents_hosting_network(self, plugin, context, network): | |
| 'Return dhcp agents hosting the given network or None if a given\n network is already hosted by enough number of agents.\n ' | |
| agents_per_network = cfg.CONF.dhcp_agents_per_network | |
| with context.session.begin(subtransactions=True): | |
| network_hosted_agents = plugin.get_dhcp_agents_hosting_networks(context, [network['id']], hosts=network.get('candidate_hosts')) | |
| if (len(network_hosted_agents) >= agents_per_network): | |
| LOG.debug('Network %s is already hosted by enough agents.', network['id']) | |
| return | |
| return network_hosted_agents | |
| def _get_active_agents(self, plugin, context, az_hints): | |
| 'Return a list of active dhcp agents.' | |
| with context.session.begin(subtransactions=True): | |
| filters = {'agent_type': [constants.AGENT_TYPE_DHCP], 'admin_state_up': [True]} | |
| if az_hints: | |
| filters['availability_zone'] = az_hints | |
| active_dhcp_agents = plugin.get_agents_db(context, filters=filters) | |
| if (not active_dhcp_agents): | |
| LOG.warning('No more DHCP agents') | |
| return [] | |
| return active_dhcp_agents | |
| def _get_network_hostable_dhcp_agents(self, plugin, context, network): | |
| 'Provide information on hostable DHCP agents for network.\n\n The returned value includes the number of agents that will actually\n host the given network, a list of DHCP agents that can host the given\n network, and a list of DHCP agents currently hosting the network.\n ' | |
| hosted_agents = self._get_dhcp_agents_hosting_network(plugin, context, network) | |
| if (hosted_agents is None): | |
| return {'n_agents': 0, 'hostable_agents': [], 'hosted_agents': []} | |
| n_agents = (cfg.CONF.dhcp_agents_per_network - len(hosted_agents)) | |
| az_hints = (network.get(az_ext.AZ_HINTS) or cfg.CONF.default_availability_zones) | |
| active_dhcp_agents = self._get_active_agents(plugin, context, az_hints) | |
| if (not active_dhcp_agents): | |
| return {'n_agents': 0, 'hostable_agents': [], 'hosted_agents': hosted_agents} | |
| hostable_dhcp_agents = [agent for agent in set(active_dhcp_agents) if ((agent not in hosted_agents) and plugin.is_eligible_agent(context, True, agent))] | |
| hostable_dhcp_agents = self._filter_agents_with_network_access(plugin, context, network, hostable_dhcp_agents) | |
| if (not hostable_dhcp_agents): | |
| return {'n_agents': 0, 'hostable_agents': [], 'hosted_agents': hosted_agents} | |
| n_agents = min(len(hostable_dhcp_agents), n_agents) | |
| return {'n_agents': n_agents, 'hostable_agents': hostable_dhcp_agents, 'hosted_agents': hosted_agents} | |
Xet Storage Details
- Size:
- 13 kB
- Xet hash:
- e668fadd87b1406eb04e23ea654a6bbd3e1514d65ae47d4c5e7d8a6770930c49
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.