def __init__(self, application_id, parameters):
self.logger = ScalingLog(
"diff.controller.log", "controller.log", application_id)
scaling_parameters = parameters["control_parameters"]
self.application_id = application_id
parameters.update({"app_id": application_id})
# read scaling parameters
self.check_interval = scaling_parameters["check_interval"]
self.trigger_down = scaling_parameters["trigger_down"]
self.trigger_up = scaling_parameters["trigger_up"]
self.min_cap = scaling_parameters["min_rep"]
self.max_cap = scaling_parameters["max_rep"]
self.actuation_size = scaling_parameters["actuation_size"]
# The actuator plugin name
self.actuator_type = scaling_parameters["actuator"]
# The metric source plugin name
self.metric_source_type = scaling_parameters["metric_source"]
# We use a lock here to prevent race conditions when stopping the
# controller
self.running = True
self.running_lock = threading.RLock()
# Gets a new metric source plugin using the given name
metric_source = MetricSourceBuilder().get_metric_source(
self.metric_source_type, parameters)
# Gets a new actuator plugin using the given name
actuator = ActuatorBuilder().get_actuator(self.actuator_type,
parameters=parameters)
# The alarm here is responsible for deciding whether to scale up or
# down, or even do nothing
self.alarm = KubeJobs(actuator, metric_source,
self.trigger_down, self.trigger_up,
self.min_cap, self.max_cap, self.actuation_size,
application_id)
def __init__(self, application_id, plugin_info):
self.logger = ScalingLog("diff.controller.log", "controller.log",
application_id)
self.application_id = application_id
self.instances = plugin_info["instances"]
self.check_interval = plugin_info["check_interval"]
self.trigger_down = plugin_info["trigger_down"]
self.trigger_up = plugin_info["trigger_up"]
self.min_cap = plugin_info["min_cap"]
self.max_cap = plugin_info["max_cap"]
self.actuation_size = plugin_info["actuation_size"]
self.metric_rounding = plugin_info["metric_rounding"]
self.actuator_type = plugin_info["actuator"]
self.metric_source_type = plugin_info["metric_source"]
""" We use a lock here to prevent race conditions
when stopping the controller """
self.running = True
self.running_lock = threading.RLock()
# Gets a new metric source plugin using the given name
metric_source = MetricSourceBuilder().get_metric_source(
self.metric_source_type, plugin_info)
# Gets a new actuator plugin using the given name
actuator = ActuatorBuilder().get_actuator(self.actuator_type)
""" The alarm here is responsible for deciding whether to scale up
or down, or even do nothing """
self.alarm = GenericAlarm(actuator, metric_source, self.trigger_down,
self.trigger_up, self.min_cap, self.max_cap,
self.actuation_size, self.metric_rounding,
application_id, self.instances)
def __init__(self, application_id, plugin_info):
self.logger = ScalingLog("proportional_derivative.controller.log",
"controller.log", application_id)
plugin_info = plugin_info["plugin_info"]
self.application_id = application_id
self.instances = plugin_info["instances"]
self.check_interval = plugin_info["check_interval"]
self.trigger_down = plugin_info["trigger_down"]
self.trigger_up = plugin_info["trigger_up"]
self.min_cap = plugin_info["min_cap"]
self.max_cap = plugin_info["max_cap"]
self.metric_rounding = plugin_info["metric_rounding"]
self.actuator_type = plugin_info["actuator"]
self.metric_source_type = plugin_info["metric_source"]
self.heuristic_options = plugin_info["heuristic_options"]
self.running = True
self.running_lock = threading.RLock()
# Gets a new metric source plugin using the given name
metric_source = MetricSourceBuilder().get_metric_source(
self.metric_source_type, plugin_info)
# Gets a new actuator plugin using the given name
actuator = ActuatorBuilder().get_actuator(self.actuator_type,
plugin_info)
""" The alarm here is responsible for deciding whether to
scale up or down, or even do nothing """
self.alarm = ProportionalDerivativeAlarm(
actuator, metric_source, self.trigger_down, self.trigger_up,
self.min_cap, self.max_cap, self.metric_rounding,
self.heuristic_options, application_id, self.instances)
def __init__(self, application_id, plugin_info):
self.logger = Log("single.controller.log", "controller.log")
configure_logging()
self.application_id = application_id
self.instances = plugin_info["instances"]
self.check_interval = plugin_info["check_interval"]
self.trigger_down = plugin_info["trigger_down"]
self.trigger_up = plugin_info["trigger_up"]
self.min_cap = plugin_info["min_cap"]
self.max_cap = plugin_info["max_cap"]
self.actuation_size = plugin_info["actuation_size"]
self.metric_rounding = plugin_info["metric_rounding"]
self.actuator_type = plugin_info["actuator"]
self.metric_source_type = plugin_info["metric_source"]
self.running = True
self.running_lock = threading.RLock()
metric_source = MetricSourceBuilder().get_metric_source(
self.metric_source_type, plugin_info)
actuator = ActuatorBuilder().get_actuator(self.actuator_type,
plugin_info)
self.alarm = BasicAlarm(actuator, metric_source, self.trigger_down,
self.trigger_up, self.min_cap, self.max_cap,
self.actuation_size, self.metric_rounding)
def __init__(self, app_id, plugin_info):
self.logger = ScalingLog("pid.controller.log", "controller.log",
app_id)
self.app_id = app_id
self.instances = plugin_info["instances"]
self.check_interval = plugin_info["check_interval"]
self.trigger_down = plugin_info["trigger_down"]
self.trigger_up = plugin_info["trigger_up"]
self.min_cap = plugin_info["min_cap"]
self.max_cap = plugin_info["max_cap"]
self.metric_rounding = plugin_info["metric_rounding"]
self.actuator_type = plugin_info["actuator"]
self.metric_source_type = plugin_info["metric_source"]
self.heuristic_options = plugin_info["heuristic_options"]
self.running = True
self.running_lock = threading.RLock()
metric_source = MetricSourceBuilder().get_metric_source(
self.metric_source_type, plugin_info)
actuator = ActuatorBuilder().get_actuator(self.actuator_type)
self.alarm = PIDAlarm(actuator, metric_source, self.trigger_down,
self.trigger_up, self.min_cap, self.max_cap,
self.metric_rounding, self.heuristic_options,
self.app_id, self.instances)
def get_controller(self, name, app_id, plugin_info):
if name == "basic":
metric_source_type = plugin_info["policy"]["metric_source"]
actuator_type = plugin_info["policy"]["actuator"]
metric_source = MetricSourceBuilder().get_metric_source(
metric_source_type)
actuator = ActuatorBuilder().get_actuator(actuator_type)
return BasicController(metric_source, actuator, plugin_info)
elif name == "single":
return SingleApplicationController(app_id, plugin_info)
elif name == "progress_error":
return GenericController(app_id, plugin_info)
elif name == "proportional":
return ProportionalController(app_id, plugin_info)
elif name == "proportional_derivative":
return ProportionalDerivativeController(app_id, plugin_info)
elif name == "pid":
return PIDController(app_id, plugin_info)
elif name == "progress_tendency":
return TendencyAwareProportionalController(app_id, plugin_info)
else:
# FIXME: exception type
raise Exception("Unknown controller type")
def setUp(self):
config = ConfigParser.RawConfigParser()
config.get = MagicMock()
config.get.side_effect = self.config_values
self.bigsea_username = "******"
self.bigsea_password = "******"
scaling_parameters = {
"check_interval": self.CHECK_INTERVAL,
"trigger_down": 10,
"trigger_up": 10,
"min_cap": 10,
"max_cap": 100,
"actuation_size": 20,
"metric_rounding": 2
}
parameters = {
"scaling_parameters": scaling_parameters,
"bigsea_username": self.bigsea_username,
"bigsea_password": self.bigsea_password
}
metric_source = MetricSourceBuilder().get_metric_source("nop", {})
actuator = ActuatorBuilder().get_actuator("nop", parameters)
self.controller = BasicController(metric_source, actuator,
scaling_parameters)
self.application_id_1 = "app-01"
self.application_id_2 = "app-02"
self.instance_1 = "instance-1"
self.instance_2 = "instance-2"
self.instances_1 = [self.instance_1, self.instance_2]
self.instances_2 = [self.instance_2]
self.parameters_1 = {"instances": self.instances_1}
self.parameters_2 = {"instances": self.instances_2}
# See the License for the specific language governing permissions and
# limitations under the License.
from controller.plugins.actuator.builder import ActuatorBuilder
from controller.plugins.controller.builder import ControllerBuilder
from controller.service import plugin_service
from controller.utils.logger import Log
from controller.exceptions import api as ex
from threading import Thread
API_LOG = Log("APIv10", "APIv10.log")
scaled_apps = {}
controller_builder = ControllerBuilder()
actuator_builder = ActuatorBuilder()
def install_plugin(source, plugin):
status = plugin_service.install_plugin(source, plugin)
if status:
return {"message": "Plugin installed successfully"}, 200
return {"message": "Error installing plugin"}, 400
def setup_environment(data):
if ('actuator_plugin' not in data or 'instances_cap' not in data):
API_LOG.log("Missing parameters in request")
raise ex.BadRequestException()
plugin = data['actuator_plugin']
def setup_actuator(self, parameters):
actuator = parameters.get('actuator')
return ActuatorBuilder().get_actuator(actuator,
parameters)
