--- /dev/null
+# Copyright 2019 Nokia
+
+# 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 logging
+
+from cmframework.utils import cmactivationwork
+from cmframework.server import cmeventletrwlock
+from cmframework.server import cmcsn
+from cmframework.server import cmsnapshot
+from cmframework.utils.cmflagfile import CMFlagFile
+from cmframework.utils import cmalarm
+
+
+class CMProcessor(object):
+ SERVICE_GROUP_NAME = 'config-manager'
+
+ def __init__(self,
+ backend_handler,
+ validator,
+ activator,
+ changemonitor,
+ activationstate_handler,
+ snapshot_handler):
+ logging.debug('CMProcessor constructed')
+
+ self.backend_handler = backend_handler
+ self.lock = cmeventletrwlock.CMEventletRWLock()
+ self.csn = cmcsn.CMCSN(self.backend_handler)
+ self.validator = validator
+ self.activator = activator
+ self.reboot_requests = set()
+ self.automatic_activation_disabled = CMFlagFile('automatic_activation_disabled')
+ self.changemonitor = changemonitor
+ self.activationstate_handler = activationstate_handler
+ self.snapshot = cmsnapshot.CMSnapshot(snapshot_handler)
+
+ def reboot_request(self, node_name):
+ logging.debug('reboot_request called for %s', node_name)
+
+ self.reboot_requests.add(node_name)
+
+ def _clear_reboot_requests(self):
+ logging.debug('_clear_reboot_requests called')
+
+ self.reboot_requests.clear()
+
+ def _raise_reboot_alarms(self):
+ logging.debug('_raise_reboot_alarms called')
+
+ reboot_request_alarm = cmalarm.CMRebootRequestAlarm()
+
+ for node_name in self.reboot_requests:
+ reboot_request_alarm.raise_alarm_for_node(node_name)
+
+ def get_property(self, prop_name, snapshot_name=None):
+ logging.debug('get_property called for %s', prop_name)
+
+ with self.lock.reader():
+ if snapshot_name:
+ self.snapshot.load(snapshot_name)
+
+ return self.snapshot.get_property(prop_name)
+
+ return self.backend_handler.get_property(prop_name)
+
+ def get_properties(self, prop_filter, snapshot_name=None):
+ logging.debug('get_properties called with filter %s', prop_filter)
+
+ with self.lock.reader():
+ if snapshot_name:
+ self.snapshot.load(snapshot_name)
+
+ return self.snapshot.get_properties(prop_filter)
+
+ return self.backend_handler.get_properties(prop_filter)
+
+ def set_property(self, prop_name, prop_value):
+ logging.debug('set_property called %s=%s', prop_name, prop_value)
+
+ props = {}
+ props[prop_name] = prop_value
+ return self.set_properties(props)
+
+ def set_properties(self, props, overwrite=False):
+ logging.debug('set_properties called for %s', str(props))
+
+ with self.lock.writer():
+ self._validate_set(props)
+ if overwrite:
+ logging.debug('Deleting old configuration data as requested')
+ orig_props = self.backend_handler.get_properties('.*')
+ self.backend_handler.delete_properties(orig_props.keys())
+ self.backend_handler.set_properties(props)
+ self.csn.increment()
+
+ if not self.automatic_activation_disabled:
+ return self._activate_set(props)
+
+ return "0"
+
+ def delete_property(self, prop_name):
+ logging.debug('delete_property called for %s', prop_name)
+
+ props = []
+ props.append(prop_name)
+ return self._delete_properties(props, None)
+
+ def delete_properties(self, arg):
+ logging.debug('delete_properties called with arg %r', arg)
+
+ keys = []
+ prop_filter = None
+ if isinstance(arg, str):
+ prop_filter = arg
+ props = self.get_properties(prop_filter)
+ keys = props.keys()
+ else:
+ keys = arg
+ return self._delete_properties(keys, prop_filter)
+
+ def _delete_properties(self, props, props_filter):
+ logging.debug('_delete_properties called with props %s filter %s', props, props_filter)
+
+ with self.lock.writer():
+ self._validate_delete(props)
+ if props_filter:
+ self.backend_handler.delete_properties(props_filter)
+ else:
+ if len(props) == 1:
+ self.backend_handler.delete_property(props[0])
+ else:
+ self.backend_handler.delete_properties(props)
+ self.csn.increment()
+
+ if not self.automatic_activation_disabled:
+ return self._activate_delete(props)
+
+ return "0"
+
+ def _validate_set(self, props):
+ logging.debug('_validate_set called for %s', str(props))
+
+ self.validator.validate_set(props)
+
+ def _activate_set_no_lock(self, props):
+ logging.debug('_activate_set_no_lock called for %s', str(props))
+
+ uuid_value = self.changemonitor.start_change()
+
+ work = cmactivationwork.CMActivationWork(cmactivationwork.CMActivationWork.OPER_SET,
+ self.csn.get(), props)
+ work.uuid_value = uuid_value
+ self.activator.add_work(work)
+ return uuid_value
+
+ def _activate_set(self, props):
+ logging.debug('_activate_set called')
+
+ with self.lock.reader():
+ return self._activate_set_no_lock(props)
+
+ def _validate_delete(self, props):
+ logging.debug('_validate_delete called for %s', str(props))
+
+ self.validator.validate_delete(props)
+
+ def _activate_delete(self, props):
+ logging.debug('_activate_delete called for %s', str(props))
+
+ with self.lock.reader():
+ uuid_value = self.changemonitor.start_change()
+ work = cmactivationwork.CMActivationWork(cmactivationwork.CMActivationWork.OPER_DELETE,
+ self.csn.get(), props)
+ work.uuid_value = uuid_value
+ self.activator.add_work(work)
+ return uuid_value
+
+ def create_snapshot(self, snapshot_name):
+ logging.debug('create_snapshot called, snapshot name is %s', snapshot_name)
+
+ with self.lock.writer():
+ self.snapshot.create(snapshot_name, self.backend_handler)
+
+ def restore_snapshot(self, snapshot_name):
+ logging.debug('restore_snapshot called, snapshot name is %s', snapshot_name)
+
+ with self.lock.writer():
+ self.snapshot.load(snapshot_name)
+
+ self._validate_set(self.snapshot.get_properties())
+
+ self.snapshot.restore(self.backend_handler)
+
+ self.csn = cmcsn.CMCSN(self.backend_handler)
+
+ self._activate_set_no_lock(self.snapshot.get_properties())
+
+ def list_snapshots(self):
+ logging.debug('list_snapshots called')
+
+ snapshots = []
+ with self.lock.writer():
+ snapshots = self.snapshot.list()
+
+ return snapshots
+
+ def delete_snapshot(self, snapshot_name):
+ logging.debug('delete_snapshot called, snapshot name is %s', snapshot_name)
+
+ with self.lock.writer():
+ self.snapshot.delete(snapshot_name)
+
+ def activate(self, node_name=None, startup_activation=False):
+ logging.debug('activate called, node is %s', node_name)
+
+ activation_alarm = cmalarm.CMActivationFailedAlarm()
+ if node_name:
+ activation_alarm.cancel_alarm_for_node(node_name)
+ else:
+ activation_alarm.cancel_alarm_for_sg(CMProcessor.SERVICE_GROUP_NAME)
+
+ with self.lock.reader():
+ uuid_value = self.changemonitor.start_change()
+ if not node_name:
+ work = cmactivationwork.CMActivationWork(
+ cmactivationwork.CMActivationWork.OPER_FULL,
+ self.csn.get(), {}, None, startup_activation)
+ else:
+ work = cmactivationwork.CMActivationWork(
+ cmactivationwork.CMActivationWork.OPER_FULL,
+ self.csn.get(), {}, node_name)
+ work.uuid_value = uuid_value
+ self.activator.add_work(work)
+
+ logging.debug('activation work added, going to wait for result')
+ failures = work.get_result()
+ logging.debug('got activation result')
+
+ if self.reboot_requests:
+ self._raise_reboot_alarms()
+
+ if not node_name:
+ self.activationstate_handler.clear_full_failed()
+
+ if failures:
+ logging.warning('Activation failed: %s', failures)
+
+ failed_activators = [activator for handler in failures.keys()
+ for activator in failures[handler]]
+
+ supplementary_info = {'failed activators': failed_activators}
+
+ if node_name:
+ activation_alarm.raise_alarm_for_node(node_name, supplementary_info)
+ else:
+ self.activationstate_handler.set_full_failed(failed_activators)
+
+ activation_alarm.raise_alarm_for_sg(CMProcessor.SERVICE_GROUP_NAME,
+ supplementary_info)
+ return uuid_value
+
+ def activate_node(self, node_name):
+ logging.debug('activate_node called, node name is %s', node_name)
+
+ if self.automatic_activation_disabled:
+ return False
+
+ with self.lock.reader():
+ node_csn = self.csn.get_node_csn(node_name)
+
+ if self.csn.get() == node_csn:
+ logging.info('No change in data since last translation, last csn %d',
+ self.csn.get())
+ return False
+
+ self._clear_reboot_requests()
+ work = cmactivationwork.CMActivationWork(cmactivationwork.CMActivationWork.OPER_NODE,
+ self.csn.get(), {}, node_name)
+ self.activator.add_work(work)
+
+ activation_alarm = cmalarm.CMActivationFailedAlarm()
+ activation_alarm.cancel_alarm_for_node(node_name)
+
+ failures = work.get_result()
+ if failures:
+ logging.warning('Activation failed: %s', failures)
+
+ failed_activators = [activator for handler in failures.keys()
+ for activator in failures[handler]]
+ supplementary_info = {'failed activators': failed_activators}
+ activation_alarm.raise_alarm_for_node(node_name, supplementary_info)
+
+ else:
+ with self.lock.writer():
+ self.csn.sync_node_csn(node_name)
+
+ return node_name in self.reboot_requests
+
+ def set_automatic_activation_state(self, state):
+ logging.debug('set_automatic_activation_state called, state is %s', state)
+
+ with self.lock.writer():
+ if state:
+ self.automatic_activation_disabled.unset()
+ else:
+ self.automatic_activation_disabled.set()
Code Review / ta / config-manager.git / blobdiff