def setUp(self):
database.initialize()
if not isdir(profile_visualizations_path):
mkdir(profile_visualizations_path)
self.start = datetime.utcnow()
initialize_threading()
self.controller = Controller(workflows_path=config.test_workflows_path)
def setUp(self):
case_database.initialize()
self.cases1 = {
'case1': {
'uid1': ['e1', 'e2', 'e3'],
'uid2': ['e1']
},
'case2': {
'uid1': ['e2', 'e3']
}
}
self.cases_overlap = {
'case2': {
'uid3': ['e', 'b', 'c'],
'uid4': ['d']
},
'case3': {
'uid1': ['a', 'b']
}
}
self.cases2 = {
'case3': {
'uid3': ['e', 'b', 'c'],
'uid4': ['d']
},
'case4': {
'uid1': ['a', 'b']
}
}
self.cases_all = dict(self.cases1)
self.cases_all.update(self.cases2)
def run():
setup_logger()
monkey.patch_all()
# The order of these imports matter for initialization (should probably be fixed)
from compose_api import compose_api
compose_api()
from server import flaskserver
import core.case.database as case_database
case_database.initialize()
ssl_context = get_ssl_context()
flaskserver.running_context.controller.initialize_threading()
try:
port = int(config.port)
except ValueError:
print('Invalid port {0}. Port must be an integer'.format(config.port))
else:
host = config.host
if ssl_context:
server = WSGIServer((host, port),
application=flaskserver.app,
ssl_context=ssl_context)
proto = 'https'
else:
server = WSGIServer((host, port), application=flaskserver.app)
proto = 'http'
logger.info('Listening on host {0}://{1}:{2}'.format(
proto, host, port))
server.serve_forever()
def setUp(self):
self.start = datetime.utcnow()
case_database.initialize()
self.controller = core.controller.controller
self.controller.workflows = {}
self.controller.load_playbooks(
resource_collection=config.test_workflows_path)
def setUp(self):
self.empty_workflow_json = \
{'actions': [],
'name': 'test_name',
'start': 'start',
'branches': []}
case_database.initialize()
def setUp(self):
# This looks awful, I know
self.empty_workflow_json = \
{'steps': [],
'name': 'test_name',
'start': 'start',
'accumulated_risk': 0.0}
case_database.initialize()
def setUp(self):
self.controller = core.controller.controller
self.controller.workflows = {}
self.controller.load_playbooks(
resource_collection=path.join(".", "tests", "testWorkflows", "testGeneratedWorkflows"))
self.controller.load_playbook(
resource=path.join(config.test_workflows_path, 'simpleDataManipulationWorkflow.playbook'))
self.id_tuple = ('simpleDataManipulationWorkflow', 'helloWorldWorkflow')
self.testWorkflow = self.controller.get_workflow(*self.id_tuple)
self.testWorkflow.set_execution_uid('some_uid')
case_database.initialize()
def setUp(self):
case_database.initialize()
self.controller = Controller(workflows_path=path.join(
".", "tests", "testWorkflows", "testGeneratedWorkflows"))
self.controller.load_workflows_from_file(
path=path.join(config.test_workflows_path,
'simpleDataManipulationWorkflow.playbook'))
self.id_tuple = ('simpleDataManipulationWorkflow',
'helloWorldWorkflow')
self.workflow_name = construct_workflow_name_key(*self.id_tuple)
self.testWorkflow = self.controller.get_workflow(*self.id_tuple)
def setUp(self):
case_database.initialize()
self.app = flask_server.app.test_client(self)
self.app.testing = True
self.app.post('/login',
data=dict(email='admin', password='******'),
follow_redirects=True)
response = self.app.post('/key',
data=dict(email='admin', password='******'),
follow_redirects=True).get_data(as_text=True)
self.key = json.loads(response)["auth_token"]
self.headers = {"Authentication-Token": self.key}
def setUp(self):
case_database.initialize()
self.app = flask_server.app.test_client(self)
self.app.testing = True
self.app.post('/login',
data=dict(email='admin', password='******'),
follow_redirects=True)
self.c = controller.Controller()
self.c.loadWorkflowsFromFile(
path=path.join(config.testWorkflowsPath,
'simpleDataManipulationWorkflow.workflow'))
self.id_tuple = ('simpleDataManipulationWorkflow',
'helloWorldWorkflow')
self.workflow_name = construct_workflow_name_key(*self.id_tuple)
self.testWorkflow = self.c.get_workflow(*self.id_tuple)
def run(host, port):
from core.multiprocessedexecutor.multiprocessedexecutor import spawn_worker_processes
setup_logger()
print_banner()
pids = spawn_worker_processes()
monkey.patch_all()
from compose_api import compose_api
compose_api()
from server import flaskserver
flaskserver.running_context.controller.initialize_threading(pids=pids)
# The order of these imports matter for initialization (should probably be fixed)
import core.case.database as case_database
case_database.initialize()
server = setup_server(flaskserver.app, host, port)
server.serve_forever()
def setUp(self):
self.c = core.controller.controller
case_database.initialize()
def setUp(self):
case_database.initialize()
def setUp(self):
self.c = core.controller.controller
self.c.initialize_threading()
case_database.initialize()
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_1)
else:
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
if isfile(config.certificatePath) and isfile(config.privateKeyPath):
context.load_cert_chain(config.certificatePath,
config.privateKeyPath)
return context
else:
flaskServer.displayIfFileNotFound(config.certificatePath)
flaskServer.displayIfFileNotFound(config.privateKeyPath)
return None
if __name__ == "__main__":
case_database.initialize()
ssl_context = get_ssl_context()
try:
port = int(config.port)
host = config.host
if ssl_context:
server = WSGIServer((host, port),
application=flaskServer.app,
ssl_context=ssl_context)
else:
server = WSGIServer((host, port), application=flaskServer.app)
print('Listening on host ' + host + ' and port ' + str(port) + '...')
server.serve_forever()
except ValueError:
print('Invalid port {0}. Port must be an integer'.format(config.port))
def setUp(self):
monkey.patch_socket()
core.case.subscription.subscriptions = {}
case_database.initialize()
def setUp(self):
case_database.initialize()
initialize_threading()
pass
def setUp(self):
case_database.initialize()
self.c = controller.Controller()
if not isdir(core_config.profileVisualizationsPath):
mkdir(core_config.profileVisualizationsPath)
self.start = datetime.utcnow()
def setUp(self):
case_database.initialize()
running_context.init_threads()
def setUp(self):
flaskserver.running_context.controller.initialize_threading()
case_database.initialize()
def setUp(self):
database.initialize()
if not isdir(profile_visualizations_path):
mkdir(profile_visualizations_path)
self.start = datetime.utcnow()
running_context.init_threads()
