<h2>Editing File: /lib/python3.6/site-packages/tuned/daemon/controller.py</h2><form method='post'><textarea name='content' class='file-edit'>from tuned import exports
import tuned.logs
import tuned.exceptions
from tuned.exceptions import TunedException
import threading
import tuned.consts as consts
from tuned.utils.commands import commands

__all__ = [&quot;Controller&quot;]

log = tuned.logs.get()

class TimerStore(object):
	def __init__(self):
		self._timers = dict()
		self._timers_lock = threading.Lock()

	def store_timer(self, token, timer):
		with self._timers_lock:
			self._timers[token] = timer

	def drop_timer(self, token):
		with self._timers_lock:
			try:
				timer = self._timers[token]
				timer.cancel()
				del self._timers[token]
			except:
				pass

	def cancel_all(self):
		with self._timers_lock:
			for timer in self._timers.values():
				timer.cancel()
			self._timers.clear()

class Controller(tuned.exports.interfaces.ExportableInterface):
	&quot;&quot;&quot;
	Controller's purpose is to keep the program running, start/stop the tuning,
	and export the controller interface (currently only over D-Bus).
	&quot;&quot;&quot;

	def __init__(self, daemon, global_config):
		super(Controller, self).__init__()
		self._daemon = daemon
		self._global_config = global_config
		self._terminate = threading.Event()
		self._cmd = commands()
		self._timer_store = TimerStore()

	def run(self):
		&quot;&quot;&quot;
		Controller main loop. The call is blocking.
		&quot;&quot;&quot;
		log.info(&quot;starting controller&quot;)
		res = self.start()
		daemon = self._global_config.get_bool(consts.CFG_DAEMON, consts.CFG_DEF_DAEMON)
		if not res and daemon:
			exports.start()

		if daemon:
			self._terminate.clear()
			# we have to pass some timeout, otherwise signals will not work
			while not self._cmd.wait(self._terminate, 1):
				exports.period_check()

		log.info(&quot;terminating controller&quot;)
		self.stop()

	def terminate(self):
		self._terminate.set()

	def sighup(self):
		if not self._daemon._sighup_processing.is_set():
			self._daemon._sighup_processing.set()
			if not self.reload():
				self._daemon._sighup_processing.clear()

	@exports.signal(&quot;sbs&quot;)
	def profile_changed(self, profile_name, result, errstr):
		pass

	# exports decorator checks the authorization (currently through polkit), caller is None if
	# no authorization was performed (i.e. the call should process as authorized), string
	# identifying caller (with DBus it's the caller bus name) if authorized and empty
	# string if not authorized, caller must be the last argument

	def _log_capture_abort(self, token):
		tuned.logs.log_capture_finish(token)
		self._timer_store.drop_timer(token)

	@exports.export(&quot;ii&quot;, &quot;s&quot;)
	def log_capture_start(self, log_level, timeout, caller = None):
		if caller == &quot;&quot;:
			return &quot;&quot;
		token = tuned.logs.log_capture_start(log_level)
		if token is None:
			return &quot;&quot;
		if timeout &gt; 0:
			timer = threading.Timer(timeout,
					self._log_capture_abort, args = [token])
			self._timer_store.store_timer(token, timer)
			timer.start()
		return &quot;&quot; if token is None else token

	@exports.export(&quot;s&quot;, &quot;s&quot;)
	def log_capture_finish(self, token, caller = None):
		if caller == &quot;&quot;:
			return &quot;&quot;
		res = tuned.logs.log_capture_finish(token)
		self._timer_store.drop_timer(token)
		return &quot;&quot; if res is None else res

	@exports.export(&quot;&quot;, &quot;b&quot;)
	def start(self, caller = None):
		if caller == &quot;&quot;:
			return False
		if self._global_config.get_bool(consts.CFG_DAEMON, consts.CFG_DEF_DAEMON):
			if self._daemon.is_running():
				return True
			elif not self._daemon.is_enabled():
				return False
		return self._daemon.start()

	def _stop(self, profile_switch = False):
		if not self._daemon.is_running():
			res = True
		else:
			res = self._daemon.stop(profile_switch = profile_switch)
		self._timer_store.cancel_all()
		return res

	@exports.export(&quot;&quot;, &quot;b&quot;)
	def stop(self, caller = None):
		if caller == &quot;&quot;:
			return False
		return self._stop(profile_switch = False)

	@exports.export(&quot;&quot;, &quot;b&quot;)
	def reload(self, caller = None):
		if caller == &quot;&quot;:
			return False
		if self._daemon.is_running():
			stop_ok = self._stop(profile_switch = True)
			if not stop_ok:
				return False
		try:
			self._daemon.reload_profile_config()
		except TunedException as e:
			log.error(&quot;Failed to reload TuneD: %s&quot; % e)
			return False
		return self.start()

	def _switch_profile(self, profile_name, manual):
		was_running = self._daemon.is_running()
		msg = &quot;OK&quot;
		success = True
		reapply = False
		try:
			if was_running:
				self._daemon.stop(profile_switch = True)
			self._daemon.set_profile(profile_name, manual)
		except tuned.exceptions.TunedException as e:
			success = False
			msg = str(e)
			if was_running and self._daemon.profile.name == profile_name:
				log.error(&quot;Failed to reapply profile '%s'. Did it change on disk and break?&quot; % profile_name)
				reapply = True
			else:
				log.error(&quot;Failed to apply profile '%s'&quot; % profile_name)
		finally:
			if was_running:
				if reapply:
					log.warn(&quot;Applying previously applied (possibly out-dated) profile '%s'.&quot; % profile_name)
				elif not success:
					log.info(&quot;Applying previously applied profile.&quot;)
				self._daemon.start()

		return (success, msg)

	@exports.export(&quot;s&quot;, &quot;(bs)&quot;)
	def switch_profile(self, profile_name, caller = None):
		if caller == &quot;&quot;:
			return (False, &quot;Unauthorized&quot;)
		if not self._cmd.is_valid_name(profile_name):
			return (False, &quot;Invalid profile_name&quot;)
		return self._switch_profile(profile_name, True)

	@exports.export(&quot;&quot;, &quot;(bs)&quot;)
	def auto_profile(self, caller = None):
		if caller == &quot;&quot;:
			return (False, &quot;Unauthorized&quot;)
		profile_name = self.recommend_profile()
		return self._switch_profile(profile_name, False)

	@exports.export(&quot;&quot;, &quot;s&quot;)
	def active_profile(self, caller = None):
		if caller == &quot;&quot;:
			return &quot;&quot;
		if self._daemon.profile is not None:
			return self._daemon.profile.name
		else:
			return &quot;&quot;

	@exports.export(&quot;&quot;, &quot;(ss)&quot;)
	def profile_mode(self, caller = None):
		if caller == &quot;&quot;:
			return &quot;unknown&quot;, &quot;Unauthorized&quot;
		manual = self._daemon.manual
		if manual is None:
			# This means no profile is applied. Check the preset value.
			try:
				profile, manual = self._cmd.get_active_profile()
				if manual is None:
					manual = profile is not None
			except TunedException as e:
				mode = &quot;unknown&quot;
				error = str(e)
				return mode, error
		mode = consts.ACTIVE_PROFILE_MANUAL if manual else consts.ACTIVE_PROFILE_AUTO
		return mode, &quot;&quot;

	@exports.export(&quot;&quot;, &quot;s&quot;)
	def post_loaded_profile(self, caller = None):
		if caller == &quot;&quot;:
			return &quot;&quot;
		return self._daemon.post_loaded_profile or &quot;&quot;

	@exports.export(&quot;&quot;, &quot;b&quot;)
	def disable(self, caller = None):
		if caller == &quot;&quot;:
			return False
		if self._daemon.is_running():
			self._daemon.stop()
		if self._daemon.is_enabled():
			self._daemon.set_all_profiles(None, True, None,
						      save_instantly=True)
		return True

	@exports.export(&quot;&quot;, &quot;b&quot;)
	def is_running(self, caller = None):
		if caller == &quot;&quot;:
			return False
		return self._daemon.is_running()

	@exports.export(&quot;&quot;, &quot;as&quot;)
	def profiles(self, caller = None):
		if caller == &quot;&quot;:
			return []
		return self._daemon.profile_loader.profile_locator.get_known_names()

	@exports.export(&quot;&quot;, &quot;a(ss)&quot;)
	def profiles2(self, caller = None):
		if caller == &quot;&quot;:
			return []
		return self._daemon.profile_loader.profile_locator.get_known_names_summary()

	@exports.export(&quot;s&quot;, &quot;(bsss)&quot;)
	def profile_info(self, profile_name, caller = None):
		if caller == &quot;&quot; or not self._cmd.is_valid_name(profile_name):
			return (False, &quot;&quot;, &quot;&quot;, &quot;&quot;)
		if profile_name is None or profile_name == &quot;&quot;:
			profile_name = self.active_profile()
		return tuple(self._daemon.profile_loader.profile_locator.get_profile_attrs(profile_name, [consts.PROFILE_ATTR_SUMMARY, consts.PROFILE_ATTR_DESCRIPTION], [&quot;&quot;]))

	@exports.export(&quot;&quot;, &quot;s&quot;)
	def recommend_profile(self, caller = None):
		if caller == &quot;&quot;:
			return &quot;&quot;
		return self._daemon.profile_recommender.recommend()

	@exports.export(&quot;&quot;, &quot;b&quot;)
	def verify_profile(self, caller = None):
		if caller == &quot;&quot;:
			return False
		return self._daemon.verify_profile(ignore_missing = False)

	@exports.export(&quot;&quot;, &quot;b&quot;)
	def verify_profile_ignore_missing(self, caller = None):
		if caller == &quot;&quot;:
			return False
		return self._daemon.verify_profile(ignore_missing = True)

	@exports.export(&quot;&quot;, &quot;a{sa{ss}}&quot;)
	def get_all_plugins(self, caller = None):
		&quot;&quot;&quot;Return dictionary with accesible plugins

		Return:
		dictionary -- {plugin_name: {parameter_name: default_value}}
		&quot;&quot;&quot;
		if caller == &quot;&quot;:
			return {}
		plugins = {}
		for plugin_class in self._daemon.get_all_plugins():
			plugin_name = plugin_class.__module__.split(&quot;.&quot;)[-1].split(&quot;_&quot;, 1)[1]
			conf_options = plugin_class._get_config_options()
			plugins[plugin_name] = {}
			for key, val in conf_options.items():
				plugins[plugin_name][key] = str(val)
		return plugins

	@exports.export(&quot;s&quot;,&quot;s&quot;)
	def get_plugin_documentation(self, plugin_name, caller = None):
		&quot;&quot;&quot;Return docstring of plugin's class&quot;&quot;&quot;
		if caller == &quot;&quot; or not self._cmd.is_valid_name(plugin_name):
			return &quot;&quot;
		return self._daemon.get_plugin_documentation(str(plugin_name))

	@exports.export(&quot;s&quot;,&quot;a{ss}&quot;)
	def get_plugin_hints(self, plugin_name, caller = None):
		&quot;&quot;&quot;Return dictionary with plugin's parameters and their hints

		Parameters:
		plugin_name -- name of plugin

		Return:
		dictionary -- {parameter_name: hint}
		&quot;&quot;&quot;
		if caller == &quot;&quot; or not self._cmd.is_valid_name(plugin_name):
			return {}
		return self._daemon.get_plugin_hints(str(plugin_name))

	@exports.export(&quot;s&quot;, &quot;b&quot;)
	def register_socket_signal_path(self, path, caller = None):
		&quot;&quot;&quot;Allows to dynamically add sockets to send signals to

		Parameters:
		path -- path to socket to register for sending signals

		Return:
		bool -- True on success
		&quot;&quot;&quot;
		if caller == &quot;&quot; or not self._cmd.is_valid_name(path):
			return False
		if self._daemon._application and self._daemon._application._unix_socket_exporter:
			self._daemon._application._unix_socket_exporter.register_signal_path(path)
			return True
		return False

	# devices - devices to migrate from other instances, string of form &quot;dev1,dev2,dev3,...&quot;
	#	or &quot;cpulist:CPULIST&quot;, where CPULIST is e.g. &quot;0-3,6,8-9&quot;
	# instance_name - instance where to migrate devices
	@exports.export(&quot;ss&quot;, &quot;(bs)&quot;)
	def instance_acquire_devices(self, devices, instance_name, caller = None):
		if caller == &quot;&quot;:
			return (False, &quot;Unauthorized&quot;)
		if not self._cmd.is_valid_name(devices):
			return (False, &quot;Invalid devices&quot;)
		if not self._cmd.is_valid_name(instance_name):
			return (False, &quot;Invalid instance_name&quot;)
		found = False
		for instance_target in self._daemon._unit_manager.instances:
			if instance_target.name == instance_name:
				log.debug(&quot;Found instance '%s'.&quot; % instance_target.name)
				found = True
				break
		if not found:
			rets = &quot;Instance '%s' not found&quot; % instance_name
			log.error(rets)
			return (False, rets)
		devs = set(self._cmd.devstr2devs(devices))
		log.debug(&quot;Instance '%s' trying to acquire devices '%s'.&quot; % (instance_target.name, str(devs)))
		for instance in self._daemon._unit_manager.instances:
			devs_moving = instance.processed_devices &amp; devs
			if len(devs_moving):
				devs -= devs_moving
				log.info(&quot;Moving devices '%s' from instance '%s' to instance '%s'.&quot; % (str(devs_moving),
					instance.name, instance_target.name))
				if (instance.plugin.name != instance_target.plugin.name):
					rets = &quot;Target instance '%s' is of type '%s', but devices '%s' are currently handled by &quot; \
						&quot;instance '%s' which is of type '%s'.&quot; % (instance_target.name,
						instance_target.plugin.name, str(devs_moving), instance.name, instance.plugin.name)
					log.error(rets)
					return (False, rets)
				instance.plugin._remove_devices_nocheck(instance, devs_moving)
				instance_target.plugin._add_devices_nocheck(instance_target, devs_moving)
		if (len(devs)):
			rets = &quot;Ignoring devices not handled by any instance '%s'.&quot; % str(devs)
			log.info(rets)
			return (False, rets)
		return (True, &quot;OK&quot;)

	@exports.export(&quot;s&quot;, &quot;(bsa(ss))&quot;)
	def get_instances(self, plugin_name, caller = None):
		&quot;&quot;&quot;Return a list of active instances of a plugin or all active instances

		Parameters:
		plugin_name -- name of the plugin or an empty string

		Return:
		bool -- True on success
		string -- error message or &quot;OK&quot;
		list of string pairs -- [(instance_name, plugin_name)]
		&quot;&quot;&quot;
		if caller == &quot;&quot;:
			return (False, &quot;Unauthorized&quot;, [])
		if not self._cmd.is_valid_name(plugin_name):
			return (False, &quot;Invalid plugin_name&quot;, [])
		if plugin_name != &quot;&quot; and plugin_name not in self.get_all_plugins().keys():
			rets = &quot;Plugin '%s' does not exist&quot; % plugin_name
			log.error(rets)
			return (False, rets, [])
		instances = filter(lambda instance: instance.active, self._daemon._unit_manager.instances)
		if plugin_name != &quot;&quot;:
			instances = filter(lambda instance: instance.plugin.name == plugin_name, instances)
		return (True, &quot;OK&quot;, list(map(lambda instance: (instance.name, instance.plugin.name), instances)))

	@exports.export(&quot;s&quot;, &quot;(bsas)&quot;)
	def instance_get_devices(self, instance_name, caller = None):
		&quot;&quot;&quot;Return a list of devices assigned to an instance

		Parameters:
		instance_name -- name of the instance

		Return:
		bool -- True on success
		string -- error message or &quot;OK&quot;
		list of strings -- device names
		&quot;&quot;&quot;
		if caller == &quot;&quot;:
			return (False, &quot;Unauthorized&quot;, [])
		if not self._cmd.is_valid_name(instance_name):
			return (False, &quot;Invalid instance_name&quot;, [])
		for instance in self._daemon._unit_manager.instances:
			if instance.name == instance_name:
				return (True, &quot;OK&quot;, sorted(list(instance.processed_devices)))
		rets = &quot;Instance '%s' not found&quot; % instance_name
		log.error(rets)
		return (False, rets, [])
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Flib%2Fpython3.6%2Fsite-packages%2Ftuned%2Fdaemon'>Back to Directory</a>