

<div style='background:#ffffff; color:#000; font-family:monospace; padding:0; max-width:900px; margin:20px auto; border:3px solid #000;'><div style='background:#000080; color:#fff; padding:6px 12px; font-weight:bold;'>✏ 编辑: plugin_manager.py</div><div style='padding:20px;'><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#fff; color:#000; border:2px solid #000; font-family:monospace; padding:10px;'>from agent_util import Plugin
import logging
import os
import sys
import traceback
import tempfile
import tarfile
import zipfile

try:
    from hashlib import sha1
except:
    from sha import sha as sha1
try:
    # Python 2.x
    import urllib2
except:
    import urllib.request as urllib2
# In case of python 3
try:
    import ConfigParser as configparser
except:
    import configparser


def execfile3(filepath, globals=None, locals=None):
    if globals is None:
        globals = {}
    globals.update(
        {
            &quot;__file__&quot;: filepath,
            &quot;__name__&quot;: &quot;__main__&quot;,
        }
    )
    f = open(filepath, &quot;rb&quot;)
    exec(compile(f.read(), filepath, &quot;exec&quot;), globals, locals)
    f.close()


class PluginManager(object):
    def __init__(self, db, config_file, *directories):
        self.log = logging.getLogger(self.__class__.__name__)
        self.db = db
        self.config_file = config_file
        self.directories = directories
        self.plugins = self._load_plugins(directories)

        # Internal container for metadata so we can avoid repeatedly regenerating it
        self._metadata = None
        self._hashed_metadata = None

        # now we load all the plugin-specific configs and map them to
        # self.config
        self.config = {}
        if os.path.exists(self.config_file):
            config_file = configparser.ConfigParser()
            config_file.read(self.config_file)
            for textkey in config_file.sections():
                try:
                    debug = config_file.get(&quot;agent&quot;, &quot;debug&quot;)
                except:
                    debug = False
                self.config[textkey] = {&quot;debug&quot;: debug}
                for k, v in config_file.items(textkey):
                    self.config[textkey][k] = v

    def add_dem_wifi_results(self, wifi_results):
        dem_config = self.config.get(&quot;dem&quot;, None)
        if dem_config:
            dem_config[&quot;wifi_results&quot;] = wifi_results

    def install_remote_plugins(self, url):
        &quot;&quot;&quot;
        Grab the remote url and extract the contents, putting them in the
        appropiate plugin folder.
        &quot;&quot;&quot;
        base_custom_plugin_dir = self.directories[-1]
        f = tempfile.NamedTemporaryFile(delete=False)
        num_installed = 0
        ext = url.split(&quot;.&quot;)[-1]
        fname = url.split(&quot;/&quot;)[-1]
        try:
            r = urllib2.urlopen(url)
            if &quot;content-disposition&quot; in r.info():
                ext = r.info().getheader(&quot;content-disposition&quot;).split(&quot;.&quot;)[-1]
            f.write(r.read())
            f.close()
        except Exception:
            self.log.error(&quot;Unable to download URL: %s&quot; % traceback.format_exc())
            return

        if ext in (&quot;tar&quot;, &quot;tgz&quot;):
            try:
                t = tarfile.open(f.name)
                for file in t.getnames():
                    if file.endswith(&quot;.py&quot;):
                        self.log.info(&quot;  Installing plugin %s&quot; % file)
                        t.extract(file, base_custom_plugin_dir)
                        num_installed += 1
            except Exception:
                self.log.error(
                    &quot;Unable to extract tar contents: %s&quot; % traceback.format_exc()
                )
        elif ext == &quot;zip&quot;:
            try:
                z = zipfile.ZipFile(f.name)
                for file in z.namelist():
                    if file.endswith(&quot;.py&quot;):
                        self.log.info(&quot;  Installing plugin %s&quot; % file)
                        z.extract(file, base_custom_plugin_dir)
                        num_installed += 1
            except Exception:
                self.log.error(
                    &quot;Unable to extract zip contents: %s&quot; % traceback.format_exc()
                )
        elif ext == &quot;py&quot;:
            self.log.info(&quot;  Installing plugin %s&quot; % fname)
            os.system(
                &quot;cp %s %s&quot; % (f.name, os.path.join(base_custom_plugin_dir, fname))
            )
            num_installed += 1
        else:
            self.log.error(
                &quot;Unable to install Agent Plugin, unknown extension: %s&quot; % ext
            )

        if num_installed:
            self.log.info(&quot;\nInstalled %s Agent plugins&quot; % num_installed)

        os.system(&quot;rm -f %s&quot; % f.name)

    # run a specific plugin
    def check(self, schedule):
        try:
            self_key = self.config.get(&quot;agent&quot;, {}).get(&quot;server_key&quot;)
            container = None
            if (
                getattr(schedule, &quot;server_key&quot;, None)
                and schedule.server_key != self_key
            ):
                container_id = schedule.server_key.split(&quot;:&quot;)[-1]
                try:
                    container = self.db[&quot;docker_containers&quot;][container_id]
                except:
                    if (
                        schedule.plugin_textkey == &quot;docker&quot;
                        and schedule.resource_textkey == &quot;status.running&quot;
                    ):
                        # Special handling of &quot;container is running&quot; metrics.
                        # Pass in a phony value to treat it as gone.
                        container = {&quot;State&quot;: &quot;deleted&quot;}
                    else:
                        self.log.error(
                            &quot;Could not find container with id %s&quot;, container_id
                        )
                        return None

            plugin = self.plugins[schedule.plugin_textkey](schedule)
            config = self.config.get(schedule.plugin_textkey, {})

            scale = config.get(&quot;scale&quot;, 1.0)

            if container:
                value = plugin.check_docker(
                    container, schedule.resource_textkey, schedule.option, config
                )
            else:
                value = plugin.check(schedule.resource_textkey, schedule.option, config)

            if value is not None:
                value *= scale

        except Exception:
            self.log.exception(
                &quot;%s/%s check failed: %s&quot;
                % (
                    schedule.plugin_textkey,
                    schedule.resource_textkey,
                    traceback.format_exc(),
                )
            )
            return None

        return value

    def _load_plugins(self, directories):
        plugins = {}
        plugin_blacklist = &quot;&quot;

        if os.path.exists(self.config_file):
            config_file = configparser.ConfigParser()
            config_file.read(self.config_file)

            try:
                plugin_blacklist = config_file.get(&quot;agent&quot;, &quot;plugin_blacklist&quot;)
            except:
                plugin_blacklist = &quot;&quot;

            if plugin_blacklist:
                plugin_blacklist = list(map(str.strip, plugin_blacklist.split(&quot;,&quot;)))

        def plugin_file_checker():
            for plugin_dir in directories:
                self.log.info(&quot;Looking in directory %r&quot;, plugin_dir)
                for name in os.listdir(plugin_dir):
                    try:
                        if name[-3:] != &quot;.py&quot; or name == &quot;__init__.py&quot;:
                            continue

                        plugin_file = os.path.join(plugin_dir, name)

                        # We've registed sys.modules['agent'] to equal THIS
                        # module, so this exec has the effect of 'importing' the
                        # plugin, and resolving 'import agent' to import this
                        # module. This is so we never have to change the plugins
                        # in order to whitelabel.
                        f_globals = {}
                        f_locals = {}
                        if sys.version_info[0] == 3:
                            execfile3(plugin_file, f_globals, f_globals)
                        else:
                            execfile(plugin_file, f_globals, f_globals)

                        for obj in list(f_globals.values()):
                            yield obj
                        self.log.debug(&quot;Loaded %r&quot;, plugin_file)

                    except Exception:
                        t, e = sys.exc_info()[:2]
                        self.log.info(&quot;Error importing plugin %s, skipping&quot;, name)
                        self.log.debug(e)
                        continue
                self.log.info(&quot;Loaded %d plugins&quot;, len(plugins))

        for obj in plugin_file_checker():
            if isinstance(obj, type):
                if (
                    issubclass(obj, Plugin)
                    and hasattr(obj, &quot;textkey&quot;)
                    and obj.textkey not in plugin_blacklist
                ):
                    if obj.textkey != &quot;TEMPLATE_PLUGIN&quot;:
                        plugins[obj.textkey] = obj

        return plugins

    # returns all the values needed to describe the plugins and their resources
    # in a json-serializable way.  Uses local cache of values to avoid recomputing.
    @property
    def metadata(self):
        if self._metadata == None:
            # We haven't previously built the metadata - go do that and cache for later
            metadata = {}
            for plugin in list(self.plugins.values()):
                # get the config and push it up with the metadata
                config = self.config.get(plugin.textkey, {})
                try:
                    meta = format_metadata(plugin.get_metadata(config))
                except:
                    self.log.exception(&quot;error getting metadata from %r&quot;, plugin.textkey)
                    continue
                self.log.info(
                    &quot;got %d textkeys for %r&quot;, len(list(meta.keys())), plugin.textkey
                )
                label = getattr(plugin, &quot;label&quot;, plugin.textkey)
                metadata[plugin.textkey] = (label, meta)

            self._metadata = metadata

        return self._metadata

    # returns the metadata hash, used for comparing whether or not our metadata
    # has changed since we last pushed.  Uses local cache of values to avoid recomputing.
    def hashed_metadata(self):
        if self._hashed_metadata == None:
            flat_data = []

            for textkey, (label, plugin_metadata) in list(self.metadata.items()):
                plugin_options = []
                for resource_name, resource_metadata in list(plugin_metadata.items()):
                    resource_meta = sorted(repr(resource_metadata))
                    plugin_options.append(repr((resource_name, resource_metadata)))

                plugin_options.sort()
                flat_data.append(repr((textkey, plugin_options, label)))

            flat_data.sort()
            self._hashed_metadata = sha1(repr(flat_data).encode()).hexdigest()

        return self._hashed_metadata

    def is_metadata_stale(self):
        self.log.info(
            &quot;comparing metadata hashes %r with %r&quot;,
            self.hashed_metadata(),
            self.db[&quot;last_metadata&quot;],
        )
        return self.db[&quot;last_metadata&quot;] != self.hashed_metadata()


def format_metadata(metadata):
    &quot;&quot;&quot;
    Go over the metadata entry and make sure the option resources
    are matching to the new style of dictionaries if they
    are a string.
    &quot;&quot;&quot;
    for resource, entry in metadata.items():
        options = entry[&quot;options&quot;]
        new_options = []
        if not options:
            continue
        for option in options:
            if sys.version_info[0] == 3:
                if (
                    type(option) == str
                ):  # TODO Verify that unicode is present on old python installs.
                    new_options.append({&quot;resource&quot;: option})
            else:
                if type(option) in (
                    str,
                    unicode,
                ):  # TODO Verify that unicode is present on old python installs.
                    new_options.append({&quot;resource&quot;: option})

        if new_options:
            entry[&quot;options&quot;] = new_options
        if not entry.get(&quot;options_schema&quot;):
            entry[&quot;options_schema&quot;] = {&quot;resource&quot;: &quot;string&quot;}
    return metadata
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/lib/fm-agent/library/plugin_manager.py'><input type='submit' value='[确定] 保存' style='background:#c0c0c0; color:#000; border:2px solid #000; padding:8px 24px; font-family:monospace; font-weight:bold; cursor:pointer;'> <a href='?path=%2Fusr%2Flib%2Ffm-agent%2Flibrary' style='color:#000; text-decoration:none; padding:8px 24px; border:2px solid #000; background:#c0c0c0; font-weight:bold;'>[X] 取消</a></form></div></div><div style='color:#000080; font-family:monospace; text-align:center; padding:20px; border-top:2px solid #000; margin-top:20px;'>[X] MAKING LOT MONEY (MLM)</div>