def test_get_configuration(self): """test the get_configuration function""" string_config = model.Configuration( "String_Config", "sample", "string", "admin" ) bool_config = model.Configuration("Bool_Config", "True", "bool", "admin") integer_config = model.Configuration("Integer_Config", "12", "integer", "admin") db_session.add_all([string_config, bool_config, integer_config]) db_session.commit() self.assertEqual(util.get_configuration("String_Config"), "sample") self.assertEqual(util.get_configuration("Bool_Config"), True) self.assertEqual(util.get_configuration("Integer_Config"), 12)
def from_store(store): """Builds a Configuration object (defined in the model)""" return model.Configuration( backup_directory=get_directory(store, BackupDirectoryOption), provider_spec=get(store, ProviderSpecOption), roms_directory=get_directory(store, ROMsDirectoryOption), userdata_directory=get_directory(store, UserdataDirectoryOption), )
def check_config(): with Session(engine) as session, session.begin(): min_operation_value = session.query( model.Configuration).get("min_operation_value") if not min_operation_value: min_operation_value = model.Configuration( name="min_operation_value", value=2) session.add(min_operation_value) max_operation_value = session.query( model.Configuration).get("max_operation_value") if not max_operation_value: max_operation_value = model.Configuration( name="max_operation_value", value=30) session.add(max_operation_value) min_position_margin = session.query( model.Configuration).get("min_position_margin") if not min_position_margin: min_position_margin = model.Configuration( name="min_position_margin", value=0.5) session.add(min_position_margin) min_year_ratio = session.query( model.Configuration).get("min_year_ratio") if not min_year_ratio: min_year_ratio = model.Configuration(name="min_year_ratio", value=10) session.add(min_year_ratio) min_direct_ratio = session.query( model.Configuration).get("min_direct_ratio") if not min_direct_ratio: min_direct_ratio = model.Configuration(name="min_direct_ratio", value=0.5) session.add(min_direct_ratio)
def save(self): configuration = model.Configuration() configuration.size = [ int(self.width_inpt.get()), int(self.height_inpt.get()) ] configuration.model = self.puzzle_type_var.get() self.master.manager.configuration = configuration self.master.controls.step_pause_time = int( self.step_pause_time_inpt.get()) self.destroy()
def test_configuration(self): """test the configuration table""" CONF_ARGS = { "key": "use_strict_comparison", "val": "True", "valType": "bool", "category": "admin", } # create and add contest conf_type = model.Configuration(**CONF_ARGS) db_session.add(conf_type) db_session.commit() # fetch contest results = model.Configuration.query.filter_by(key=CONF_ARGS["key"]).all() self.assertEqual(len(results), 1)
def add_config(): """ Adds or edits a config Note: must be called from within a request context Returns: a redirect to the config view page """ config_id = request.form.get("config_id") key = request.form.get("key") val = request.form.get("val") valType = request.form.get("valType") category = request.form.get("category") if config_id: # edit config = model.Configuration.query.filter_by(id=int(config_id)).one() config.key = key config.val = val config.valType = valType config.category = category else: # add if is_dup_config_key(key): error = "Failed to add config '{}' as config already exists.".format(key) current_app.logger.info(error) flash(error, "danger") return redirect(url_for("configurations.configurations_view")) config = model.Configuration( key=key, val=val, valType=valType, category=category ) db_session.add(config) db_session.commit() return redirect(url_for("configurations.configurations_view"))
def update_lists(jsonrpc): # safety check omitted for brevity data = jsonrpc["params"]["data"] url = jsonrpc["params"]["url"] # Remove if exist slash at the end of url if url.endswith('/'): url = url[:-1] # if GW posting list of ids if "id" in data: for i in data["id"]: print(i) return # else data contain object item_id = jsonrpc["params"]["data"][":id"] if jsonrpc["method"] == "PUT": # url contain UUID at the end item = url.split('/')[-2] # TODO check what kingd of item and update item print(Colors.WARNING + "TODO --- Update item: " + item + Colors.ENDC) return # else - POST item = url.split('/')[-1] parent_id = url.split('/')[-2] if item == "gateway": global gateway gateway = model.Gateway(data, url, None) print(gateway) if item == "network": global network network = model.Network(data, url, None) print(network) if item == "device": device = model.Device(data, url, parent_id) if device.data["included"] == "0": device.data["included"] = "1" client = Client("/tmp/zero_interface") client.includeDevice(device) else: create_update_item(device, devices) if device.data['product']: print('product: {}'.format(device.data['product'])) if device.data['version_hardware']: print("version_hardware: {}".format( device.data['version_hardware'])) if device.data['version_stack']: print("version_stack: {}".format(device.data['version_stack'])) if device.data['version_boot']: print("version_boot: {}".format(device.data['version_boot'])) if device.data['version_application']: print("version_application: {}".format( device.data['version_application'])) if item == "service": service = model.Service(data, url, parent_id) create_update_item(service, services) if item == "value": value = model.Value(data, url, parent_id) create_update_item(value, values) if item == "status": level = data["level"] status_type = data["type"] message = data["message"] print(Colors.OKGREEN + "Status level: '" + level + "' type: '" + status_type + "' message: '" + message + "'" + Colors.ENDC) if item == "configuration": configuration = model.Configuration(data, url, parent_id) create_update_item(configuration, configurations) if item == "partner": partner = model.Partner(data, url, parent_id) create_update_item(partner, partners) if item == "action": action = model.Action(data, url, parent_id) create_update_item(action, actions) if item == "calendar": calendar = model.Calendar(data, url, parent_id) create_update_item(calendar, calendars) if item == "calculation": calculation = model.Calculation(data, url, parent_id) create_update_item(calculation, calculations) if item == "timer": timer = model.Timer(data, url, parent_id) create_update_item(timer, timers) if item == "statemachine": machine = model.StateMachine(data, url, parent_id) create_update_item(machine, statemachines)
def populate_db(): """Performs the initial database setup for the application """ current_app.logger.info("Initializing db tables") db_session.add_all([ model.UserRole("defendant"), model.UserRole("operator"), model.UserRole("judge"), model.UserRole("executioner"), model.UserRole("observer") ]) # TODO: extract these out into a folder db_session.add_all([ model.Language("python", "python", True, textwrap.dedent(''' #!/bin/bash cat $1 | python3 $2 exit $?''').strip()), model.Language("python2", "python", True, textwrap.dedent(''' #!/bin/bash cat $1 | python2 $2 exit $?''').strip()), model.Language("perl", "perl", True, textwrap.dedent(''' #!/bin/bash cat $1 | perl $2 exit $?''').strip()), model.Language("lua", "lua", True, textwrap.dedent(''' #!/bin/bash cat $1 | lua $2 exit $?''').strip()), model.Language("nodejs", "javascript", True, textwrap.dedent(''' #!/bin/bash cat $1 | node $2 exit $?''').strip()), model.Language("guile", "scheme", True, textwrap.dedent(''' #!/bin/bash cat $1 | guile --no-auto-compile $2 exit $?''').strip()), model.Language("fortran", "fortran", True, textwrap.dedent(''' #!/bin/bash cp /share/program /scratch/program.f cd /scratch gfortran -o program /scratch/program.f if [[ $? != 0 ]]; then exit $? fi cat $1 | ./program exit $?''').strip()), model.Language("c", "clike", True, textwrap.dedent(''' #!/bin/bash cp /share/program /scratch/program.c cd /scratch gcc -o program /scratch/program.c if [[ $? != 0 ]]; then exit $? fi cat $1 | ./program exit $?''').strip(), textwrap.dedent(''' #include <stdio.h> int main(int argc, const char* argv[]) { }''')), model.Language("c++", "clike", True, textwrap.dedent(''' #!/bin/bash cp /share/program /scratch/program.cpp cd /scratch g++ -o program /scratch/program.cpp if [[ $? != 0 ]]; then exit $? fi cat $1 | ./program exit $?''').strip(), textwrap.dedent(''' #include <iostream> int main() { std::cout << "Hello World!"; }''')), model.Language("java", "clike", True, textwrap.dedent(''' #!/bin/bash cp /share/program /scratch/Main.java cd /scratch /usr/lib/jvm/java-1.8-openjdk/bin/javac Main.java if [[ $? != 0 ]]; then exit $? fi cat $1 | /usr/lib/jvm/java-1.8-openjdk/bin/java Main exit $?''').strip(), textwrap.dedent(''' public class Main { public static void main(String[] args) { } }''')), model.Language("ruby", "ruby", True, textwrap.dedent(''' #!/bin/bash cat $1 | ruby $2 exit $?''').strip()), model.Language("rust", "rust", True, textwrap.dedent(''' #!/bin/bash cp /share/program /scratch/main.rs cd /scratch rustc /scratch/main.rs if [[ $? != 0 ]]; then exit $? fi cat $1 | ./main exit $?''').strip()) ]) db_session.add_all([ model.Configuration("strict_whitespace_diffing", "False", "bool", "admin"), model.Configuration("contestants_see_sample_output", "True", "bool", "defendant"), model.Configuration("max_user_submissions", "5", "integer", "defendant"), model.Configuration("user_submission_time_limit", "1", "integer", "defendant"), model.Configuration("max_output_length", str(10 * 1024), "integer", "defendant") ]) db_session.add_all([ model.ProblemType("input-output", '#!/bin/bash\ntest "$1" = "$2"') ]) db_session.commit() roles = {x.name: x for x in model.UserRole.query.all()} db_session.add_all([ model.User( "*****@*****.**", "Admin", "pass", user_roles=[roles['operator']]), model.User( "*****@*****.**", "Executioner", "epass", user_roles=[roles['executioner']]) ]) db_session.commit()
def populate_db(): """Performs the initial database setup for the application """ current_app.logger.info("Initializing db tables") db_session.add_all([ model.UserRole("defendant"), model.UserRole("operator"), model.UserRole("judge"), model.UserRole("executioner"), model.UserRole("observer"), ]) # TODO: extract these out into a folder db_session.add_all([ model.Language( "python", "python", True, textwrap.dedent(""" #!/bin/bash cat $input_file | python3 $program_file exit $?""").strip(), ), model.Language( "python2", "python", True, textwrap.dedent(""" #!/bin/bash cat $input_file | python2 $program_file exit $?""").strip(), ), model.Language( "perl", "perl", True, textwrap.dedent(""" #!/bin/bash cat $input_file | perl $program_file exit $?""").strip(), ), model.Language( "lua", "lua", True, textwrap.dedent(""" #!/bin/bash cat $input_file | lua $program_file exit $?""").strip(), ), model.Language( "nodejs", "javascript", True, textwrap.dedent(""" #!/bin/bash cat $input_file | node $program_file exit $?""").strip(), ), model.Language( "guile", "scheme", True, textwrap.dedent(""" #!/bin/bash cat $input_file | guile --no-auto-compile $program_file exit $?""").strip(), ), model.Language( "fortran", "fortran", True, textwrap.dedent(""" #!/bin/bash cp /share/program $scratch_dir/program.f cd $scratch_dir gfortran -o program $scratch_dir/program.f if [[ $? != 0 ]]; then exit $? fi cat $input_file | ./program exit $?""").strip(), ), model.Language( "c", "clike", True, textwrap.dedent(""" #!/bin/bash cp $program_file $scratch_dir/program.c cd $3 gcc -o program $scratch_dir/program.c if [[ $? != 0 ]]; then exit $? fi cat $input_file | ./program exit $?""").strip(), textwrap.dedent(""" #include <stdio.h> int main(int argc, const char* argv[]) { }"""), ), model.Language( "c++", "clike", True, textwrap.dedent(""" #!/bin/bash cp $program_file $scratch_dir/program.cpp cd $scratch_dir g++ -o program $scratch_dir/program.cpp if [[ $? != 0 ]]; then exit $? fi cat $input_file | ./program exit $?""").strip(), textwrap.dedent(""" #include <iostream> int main() { std::cout << "Hello World!"; }"""), ), model.Language( "java", "clike", True, textwrap.dedent(""" #!/bin/bash export PATH=$PATH:/usr/lib/jvm/java-1.8-openjdk/bin cp $program_file $scratch_dir/Main.java cd $scratch_dir javac Main.java if [[ $? != 0 ]]; then exit $? fi cat $input_file | java Main exit $?""").strip(), textwrap.dedent(""" public class Main { public static void main(String[] args) { } }"""), ), model.Language( "ruby", "ruby", True, textwrap.dedent(""" #!/bin/bash cat $input_file | ruby $program_file exit $?""").strip(), ), model.Language( "rust", "rust", True, textwrap.dedent(""" #!/bin/bash cp /share/program $scratch_dir/main.rs cd $scratch_dir rustc $scratch_dir/main.rs if [[ $? != 0 ]]; then exit $? fi cat $input_file | ./main exit $?""").strip(), textwrap.dedent(""" fn main() { } """).strip(), ), ]) db_session.add_all([ model.Configuration("strict_whitespace_diffing", "False", "bool", "admin"), model.Configuration("contestants_see_sample_output", "True", "bool", "defendant"), model.Configuration("max_user_submissions", "5", "integer", "defendant"), model.Configuration("user_submission_time_limit", "1", "integer", "defendant"), model.Configuration("max_output_length", str(10 * 1024), "integer", "defendant"), model.Configuration("run_refresh_interval_millseconds", 5000, "integer", "defendant"), model.Configuration("score_refresh_interval_millseconds", 30000, "integer", "defendant"), model.Configuration("misc_refresh_interval_millseconds", 12000, "integer", "defendant"), model.Configuration("extra_signup_fields", "[]", "json", "defendant"), ]) db_session.add_all( [model.ProblemType("input-output", '#!/bin/bash\ntest "$1" = "$2"')]) db_session.commit() roles = {x.name: x for x in model.UserRole.query.all()} db_session.add_all([ model.User("admin", "Admin", "pass", user_roles=[roles["operator"]]), model.User("exec", "Executioner", "epass", user_roles=[roles["executioner"]]), ]) db_session.commit() # Version scraper run with open("init_data/printver.py", "r") as f: src_code = "\n".join(f.readlines()) executioner_user = model.User.query.filter_by(username="******").scalar() python = model.Language.query.filter_by(name="python").scalar() empty_input = "" version_contest = model.Contest( name="version_contest", start_time=datetime.datetime.utcnow(), end_time=datetime.datetime.utcnow() + datetime.timedelta(hours=1), is_public=True, activate_time=datetime.datetime.utcnow(), freeze_time=None, deactivate_time=None, ) db_session.add(version_contest) db_session.commit() verscrape_run = model.Run( executioner_user, version_contest, python, None, datetime.datetime.utcnow(), src_code, empty_input, empty_input, True, None, ) db_session.add(verscrape_run) db_session.commit()
def __init__(self): self.serializer = serializer.PuzzleStatementSerializer() self.game = None self.configuration = model.Configuration() self.validator = None self._threads = []