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 = []
