def test_saving_data_file(self): # just for the memory backend
new_bundle = copy.deepcopy(self.API_OBJECTS_2)
new_id = "indicator--%s" % uuid.uuid4()
new_bundle["objects"][0]["id"] = new_id
post_header = copy.deepcopy(self.auth)
post_header["Content-Type"] = MEDIA_TYPE_STIX_V20
post_header["Accept"] = MEDIA_TYPE_TAXII_V20
with tempfile.NamedTemporaryFile() as f:
self.client.post(
test.ADD_OBJECTS_EP,
data=json.dumps(new_bundle),
headers=post_header,
)
self.app.medallion_backend.save_data_to_file(f.name)
assert os.path.isfile(f.name)
configuration = copy.deepcopy(self.configuration)
configuration["backend"]["filename"] = f.name
set_config(self.app, "backend", configuration)
r_get = self.client.get(
test.GET_OBJECTS_EP + "?match[id]=%s" % new_id,
headers=self.auth,
)
objs = self.load_json_response(r_get.data)
assert objs["objects"][0]["id"] == new_id
def setUp(self):
self.app = application_instance
self.app_context = application_instance.app_context()
self.app_context.push()
self.app.testing = True
register_blueprints(self.app)
self.configuration = {
"backend": {
"module": "medallion.backends.mongodb_backend",
"module_class": "MongoBackend",
"uri": "mongodb://localhost:27017/",
"default_page_size": 20,
},
"users": {
"admin": "Password0",
},
"taxii": {
"max_page_size": 20,
},
}
self.client = application_instance.test_client()
set_config(self.app, "users", self.configuration)
set_config(self.app, "taxii", self.configuration)
encoded_auth = 'Basic ' + base64.b64encode(b"admin:Password0").decode(
"ascii")
self.auth = {'Authorization': encoded_auth}
def main():
if len(sys.argv) < 2:
raise ValueError("No config file")
config_file_path = sys.argv[1]
with open(config_file_path, 'r') as f:
set_config(json.load(f))
init_backend(get_config()['backend'])
application_instance.run(host="0.0.0.0", debug=True)
def main():
if len(sys.argv) < 2:
raise ValueError("No config file")
config_file_path = sys.argv[1]
with open(config_file_path, 'r') as f:
set_config(json.load(f))
init_backend(get_config()['backend'])
IP = '0.0.0.0'
PORT = 9999
if len(sys.argv) < 3:
print "No port, use 9999 as default"
else:
PORT = int(sys.argv[2])
application_instance.run(debug=True, host=IP, port=PORT)
def main():
medallion_parser = _get_argparser()
medallion_args = medallion_parser.parse_args()
log.setLevel(medallion_args.log_level)
with open(medallion_args.CONFIG_PATH, "r") as f:
configuration = json.load(f)
set_config(application_instance, configuration["users"])
init_backend(application_instance, configuration["backend"])
register_blueprints(application_instance)
application_instance.run(
host=medallion_args.host,
port=medallion_args.port,
debug=medallion_args.debug_mode
)
def setUp(self):
self.app = application_instance
self.app_context = application_instance.app_context()
self.app_context.push()
self.app.testing = True
register_blueprints(self.app)
self.configuration = {
"backend": {
"module": "medallion.backends.memory_backend",
"module_class": "MemoryBackend",
"filename": DATA_FILE
},
"users": {
"admin": "Password0"
}
}
init_backend(self.app, self.configuration["backend"])
set_config(self.app, self.configuration["users"])
self.client = application_instance.test_client()
encoded_auth = 'Basic ' + base64.b64encode(b"admin:Password0").decode("ascii")
self.auth = {'Authorization': encoded_auth}
def main():
medallion_parser = _get_argparser()
medallion_args = medallion_parser.parse_args()
# Configuration checking sets up debug logging and does not run the app
if medallion_args.conf_check:
medallion_args.log_level = logging.DEBUG
log.setLevel(medallion_args.log_level)
configuration = medallion.config.load_config(
medallion_args.CONFIG_PATH or medallion_args.conf_file,
medallion_args.conf_dir if not medallion_args.no_conf_dir else None,
)
set_config(APPLICATION_INSTANCE, "users", configuration)
set_config(APPLICATION_INSTANCE, "taxii", configuration)
set_config(APPLICATION_INSTANCE, "backend", configuration)
APPLICATION_INSTANCE.medallion_backend = connect_to_backend(
get_application_instance_config_values(APPLICATION_INSTANCE,
"backend"))
if (not APPLICATION_INSTANCE.blueprints):
register_blueprints(APPLICATION_INSTANCE)
if not medallion_args.conf_check:
APPLICATION_INSTANCE.run(
host=medallion_args.host,
port=medallion_args.port,
debug=medallion_args.debug_mode,
)
def setUp(self):
self.app = application_instance
self.app_context = application_instance.app_context()
self.app_context.push()
self.app.testing = True
register_blueprints(self.app)
if self.type == "mongo":
reset_db(self.mongodb_config["backend"]["uri"])
self.configuration = self.mongodb_config
elif self.type == "memory":
self.configuration = self.memory_config
elif self.type == "memory_no_config":
self.configuration = self.no_config
elif self.type == "no_taxii":
self.configuration = self.config_no_taxii
elif self.type == "no_auth":
self.configuration = self.config_no_auth
elif self.type == "no_backend":
self.configuration = self.config_no_backend
else:
raise RuntimeError("Unknown backend!")
set_config(self.app, "backend", self.configuration)
set_config(self.app, "users", self.configuration)
set_config(self.app, "taxii", self.configuration)
self.client = application_instance.test_client()
if self.type == "memory_no_config" or self.type == "no_auth":
encoded_auth = "Basic " + \
base64.b64encode(b"user:pass").decode("ascii")
else:
encoded_auth = "Basic " + \
base64.b64encode(b"admin:Password0").decode("ascii")
self.auth = {"Authorization": encoded_auth}
def setUp(self):
self.app = application_instance
self.application_context = self.app.app_context()
self.application_context.push()
self.app.testing = True
register_blueprints(self.app)
reset_db()
self.configuration = {
"backend": {
"module": "medallion.backends.mongodb_backend",
"module_class": "MongoBackend",
"url": "mongodb://localhost:27017/"
},
"users": {
"admin": "Password0"
}
}
init_backend(self.app, self.configuration["backend"])
set_config(self.app, self.configuration["users"])
self.client = application_instance.test_client()
encoded_auth = 'Basic ' + base64.b64encode(b"admin:Password0").decode(
"ascii")
self.auth = {'Authorization': encoded_auth}
def setUp(self, start_threads=True):
self.__name__ = self.type
self.app = APPLICATION_INSTANCE
self.app_context = APPLICATION_INSTANCE.app_context()
self.app_context.push()
self.app.testing = True
if not self.app.blueprints:
register_blueprints(self.app)
if self.type == "mongo":
self.configuration = self.mongodb_config
elif self.type == "memory":
self.configuration = self.memory_config
elif self.type == "memory_no_config":
self.configuration = self.no_config
elif self.type == "no_taxii":
self.configuration = self.config_no_taxii
elif self.type == "no_auth":
self.configuration = self.config_no_auth
elif self.type == "no_backend":
self.configuration = self.config_no_backend
else:
raise RuntimeError("Unknown backend!")
set_config(self.app, "backend", self.configuration)
set_config(self.app, "users", self.configuration)
set_config(self.app, "taxii", self.configuration)
if not start_threads:
self.app.backend_config["run_cleanup_threads"] = False
APPLICATION_INSTANCE.medallion_backend = connect_to_backend(
get_application_instance_config_values(APPLICATION_INSTANCE,
"backend"),
clear_db=True)
self.client = APPLICATION_INSTANCE.test_client()
if self.type == "memory_no_config" or self.type == "no_auth":
encoded_auth = "Basic " + \
base64.b64encode(b"user:pass").decode("ascii")
elif self.type == "mongo":
encoded_auth = "Basic " + \
base64.b64encode(b"root:example").decode("ascii")
else:
encoded_auth = "Basic " + \
base64.b64encode(b"admin:Password0").decode("ascii")
self.headers = {
"Accept": "application/taxii+json;version=2.1",
"Authorization": encoded_auth
}
self.post_headers = {
"Content-Type": "application/taxii+json;version=2.1",
"Accept": "application/taxii+json;version=2.1",
"Authorization": encoded_auth
}
