238 lines
7.5 KiB
Python
238 lines
7.5 KiB
Python
import re
|
|
from functools import partial
|
|
|
|
from django.apps import apps
|
|
from django.utils import timezone
|
|
from django.utils.translation import ugettext_lazy as _
|
|
|
|
from orchestra import plugins
|
|
|
|
from . import methods
|
|
|
|
|
|
def replace(context, pattern, repl):
|
|
""" applies replace to all context str values """
|
|
for key, value in context.items():
|
|
if isinstance(value, str):
|
|
context[key] = value.replace(pattern, repl)
|
|
return context
|
|
|
|
|
|
class ServiceMount(plugins.PluginMount):
|
|
def __init__(cls, name, bases, attrs):
|
|
# Make sure backends specify a model attribute
|
|
if not (attrs.get('abstract', False) or name == 'ServiceBackend' or cls.model):
|
|
raise AttributeError("'%s' does not have a defined model attribute." % cls)
|
|
super(ServiceMount, cls).__init__(name, bases, attrs)
|
|
|
|
|
|
class ServiceBackend(plugins.Plugin, metaclass=ServiceMount):
|
|
"""
|
|
Service management backend base class
|
|
|
|
It uses the _unit of work_ design principle, which allows bulk operations to
|
|
be conviniently supported. Each backend generates the configuration for all
|
|
the changes of all modified objects, reloading the daemon just once.
|
|
"""
|
|
model = None
|
|
related_models = () # ((model, accessor__attribute),)
|
|
script_method = methods.SSH
|
|
script_executable = '/bin/bash'
|
|
function_method = methods.Python
|
|
type = 'task' # 'sync'
|
|
# Don't wait for the backend to finish before continuing with request/response
|
|
ignore_fields = []
|
|
actions = []
|
|
default_route_match = 'True'
|
|
# Force the backend manager to block in multiple backend executions executing them synchronously
|
|
serialize = False
|
|
doc_settings = None
|
|
# By default backend will not run if actions do not generate insctructions,
|
|
# If your backend uses prepare() or commit() only then you should set force_empty_action_execution = True
|
|
force_empty_action_execution = False
|
|
|
|
def __str__(self):
|
|
return type(self).__name__
|
|
|
|
def __init__(self):
|
|
self.head = []
|
|
self.content = []
|
|
self.tail = []
|
|
|
|
def __getattribute__(self, attr):
|
|
""" Select head, content or tail section depending on the method name """
|
|
IGNORE_ATTRS = (
|
|
'append',
|
|
'cmd_section',
|
|
'head',
|
|
'tail',
|
|
'content',
|
|
'script_method',
|
|
'function_method',
|
|
'set_head',
|
|
'set_tail',
|
|
'set_content',
|
|
'actions',
|
|
)
|
|
if attr == 'prepare':
|
|
self.set_head()
|
|
elif attr == 'commit':
|
|
self.set_tail()
|
|
elif attr not in IGNORE_ATTRS and attr in self.actions:
|
|
self.set_content()
|
|
return super(ServiceBackend, self).__getattribute__(attr)
|
|
|
|
def set_head(self):
|
|
self.cmd_section = self.head
|
|
|
|
def set_tail(self):
|
|
self.cmd_section = self.tail
|
|
|
|
def set_content(self):
|
|
self.cmd_section = self.content
|
|
|
|
@classmethod
|
|
def get_actions(cls):
|
|
return [ action for action in cls.actions if action in dir(cls) ]
|
|
|
|
@classmethod
|
|
def get_name(cls):
|
|
return cls.__name__
|
|
|
|
@classmethod
|
|
def is_main(cls, obj):
|
|
opts = obj._meta
|
|
return cls.model == '%s.%s' % (opts.app_label, opts.object_name)
|
|
|
|
@classmethod
|
|
def get_related(cls, obj):
|
|
opts = obj._meta
|
|
model = '%s.%s' % (opts.app_label, opts.object_name)
|
|
for rel_model, field in cls.related_models:
|
|
if rel_model == model:
|
|
related = obj
|
|
for attribute in field.split('__'):
|
|
related = getattr(related, attribute)
|
|
return related
|
|
return None
|
|
|
|
@classmethod
|
|
def get_backends(cls, instance=None, action=None):
|
|
backends = cls.get_plugins()
|
|
included = []
|
|
# Filter for instance or action
|
|
for backend in backends:
|
|
include = True
|
|
if instance:
|
|
opts = instance._meta
|
|
if backend.model != '.'.join((opts.app_label, opts.object_name)):
|
|
include = False
|
|
if include and action:
|
|
if action not in backend.get_actions():
|
|
include = False
|
|
if include:
|
|
included.append(backend)
|
|
return included
|
|
|
|
@classmethod
|
|
def get_backend(cls, name):
|
|
return cls.get(name)
|
|
|
|
@classmethod
|
|
def model_class(cls):
|
|
return apps.get_model(cls.model)
|
|
|
|
@property
|
|
def scripts(self):
|
|
""" group commands based on their method """
|
|
if not self.content:
|
|
return []
|
|
scripts = {}
|
|
for method, cmd in self.content:
|
|
scripts[method] = []
|
|
for method, commands in self.head + self.content + self.tail:
|
|
try:
|
|
scripts[method] += commands
|
|
except KeyError:
|
|
pass
|
|
return list(scripts.items())
|
|
|
|
def get_banner(self):
|
|
time = timezone.now().strftime("%h %d, %Y %I:%M:%S %Z")
|
|
return "Generated by Orchestra at %s" % time
|
|
|
|
def create_log(self, server, **kwargs):
|
|
from .models import BackendLog
|
|
state = BackendLog.RECEIVED
|
|
run = bool(self.scripts) or (self.force_empty_action_execution or bool(self.content))
|
|
if not run:
|
|
state = BackendLog.NOTHING
|
|
log = BackendLog.objects.create(backend=self.get_name(), state=state, server=server)
|
|
return log
|
|
|
|
def execute(self, server, async=False, log=None):
|
|
from .models import BackendLog
|
|
if log is None:
|
|
log = self.create_log(server)
|
|
run = log.state != BackendLog.NOTHING
|
|
if run:
|
|
scripts = self.scripts
|
|
for method, commands in scripts:
|
|
method(log, server, commands, async)
|
|
if log.state != BackendLog.SUCCESS:
|
|
break
|
|
return log
|
|
|
|
def append(self, *cmd):
|
|
# aggregate commands acording to its execution method
|
|
if isinstance(cmd[0], str):
|
|
method = self.script_method
|
|
cmd = cmd[0]
|
|
else:
|
|
method = self.function_method
|
|
cmd = partial(*cmd)
|
|
if not self.cmd_section or self.cmd_section[-1][0] != method:
|
|
self.cmd_section.append((method, [cmd]))
|
|
else:
|
|
self.cmd_section[-1][1].append(cmd)
|
|
|
|
def get_context(self, obj):
|
|
return {}
|
|
|
|
def prepare(self):
|
|
"""
|
|
hook for executing something at the beging
|
|
define functions or initialize state
|
|
"""
|
|
self.append(
|
|
'set -e\n'
|
|
'set -o pipefail\n'
|
|
'exit_code=0;'
|
|
)
|
|
|
|
def commit(self):
|
|
"""
|
|
hook for executing something at the end
|
|
apply the configuration, usually reloading a service
|
|
reloading a service is done in a separated method in order to reload
|
|
the service once in bulk operations
|
|
"""
|
|
self.append('exit $exit_code')
|
|
|
|
|
|
class ServiceController(ServiceBackend):
|
|
actions = ('save', 'delete')
|
|
abstract = True
|
|
|
|
@classmethod
|
|
def get_verbose_name(cls):
|
|
return _("[S] %s") % super(ServiceController, cls).get_verbose_name()
|
|
|
|
@classmethod
|
|
def get_backends(cls):
|
|
""" filter controller classes """
|
|
backends = super(ServiceController, cls).get_backends()
|
|
return [
|
|
backend for backend in backends if issubclass(backend, ServiceController)
|
|
]
|