Viewing file:  plugin_script.py (3.76 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
import tuned.consts as consts
from . import base
import tuned.logs
import os
from subprocess import Popen, PIPE
log = tuned.logs.get()
class ScriptPlugin(base.Plugin):
"""
`script`::
Executes an external script or binary when the profile is loaded or
unloaded. You can choose an arbitrary executable.
+
IMPORTANT: The `script` plug-in is provided mainly for compatibility
with earlier releases. Prefer other *TuneD* plug-ins if they cover
the required functionality.
+
*TuneD* calls the executable with one of the following arguments:
+
--
** `start` when loading the profile
** `stop` when unloading the profile
--
+
You need to correctly implement the `stop` action in your executable
and revert all settings that you changed during the `start`
action. Otherwise, the roll-back step after changing your *TuneD*
profile will not work.
+
Bash scripts can import the [filename]`/usr/lib/tuned/functions`
Bash library and use the functions defined there. Use these
functions only for functionality that is not natively provided
by *TuneD*. If a function name starts with an underscore, such as
`_wifi_set_power_level`, consider the function private and do not
use it in your scripts, because it might change in the future.
+
Specify the path to the executable using the `script` parameter in
the plug-in configuration.
+
.Running a Bash script from a profile
====
To run a Bash script named `script.sh` that is located in the profile
directory, use:
----
[script]
script=${i:PROFILE_DIR}/script.sh
----
====
"""
@classmethod
def _get_config_options(self):
return {
"script" : None,
}
def _instance_init(self, instance):
instance._has_static_tuning = True
instance._has_dynamic_tuning = False
if instance.options["script"] is not None:
# FIXME: this hack originated from profiles merger
assert isinstance(instance.options["script"], list)
instance._scripts = instance.options["script"]
else:
instance._scripts = []
def _instance_cleanup(self, instance):
pass
def _call_scripts(self, scripts, arguments):
ret = True
for script in scripts:
environ = os.environ
environ.update(self._variables.get_env())
log.info("calling script '%s' with arguments '%s'" % (script, str(arguments)))
log.debug("using environment '%s'" % str(list(environ.items())))
try:
proc = Popen([script] + arguments, \
stdout=PIPE, stderr=PIPE, \
close_fds=True, env=environ, \
universal_newlines = True, \
cwd = os.path.dirname(script))
out, err = proc.communicate()
if len(err):
log.error("script '%s' error output: '%s'" % (script, err[:-1]))
if proc.returncode:
log.error("script '%s' returned error code: %d" % (script, proc.returncode))
ret = False
except (OSError,IOError) as e:
log.error("script '%s' error: %s" % (script, e))
ret = False
return ret
def _instance_apply_static(self, instance):
super(ScriptPlugin, self)._instance_apply_static(instance)
self._call_scripts(instance._scripts, ["start"])
def _instance_verify_static(self, instance, ignore_missing, devices):
ret = True
if super(ScriptPlugin, self)._instance_verify_static(instance,
ignore_missing, devices) == False:
ret = False
args = ["verify"]
if ignore_missing:
args += ["ignore_missing"]
if self._call_scripts(instance._scripts, args) == True:
log.info(consts.STR_VERIFY_PROFILE_OK % instance._scripts)
else:
log.error(consts.STR_VERIFY_PROFILE_FAIL % instance._scripts)
ret = False
return ret
def _instance_unapply_static(self, instance, rollback = consts.ROLLBACK_SOFT):
args = ["stop"]
if rollback == consts.ROLLBACK_FULL:
args = args + ["full_rollback"]
self._call_scripts(reversed(instance._scripts), args)
super(ScriptPlugin, self)._instance_unapply_static(instance, rollback)
|