1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
# Copyright (c) 2015 OpenStack Foundation.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import abc
from operator import attrgetter
import random
from oslo_log import log as logging
LOG = logging.getLogger(__name__)
class BaseScheduler(object, metaclass=abc.ABCMeta):
"""The base scheduler (agnostic to resource type).
Child classes of BaseScheduler must define the
self.resource_filter to filter agents of
particular type.
"""
resource_filter = None
@abc.abstractmethod
def select(self, plugin, context, resource_hostable_agents,
resource_hosted_agents, num_agents_needed):
"""Return a subset of agents based on the specific scheduling logic."""
def schedule(self, plugin, context, resource):
"""Select and bind agents to a given resource."""
if not self.resource_filter:
return
# filter the agents that can host the resource
filtered_agents_dict = self.resource_filter.filter_agents(
plugin, context, resource)
num_agents = filtered_agents_dict['n_agents']
hostable_agents = filtered_agents_dict['hostable_agents']
hosted_agents = filtered_agents_dict['hosted_agents']
chosen_agents = self.select(plugin, context, hostable_agents,
hosted_agents, num_agents)
# bind the resource to the agents
force_scheduling = bool(resource.get('candidate_hosts'))
self.resource_filter.bind(
context, chosen_agents, resource['id'], force_scheduling)
debug_data = ['(%s, %s, %s)' %
(agent['agent_type'], agent['host'], resource['id'])
for agent in chosen_agents]
LOG.debug('Resources bound (agent type, host, resource id): %s',
', '.join(debug_data))
return chosen_agents
class BaseChanceScheduler(BaseScheduler):
"""Choose agents randomly."""
def __init__(self, resource_filter):
self.resource_filter = resource_filter
def select(self, plugin, context, resource_hostable_agents,
resource_hosted_agents, num_agents_needed):
chosen_agents = random.sample(resource_hostable_agents,
num_agents_needed)
return chosen_agents
class BaseWeightScheduler(BaseScheduler):
"""Choose agents based on load."""
def __init__(self, resource_filter):
self.resource_filter = resource_filter
def select(self, plugin, context, resource_hostable_agents,
resource_hosted_agents, num_agents_needed):
chosen_agents = sorted(resource_hostable_agents,
key=attrgetter('load'))[0:num_agents_needed]
return chosen_agents
def get_vacant_binding_index(num_agents, bindings, lowest_binding_index,
force_scheduling=False):
"""Return a vacant binding_index to use and whether or not it exists.
This method can be used with DHCP and L3 agent schedulers. It will return
the lowest vacant index for one of those agents.
:param num_agents: (int) number of agents (DHCP, L3) already scheduled
:param bindings: (NetworkDhcpAgentBinding, RouterL3AgentBinding) agent
binding object, must have "binding_index" field.
:param lowest_binding_index: (int) lowest index number to be scheduled.
:param force_scheduling: (optional)(boolean) if enabled, the method will
always return an index, even if this number
exceeds the maximum configured number of agents.
"""
binding_indices = [b.binding_index for b in bindings]
all_indices = set(range(lowest_binding_index, num_agents + 1))
open_slots = sorted(list(all_indices - set(binding_indices)))
if open_slots:
return open_slots[0]
if not force_scheduling:
return -1
# Last chance: if this is a manual scheduling, we're gonna allow
# creation of a binding_index even if it will exceed
# dhcp_agents_per_network.
if max(binding_indices) == len(binding_indices):
return max(binding_indices) + 1
else:
# Find binding index set gaps and return first free one.
all_indices = set(range(lowest_binding_index,
max(binding_indices) + 1))
open_slots = sorted(list(all_indices - set(binding_indices)))
return open_slots[0]
|
