class ModHandler:
def __init__(self, url=None, password=None, sessionfile=None):
self.sessions = Sessions(url, password, sessionfile)
self.set_url_pwd()
self.interpreter = None
self.modules_names_by_group = {}
self.modules_classes = {}
self.modules = {}
self._guess_modules_path()
self._load_modules_tree()
self.verbosity = [3]
self._last_warns = ''
def set_url_pwd(self):
self.url = self.sessions.get_session()['global']['url']
self.password = self.sessions.get_session()['global']['password']
def _guess_modules_path(self):
try:
current_path = os.path.realpath(__file__)
root_path = os.sep.join(current_path.split(os.sep)[:-2]) + os.sep
self.modules_path = root_path + 'modules'
except Exception, e:
raise Exception('Error finding module path: %s' % str(e))
if not os.path.exists(self.modules_path):
raise Exception("No module directory %s found." %
self.modules_path)
def __init__(self, url=None, password=None, sessionfile=None):
self.sessions = Sessions(url, password, sessionfile)
self.set_url_pwd()
self.interpreter = None
self.modules_names_by_group = {}
self.modules_classes = {}
self.modules = {}
self._guess_modules_path()
self._load_modules_tree()
self.verbosity = [3]
self._last_warns = ''
def __init__(self, *args, **kwargs):
from core.db import Database, DatabaseQueueWorker
from core.sessions import Sessions
super(Vmmaster, self).__init__(*args, **kwargs)
self.running = True
self.json_encoder = JSONEncoder
self.database = Database()
self.database_task_queue = deque()
self.database_task_worker = DatabaseQueueWorker(
self.database_task_queue)
self.database_task_worker.start()
self.sessions = Sessions(self.database, self.app_context)
self.sessions.start_workers()
def __init__(self, *args, **kwargs):
from core.db import Database
from core.sessions import Sessions
from vmpool.virtual_machines_pool import VirtualMachinesPool
super(Provider, self).__init__(*args, **kwargs)
self.running = True
self.json_encoder = JSONEncoder
self.database = Database()
self.sessions = Sessions(self.database, self.app_context)
self.pool = VirtualMachinesPool(app=self, name=config.PROVIDER_NAME)
self.pool.start_workers()
def __init__(self, *args, **kwargs):
from core.db import Database
from core.sessions import Sessions
from vmpool.virtual_machines_pool import VirtualMachinesPool
super(Vmmaster, self).__init__(*args, **kwargs)
self.running = True
self.uuid = str(uuid1())
self.database = Database()
self.pool = VirtualMachinesPool(self)
self.sessions = Sessions(self)
self.json_encoder = JSONEncoder
self.register()
def validar(self):
user_hash = get_hash("sha256", get_form_value("username"))
pass_hash = get_hash("sha512", get_form_value("password"))
user_id = get_hash("sha384", get_form_value("username"))
user_id = get_hash("md5", user_id)
salt_username = get_form_value("username")[0:2]
salt_password = get_form_value("password")[1:]
salt = get_hash("sha224", "{}{}".format(salt_username, salt_password))
credential = get_hash("sha1", "{}{}{}".format(salt, user_hash, pass_hash))
filename = "{}/.{}".format(CREDENTIAL_PATH, credential)
#print(HTTP_HTML, "\n")
#print(filename); exit()
if isfile(filename):
#sess_file = Sessions.get_all()
variable = Sessions.create()
print(HTTP_HTML, "\n")
print(variable); exit()
Sessions.set("USER_ID", user_id)
redirect("cliente/listar")
else:
redirect("user/login")
class ModHandler:
def __init__(self, url = None, password = None, sessionfile=None):
self.sessions = Sessions(url, password, sessionfile)
self.set_url_pwd()
self.interpreter = None
self.modules_names_by_group = {}
self.modules_classes = {}
self.modules = {}
self._guess_modules_path()
self._load_modules_tree()
self.verbosity=[ 3 ]
self._last_warns = ''
def set_url_pwd(self):
self.url = self.sessions.get_session()['global']['url']
self.password = self.sessions.get_session()['global']['password']
def _guess_modules_path(self):
try:
current_path = os.path.realpath( __file__ )
root_path = os.sep.join(current_path.split(os.sep)[:-2]) + os.sep
self.modules_path = root_path + 'modules'
except Exception, e :
raise Exception('Error finding module path: %s' % str(e))
if not os.path.exists(self.modules_path):
raise Exception( "No module directory %s found." % self.modules_path )
def __init__(self, url = None, password = None, sessionfile=None):
self.sessions = Sessions(url, password, sessionfile)
self.set_url_pwd()
self.interpreter = None
self.modules_names_by_group = {}
self.modules_classes = {}
self.modules = {}
self._guess_modules_path()
self._load_modules_tree()
self.verbosity=[ 3 ]
self._last_warns = ''
def __init__(self):
self.name = 'main'
self.prompt_session = PromptSession(
'ST ≫ ',
bottom_toolbar=bottom_toolbar,
auto_suggest=AutoSuggestFromHistory(),
enable_history_search=True,
# rprompt=get_rprompt,
style=rprompt_style
)
self.contexts = [
Listeners(self.prompt_session),
Sessions(self.prompt_session),
Modules(self.prompt_session),
Stagers(self.prompt_session)
]
self.prompt_session.completer = WordCompleter([ctx.name for ctx in self.contexts] + ['exit'], ignore_case=True)
self.prompt_session.contexts = self.contexts
self.current_context = self
def __init__(self):
self.name = 'main'
self.completer = WordCompleter(
['listeners', 'sessions', 'modules', 'stagers', 'exit'],
ignore_case=True)
self.prompt_session = PromptSession(
'ST ≫ ',
bottom_toolbar=bottom_toolbar,
completer=self.completer,
auto_suggest=AutoSuggestFromHistory()
#rprompt=get_rprompt,
#style=rprompt_style
)
self.contexts = [
Listeners(self.prompt_session),
Sessions(self.prompt_session),
Modules(self.prompt_session),
Stagers(self.prompt_session)
]
self.current_context = self
logging.info('"%s"' % config.SHIVA_USER_AGENT)
logging.info('Tornado version: %s' % tornado.version)
logging.info('WMS Server started [port %s]' % (config.SHIVA_PORT))
logging.info('Oracle connection: %s:%s' % (RC_IP, RC_PORT))
app = Application(handlers=urls.handlers,
**{
'static_path': config.STATIC_DIR,
'default_handler': MissingHandler,
'debug': False,
'gzip': True,
'ssl_options': {
"certfile": os.path.join("certs/server.crt"),
"keyfile": os.path.join("certs/server.key"),
},
})
app.sessions = Sessions()
# кэш имен файлов паспортов качества - {'имя':None} 33
app.passport_cash = {}
http_server = tornado.httpserver.HTTPServer(app, xheaders=True)
#http_server.listen(config.SHIVA_PORT)
http_server.bind(config.SHIVA_PORT)
http_server.start(
MAX_SESSIONS) # autodetect number of cores and fork a process for each
IOLoop.instance().start()
def listar(self):
Sessions.check()
c = Collector()
c.get("Cliente")
self.view.listar(c.coleccion)
def logout(self):
Sessions.destroy()
redirect("user/login")
def login(self):
Sessions.start()
self.view.login()
class Vmmaster(Flask):
balance_lock = threading.Lock()
def __init__(self, *args, **kwargs):
from core.db import Database, DatabaseQueueWorker
from core.sessions import Sessions
super(Vmmaster, self).__init__(*args, **kwargs)
self.running = True
self.json_encoder = JSONEncoder
self.database = Database()
self.database_task_queue = deque()
self.database_task_worker = DatabaseQueueWorker(
self.database_task_queue)
self.database_task_worker.start()
self.sessions = Sessions(self.database, self.app_context)
self.sessions.start_workers()
def cleanup(self):
log.info("Cleanup...")
try:
self.database_task_worker.stop()
self.sessions.stop_workers()
log.info("Cleanup done")
except:
log.exception("Cleanup was finished with errors")
@property
def providers(self):
return self.database.get_active_providers()
def stop(self):
self.running = False
def get_matched_platforms(self, dc):
from vmmaster.matcher import SeleniumMatcher, PlatformsBasedMatcher
providers_platforms, limits = {}, {}
with self.balance_lock:
for provider in self.providers:
platforms = self.database.get_platforms(provider.id)
matcher = SeleniumMatcher(
platforms=provider.config,
fallback_matcher=PlatformsBasedMatcher(platforms))
matched_platforms = matcher.get_matched_platforms(dc)
if matched_platforms and provider.max_limit:
providers_platforms[provider.id] = matched_platforms
limits[provider.id] = provider.max_limit
if not providers_platforms:
return None, None
provider_id = self.get_provider_id(limits)
if provider_id:
return providers_platforms[provider_id][0], provider_id
return None, None
def get_provider_id(self, limits):
availables = {}
for provider_id, limit in limits.items():
sessions = self.sessions.active(provider_id=provider_id)
availables[provider_id] = limit - len(sessions)
if availables:
max_value = max(availables.values())
return availables.keys()[availables.values().index(max_value)]
#!/usr/bin/env python3
#-*- coding: utf-8 -*-
from os.path import isfile
from core.sessions import Sessions
from settings import MODULE_PATH, PACKAGE, CONTROLLER, RESOURCE, HTTP_404,\
HTTP_HTML, SHOW_ERROR_404, HTTP_REDIRECT, MODULE
Sessions.update()
error_module = error_resource = True
if isfile(MODULE_PATH):
modulo = __import__(PACKAGE, fromlist=[CONTROLLER])
controller = getattr(modulo, CONTROLLER)()
error_module = False
if not error_module and hasattr(controller, RESOURCE):
getattr(controller, RESOURCE)()
error_resource = False
if error_module or error_resource:
error_header = "{}\n{}\n{}".format(HTTP_HTML, HTTP_404, "")
location_header = "{}\n\n".format(HTTP_REDIRECT)
print(error_header if SHOW_ERROR_404 else location_header)
