import json
|
import logging, os, sys, subprocess
|
from abc import ABC
|
from app.plugins import UserDataStore, GlobalDataStore
|
from app.plugins.functions import get_plugins_persistent_path
|
from contextlib import contextmanager
|
|
from app.plugins.pyutils import requirements_installed, compute_file_md5
|
|
logger = logging.getLogger('app.logger')
|
|
class PluginBase(ABC):
|
def __init__(self):
|
self.name = self.get_module_name().split(".")[-2]
|
self.manifest = None
|
|
def register(self):
|
self.check_requirements()
|
|
def check_requirements(self):
|
"""
|
Check if Python requirements need to be installed
|
"""
|
req_file = self.get_path("requirements.txt")
|
if os.path.exists(req_file):
|
reqs_installed = requirements_installed(req_file, self.get_python_packages_path())
|
|
md5_file = self.get_python_packages_path("install_md5")
|
md5_mismatch = False
|
req_md5 = compute_file_md5(req_file)
|
|
if os.path.exists(md5_file):
|
with open(md5_file, 'r') as f:
|
md5_mismatch = f.read().strip() != req_md5
|
else:
|
reqs_installed = False
|
|
if not reqs_installed or md5_mismatch:
|
logger.info("Installing requirements.txt for {}".format(self))
|
|
if not os.path.exists(self.get_python_packages_path()):
|
os.makedirs(self.get_python_packages_path(), exist_ok=True)
|
|
p = subprocess.Popen(['python', '-m', 'pip', 'install', '-U', '-r', 'requirements.txt',
|
'--target', self.get_python_packages_path()],
|
cwd=self.get_path())
|
p.wait()
|
|
# Verify
|
if requirements_installed(self.get_path("requirements.txt"), self.get_python_packages_path()):
|
logger.info("Installed requirements.txt for {}".format(self))
|
|
# Write MD5
|
if req_md5:
|
with open(md5_file, 'w') as f:
|
f.write(req_md5)
|
else:
|
logger.warning("Failed to install requirements.txt for {}".format(self))
|
|
def get_persistent_path(self, *paths):
|
return get_plugins_persistent_path(self.name, *paths)
|
|
def get_python_packages_path(self, *paths):
|
return self.get_persistent_path("site-packages", *paths)
|
|
@contextmanager
|
def python_imports(self):
|
# Add python path
|
sys.path.insert(0, self.get_python_packages_path())
|
try:
|
yield
|
finally:
|
# Remove python path
|
sys.path.remove(self.get_python_packages_path())
|
|
|
def get_path(self, *paths):
|
"""
|
Gets the path of the directory of the plugin, optionally chained with paths
|
:return: path
|
"""
|
return os.path.join(os.path.dirname(sys.modules[self.get_module_name()].__file__), *paths)
|
|
def get_name(self):
|
"""
|
:return: Name of current module (reflects the directory in which this plugin is stored)
|
"""
|
return self.name
|
|
def get_user_data_store(self, user):
|
"""
|
Helper function to instantiate a user data store associated
|
with this plugin
|
:return: UserDataStore
|
"""
|
return UserDataStore(self.get_name(), user)
|
|
def get_global_data_store(self):
|
"""
|
Helper function to instantiate a user data store associated
|
with this plugin
|
:return: GlobalDataStore
|
"""
|
return GlobalDataStore(self.get_name())
|
|
def get_module_name(self):
|
return self.__class__.__module__
|
|
def get_include_js_urls(self):
|
return [self.public_url(js_file) for js_file in self.include_js_files()]
|
|
def get_include_css_urls(self):
|
return [self.public_url(css_file) for css_file in self.include_css_files()]
|
|
def public_url(self, path):
|
"""
|
:param path: unix-style path
|
:return: Path that can be accessed via a URL (from the browser), relative to plugins/<yourplugin>/public
|
"""
|
return "/plugins/{}/{}".format(self.get_name(), path)
|
|
def is_persistent(self):
|
"""
|
:return: whether this plugin is persistent (stored in the /plugins directory,
|
instead of /app/media/plugins which are transient)
|
"""
|
return ".." in os.path.relpath(self.get_path(), get_plugins_persistent_path())
|
|
def template_path(self, path):
|
"""
|
:param path: unix-style path
|
:return: path used to reference Django templates for a plugin
|
"""
|
if self.is_persistent():
|
return "coreplugins/{}/templates/{}".format(self.get_name(), path)
|
else:
|
return "plugins/{}/templates/{}".format(self.get_name(), path)
|
|
|
def path_exists(self, path):
|
return os.path.exists(self.get_path(path))
|
|
def include_js_files(self):
|
"""
|
Should be overriden by plugins to communicate
|
which JS files should be included in the WebODM interface
|
All paths are relative to a plugin's /public folder.
|
"""
|
return []
|
|
def include_css_files(self):
|
"""
|
Should be overriden by plugins to communicate
|
which CSS files should be included in the WebODM interface
|
All paths are relative to a plugin's /public folder.
|
"""
|
return []
|
|
def build_jsx_components(self):
|
"""
|
Experimental
|
Should be overriden by plugins that want to automatically
|
build JSX files.
|
All paths are relative to a plugin's /public folder.
|
"""
|
return []
|
|
def requires_restart(self):
|
"""
|
Whether the plugin requires an app restart to
|
function properly
|
"""
|
return len(self.root_mount_points()) > 0
|
|
def main_menu(self):
|
"""
|
Should be overriden by plugins that want to add
|
items to the side menu.
|
:return: [] of Menu objects
|
"""
|
return []
|
|
def root_mount_points(self):
|
"""
|
Should be overriden by plugins that want to
|
add routes to the root view controller.
|
CAUTION: this should be used sparingly, as
|
routes could conflict with other plugins and
|
future versions of WebODM might break the routes.
|
It's recommended to use app_mount_points, unless
|
you know what you are doing.
|
:return: [] of MountPoint objects
|
"""
|
return []
|
|
def app_mount_points(self):
|
"""
|
Should be overriden by plugins that want to connect
|
custom Django views
|
:return: [] of MountPoint objects
|
"""
|
return []
|
|
def api_mount_points(self):
|
"""
|
Should be overriden by plugins that want to add
|
new API mount points
|
:return: [] of MountPoint objects
|
"""
|
return []
|
|
def serve_public_assets(self, request):
|
"""
|
Should be overriden by plugins that want to control which users
|
have access to the public assets. By default anyone can access them,
|
including anonymous users.
|
:param request: HTTP request
|
:return: boolean (whether the plugin's public assets should be exposed for this request)
|
"""
|
return True
|
|
def get_dynamic_script(self, script_path, callback = None, **template_args):
|
"""
|
Retrieves a view handler that serves a dynamic script from
|
the plugin's directory. Dynamic scripts are normal Javascript
|
files that optionally support Template variable substitution
|
via ${vars}, computed on the server.
|
:param script_path: path to script relative to plugin's directory.
|
:param callback: optional callback. The callback can prevent the script from being returned if it returns False.
|
If it returns a dictionary, the dictionary items are used for variable substitution.
|
:param template_args: Parameters to use for variable substitution (unless a callback is specified)
|
:return: Django view
|
"""
|
from app.plugins import get_dynamic_script_handler
|
return get_dynamic_script_handler(self.get_path(script_path), callback, **template_args)
|
|
def get_manifest(self):
|
# Lazy loading
|
if self.manifest: return self.manifest
|
|
manifest_path = self.get_path("manifest.json")
|
|
# Read manifest
|
with open(manifest_path) as manifest_file:
|
self.manifest = json.load(manifest_file)
|
|
return self.manifest
|
|
def __str__(self):
|
return "[{}]".format(self.get_module_name())
|
