def init_plugin(name, module=None, optional=False):
"""
Installs a plug-in specified by the supplied name (or name and module).
arguments:
name -- a name of the plugin
module -- if supplied then name->module inference is skipped and init_plugin
uses this module as a source of the plug-in
optional -- if True then the module is installed only if it is configured
"""
if not optional or has_configured_plugin(name):
try:
if module is None:
if not settings.contains('plugins', name):
raise PluginException('Missing configuration for the "%s" plugin' % name)
plugin_module = plugins.load_plugin_module(settings.get('plugins', name)['module'])
else:
plugin_module = module
plugins.install_plugin(name, plugin_module, settings)
except ImportError as e:
logging.getLogger(__name__).warn('Plugin [%s] configured but following error occurred: %r'
% (name, e))
except (PluginException, Exception) as e:
from controller.errors import get_traceback
logging.getLogger(__name__).critical('Failed to initiate plug-in %s: %s' % (name, e))
logging.getLogger(__name__).error(''.join(get_traceback()))
raise e
else:
plugins.add_missing_plugin(name)
def init_plugin(name, module=None, optional=False):
"""
Installs a plug-in specified by the supplied name (or name and module).
arguments:
name -- a name of the plugin
module -- if supplied then name->module inference is skipped and init_plugin
uses this module as a source of the plug-in
optional -- if True then the module is installed only if it is configured
"""
if not optional or has_configured_plugin(name):
try:
if module is None:
if not settings.contains('plugins', name):
raise PluginException(
'Missing configuration for the "%s" plugin' % name)
plugin_module = plugins.load_plugin_module(
settings.get('plugins', name)['module'])
else:
plugin_module = module
plugins.install_plugin(name, plugin_module, settings)
except ImportError as e:
logging.getLogger(__name__).warn(
'Plugin [%s] configured but following error occurred: %r' %
(name, e))
except (PluginException, Exception) as e:
logging.getLogger(__name__).critical(
'Failed to initiate plug-in %s: %s' % (name, e))
raise e
else:
plugins.add_missing_plugin(name)
def run(args):
client = Client(base_url=args.base_url,
base_auth=args.base_authentication)
try:
if hasattr(args, 'list'):
if args.user:
plugins = list_plugins(client, key='userInstalled',
value='boolean', pattern='true')
elif args.system:
plugins = list_plugins(client, key='userInstalled',
value='boolean', pattern='false')
elif args.key:
plugins = list_plugins(client, key='key', value='regex',
pattern=args.key)
elif args.key_configuration_file:
config = read_config(args.key_configuration_file)
key = get_key_config(config)
plugins = list_plugins(client, key='key', value='regex',
pattern=key)
else:
plugins = list_plugins(client)
if plugins is not None:
print plugins
elif hasattr(args, 'show'):
plugin = show_plugin(client, args.key)
print plugin
elif hasattr(args, 'install'):
token = get_upm_token(client)
client.request.url = args.base_url
install_plugin(client, token, args.plugin)
elif hasattr(args, 'delete'):
delete_plugin(client, args.key)
elif hasattr(args, 'activate'):
activate_plugin(client, args.key)
elif hasattr(args, 'deactivate'):
deactivate_plugin(client, args.key)
except ClientError as e:
print >> sys.stderr, "%s: %s" % ('upmctl', e)
sys.exit(1)
sys.exit(0)
def start():
import namb.gui as gui
global m
m=gui.MainWindow()
import extensions
extensions.load()
extensions.load_extension("vlc")
import plugins
plugins.load()
plugins.install_plugin("radionpo")
plugins.load_plugin("radionpo")
#plugins.load_plugin("jazzradio_com")
global g
g=plugins.get_plugin("radionpo")
g.init()
g.display(m.p.frame)
import namb.userinput
namb.userinput.set_receiver(g.menu)
g.menu.focus_receive()
m.p.frame.after(1, lambda: m.bar.menu_vanish())
ui_loop()
def init_plugin(name, module=None, optional=False):
"""
Installs a plug-in specified by the supplied name (or name and module).
arguments:
name -- a name of the plugin
module -- if supplied then name->module inference is skipped and init_plugin
uses this module as a source of the plug-in
optional -- if True then the module is installed only if it is configured
"""
if not optional or has_configured_plugin(name):
try:
if module is None:
if not settings.contains('plugins', name):
raise PluginException(
'Missing configuration for the "%s" plugin' % name)
plugin_module = plugins.load_plugin_module(
settings.get('plugins', name)['module'])
else:
plugin_module = module
plg = plugins.install_plugin(name, plugin_module, settings)
if hasattr(plg, 'wait_for_environment') and callable(
plg.wait_for_environment):
logging.getLogger(__name__).info(
f'Plug-in {plg.__class__.__name__} is waiting for environment'
)
err = plg.wait_for_environment()
if err:
logging.getLogger(__name__).error(
f'{plg.__class__.__name__}: {err}')
else:
logging.getLogger(__name__).info(
f'Plug-in {plg.__class__.__name__} environment OK')
except ImportError as e:
logging.getLogger(__name__).warn(
'Plugin [%s] configured but following error occurred: %r' %
(name, e))
except (PluginException, Exception) as e:
from controller.errors import get_traceback
logging.getLogger(__name__).critical(
'Failed to initiate plug-in %s: %s' % (name, e))
logging.getLogger(__name__).error(''.join(get_traceback()))
raise e
else:
plugins.add_missing_plugin(name)
logging.getLogger(__name__).warn('More than %d errors occured.' % MAX_NUM_SHOW_ERRORS)
if len(errors) == 0:
return info
else:
return errors
if __name__ == '__main__':
sys.path.insert(0, os.path.realpath('%s/../..' % os.path.dirname(os.path.realpath(__file__))))
import autoconf
settings = autoconf.settings
logger = autoconf.logger
import plugins
from plugins import redis_db
plugins.install_plugin('db', redis_db, autoconf.settings)
from plugins.ucnk_conc_persistence2 import KEY_ALPHABET, PERSIST_LEVEL_KEY
parser = argparse.ArgumentParser(description='Archive old records from Synchronize data from mysql db to redis')
parser.add_argument('-k', '--key-prefix', type=str,
help='Processes just keys with defined prefix')
parser.add_argument('-c', '--cron-interval', type=int,
help='Non-empty values initializes partial processing with '
'defined interval between chunks')
parser.add_argument('-d', '--dry-run', action='store_true',
help='allows running without affecting storage data')
parser.add_argument('-l', '--log-file', type=str,
help='A file used for logging. If omitted then stdout is used')
args = parser.parse_args()
autoconf.setup_logger(log_path=args.log_file, logger_name='conc_archive')
import sys
import os
sys.path.insert(0, os.path.realpath('%s/..' % os.path.dirname(__file__)))
import autoconf
import plugins
from plugins import lindat_db
plugins.install_plugin('db', lindat_db, autoconf.settings)
if __name__ == '__main__':
plugin_db = plugins.runtime.DB.instance
redis = getattr(plugin_db, 'redis')
# cleanup caches etc.
redis.flushdb()
auth_db = plugin_db.get_instance('auth')
redis = getattr(auth_db, 'redis')
keys = list([key for key in list(auth_db.keys()) if key != '__user_count'])
for key in keys:
try:
auth_db.hash_get_all(key)
except:
data = redis.hgetall(key)
for k, v in list(data.items()):
if k == 'id':
v = int(v)
auth_db.hash_set(key, k, v)
"""
import argparse
import os
import sys
import logging
import json
from datetime import datetime
sys.path.insert(0, '%s/../..' % os.path.realpath(os.path.dirname(__file__)))
import autoconf
import plugins
from plugins import redis_db
plugins.install_plugin('db', redis_db, autoconf.settings)
from plugins import default_sessions
plugins.install_plugin('sessions', default_sessions, autoconf.settings)
from plugins import ucnk_remote_auth2
plugins.install_plugin('auth', ucnk_remote_auth2, autoconf.settings)
import mysql2redis as m2r
logger = logging.getLogger('syncdb')
DEFAULT_CHECK_INTERVAL = 5
class DbSync(object):
#!/usr/bin/env python
import sys
import os
sys.path.insert(0, os.path.realpath('%s/../..' % os.path.dirname(__file__)))
import autoconf
import plugins
from plugins import redis_db
plugins.install_plugin('db', redis_db, autoconf.settings)
from plugins import default_query_storage
plugins.install_plugin('query_storage', default_query_storage,
autoconf.settings)
if __name__ == '__main__':
import argparse
import json
argparser = argparse.ArgumentParser(description="User data editor")
argparser.add_argument('source_file',
metavar="FILE",
help="a file containing JSON-encoded initial data")
argparser.add_argument('action',
metavar="ACTION",
help="an action to be performed (add, reset)")
argparser.add_argument(
'-s',
'--specific-id',
type=int,
help=
#!/usr/bin/env python
import sys
import os
sys.path.insert(0, os.path.realpath('%s/../..' % os.path.dirname(__file__)))
import autoconf
import plugins
from plugins import redis_db
plugins.install_plugin('db', redis_db, autoconf.settings)
from plugins import default_query_storage
plugins.install_plugin('query_storage', default_query_storage, autoconf.settings)
if __name__ == '__main__':
import argparse
import json
argparser = argparse.ArgumentParser(description="User data editor")
argparser.add_argument('source_file', metavar="FILE", help="a file containing JSON-encoded initial data")
argparser.add_argument('action', metavar="ACTION", help="an action to be performed (add, reset)")
argparser.add_argument('-s', '--specific-id', type=int, help='add only user with specific ID (even if the source contains a list)')
argparser.add_argument('-d', '--dry-run', action='store_true',
help='allows running without affecting storage data')
args = argparser.parse_args()
if not args.dry_run:
print("==================================================")
else:
print("==================== dry run =====================")
import sys
import os
sys.path.insert(0, os.path.realpath('%s/..' % os.path.dirname(__file__)))
import autoconf
import plugins
from plugins import lindat_db
plugins.install_plugin('db', lindat_db, autoconf.settings)
if __name__ == '__main__':
plugin_db = plugins.runtime.DB.instance
redis = getattr(plugin_db, 'redis')
# cleanup caches etc.
redis.flushdb()
auth_db = plugin_db.get_instance('auth')
redis = getattr(auth_db, 'redis')
keys = list(filter(lambda key: key != '__user_count', auth_db.keys()))
for key in keys:
try:
auth_db.hash_get_all(key)
except:
data = redis.hgetall(key)
for k,v in data.items():
if k == 'id':
v = int(v)
auth_db.hash_set(key, k, v)
import sys
import os
import sqlite3
import re
import json
sys.path.insert(0, os.path.realpath('%s/..' % os.path.dirname(__file__)))
import autoconf
import plugins
from plugins import redis_db
plugins.install_plugin('db', redis_db, autoconf.settings)
DB_CONF_ENTRY = 'ucnk:archive_db_path'
def fix_new_lines(data):
if 'q' in data:
new_q = []
for item in data['q']:
new_q.append(re.sub(r'[\n\r]+', ' ', item).strip())
data['q'] = new_q
else:
raise ValueError('"q" not found in the record')
def get_sqlite_conn():
conf = autoconf.settings.get('plugins', 'conc_persistence')
db_path = conf.get(DB_CONF_ENTRY, None)
if db_path:
return sqlite3.connect(db_path)
#!/usr/bin/env python
import sys
import os
sys.path.insert(0, os.path.realpath("%s/../.." % os.path.dirname(__file__)))
import autoconf
import plugins
from plugins import redis_db
plugins.install_plugin("db", redis_db, autoconf.settings)
from plugins import default_query_storage
plugins.install_plugin("query_storage", default_query_storage, autoconf.settings)
if __name__ == "__main__":
import argparse
import json
argparser = argparse.ArgumentParser(description="User data editor")
argparser.add_argument("source_file", metavar="FILE", help="a file containing JSON-encoded initial data")
argparser.add_argument("action", metavar="ACTION", help="an action to be performed (add, reset)")
argparser.add_argument(
"-s", "--specific-id", type=int, help="add only user with specific ID (even if the source contains a list)"
)
argparser.add_argument("-d", "--dry-run", action="store_true", help="allows running without affecting storage data")
args = argparser.parse_args()
if not args.dry_run:
