def execute():
_state = election.ElectionState().get()
if _state == election.ETAPP_TYHISTUS:
qlist = election.Election().get_questions()
for el in qlist:
print el
htsdisp.start_revocation(el)
elif _state == election.ETAPP_LUGEMINE:
qlist = election.Election().get_questions()
for el in qlist:
print el
htsdisp.start_tabulation(el)
else:
pass
def init_hts(self):
import htscommon
election.Election().get_root_reg().ensure_key(\
htscommon.get_verification_key())
self.__quest.create_keys(G_HTS_KEYS)
self.__quest.create_revlog()
def validate_form(form, required):
try:
logline = ''
invalid = get_invalid_keys(form, required)
if len(invalid) != 0:
logline = 'Invalid form: '
for el in invalid:
if len(el) == 2:
logline = ("%skey - %s, reason - %s;" %
(logline, el[0], REASONS[el[1]]))
elif len(el) == 3:
logline = ("%skey - %s, reason - %s, extra - %s" %
(logline, el[0], REASONS[el[1]], el[2][:200]))
else:
logline = "%sinternal error" % logline
return False, logline
if evcommon.POST_EVOTE in required:
return validate_vote(form.getvalue(evcommon.POST_EVOTE),
election.Election().get_questions())
return True, logline
except:
logline = ('Invalid form: key - exception, reason - %s' %
exception_msg.trace())
return False, logline
def execute(ex_elid, ex_type, ex_descr):
creat = ElectionCreator()
creat.prepare(ex_elid, ex_type, ex_descr)
if election.Election().is_hes():
creat.init_hes()
elif election.Election().is_hts():
creat.init_hts()
elif election.Election().is_hlr():
creat.init_hlr()
else:
raise Exception('Serveri tüüp määramata')
creat.init_done()
print 'Lõpetasin töö edukalt'
def purge_otps():
runtime = int(time.time())
AppLog().set_app("purgeotps.py")
AppLog().log("Purging expired vote ID's as of %s: START" % \
time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(runtime)))
try:
reg = election.Election().get_root_reg()
timeout = election.Election().get_verification_time() * 60
for otp in reg.list_keys(htscommon.get_verification_key()):
otp_key = htscommon.get_verification_key(otp)
created = reg.read_integer_value(otp_key, "timestamp").value
if created + timeout < runtime:
AppLog().log("Purging expired vote ID %s" % otp)
purge_otp(otp_key)
except:
AppLog().log_exception()
finally:
AppLog().log("Purging expired vote ID's: DONE")
def purge_otp(otp_key):
elec = election.Election()
reg = elec.get_root_reg()
voter = reg.read_string_value(otp_key, "voter").value.rstrip()
voter_key = htscommon.get_user_key(voter)
elids = reg.read_string_value(otp_key, "elids").value.rstrip().split("\t")
for elid in elids:
sreg = elec.get_sub_reg(elid)
if sreg.check(voter_key + [htscommon.VOTE_VERIFICATION_ID_FILENAME]):
sreg.delete_value(voter_key, htscommon.VOTE_VERIFICATION_ID_FILENAME)
reg.ensure_no_key(otp_key)
def _execute_prepare_stop():
import datetime
if election.ElectionState().election_on():
election.Election().refuse_new_voters()
sched = scheduled(COMMAND_PREPARE_STOP)
minutes = stop_grace_period()
if not sched or not minutes:
return
_, time = sched
dt = datetime.datetime.strptime(time, TIME_FORMAT)
dt += datetime.timedelta(minutes=minutes)
schedule(COMMAND_STOP, dt.timetuple())
def do_cgi():
try:
elec = election.Election()
evlog.AppLog().set_app(APP)
# Create a list of pairs from the form parameters. Don't use a dictionary
# because that will overwrite recurring keys.
form = cgi.FieldStorage()
params = []
for key in form:
for value in form.getlist(key):
params.append((key, value))
# Only accept up to a single parameter
if len(params) > 1:
def keys(pairs):
"""Return a comma-separated list of the keys."""
return ", ".join([pair[0] for pair in pairs])
evlog.log_error("Too many query parameters: " + keys(params))
bad_parameters()
return
# Only accept the POST_VERIFY_VOTE parameter.
if len(params) and params[0][0] != evcommon.POST_VERIFY_VOTE:
evlog.log_error("Unknown query parameter \"%s\"" % params[0][0])
bad_parameters()
return
# Make sure the parameter is correctly formatted.
if not formatutil.is_vote_verification_id(params[0][1]):
# Don't write to disk; we don't know how large the value is
evlog.log_error("Malformed vote ID")
bad_parameters()
return
evlog.log("verif/auth REMOTE_ADDR: " + evlogdata.get_remote_ip())
evlog.log("verif/auth VOTE-ID: " + params[0][1])
params.append((evcommon.POST_SESS_ID, sessionid.voting()))
url = "http://" + elec.get_hts_ip() + "/" + elec.get_hts_verify_path()
conn = urllib.urlopen(url, urllib.urlencode(params))
protocol.http_response(conn.read())
except:
evlog.log_exception()
technical_error()
os.umask(007)
APP = "hes-verify-vote.cgi"
def bad_parameters():
protocol.http_response(evcommon.VERSION + "\n" + \
evcommon.VERIFY_ERROR + "\n" + \
evmessage.EvMessage().get_str("BAD_PARAMETERS", \
evstrings.BAD_PARAMETERS))
cgi.sys.exit(0)
if not evcommon.testrun():
elec = election.Election()
AppLog().set_app(APP)
# Create a list of pairs from the form parameters. Don't use a dictionary
# because that will overwrite recurring keys.
form = cgi.FieldStorage()
params = []
for key in form:
for value in form.getlist(key):
params.append((key, value))
# Only accept up to a single parameter
if len(params) > 1:
def keys(pairs):
"""Return a comma-separated list of the keys."""
def init_done(self): # pylint: disable=R0201
election.ElectionState().init()
election.Election().init_conf_done()
def prepare(self, ex_elid, ex_type, ex_descr):
election.create_registry()
election.Election().init_keys()
self.__quest = election.Election().new_question(\
ex_elid, ex_type, ex_descr)
if cgivalidator.validate_sessionid(form):
sessionid.setsid(form.getvalue(evcommon.POST_SESS_ID))
res, logline = cgivalidator.validate_form(form, req_params)
if res:
cgilog.do_log('vote/auth')
result = hesd.hts_vote(form.getvalue(evcommon.POST_EVOTE))
else:
cgilog.do_log_error('vote/auth/err')
evlog.log_error(logline)
else:
req_params = []
res, logline = cgivalidator.validate_form(form, req_params)
if res:
cgilog.do_log('cand/auth')
if election.Election().allow_new_voters():
result = hesd.get_candidate_list()
else:
evlog.log_error('nonewvoters')
a, b = protocol.plain_error_election_off_after()
result = protocol.msg_error(a, b)
else:
cgilog.do_log_error('cand/auth/err')
evlog.log_error(logline)
except:
evlog.log_exception()
result = protocol.msg_error_technical()
protocol.http_response(result)
cgi.sys.exit(0)
elid = sys.argv[1]
infile = sys.argv[2]
p_time = "00:00:00"
evlog.AppLog().set_app('HTS', elid)
tmp_f = None
try:
try:
s_time = time.time()
evlog.AppLog().log(
'Tühistus-/ennistusnimekirja laadimine: ALGUS')
bdocpython.initialize()
bconf = bdocconfig.BDocConfig()
bconf.load(election.Election().get_bdoc_conf())
result = regrights.kontrolli_volitusi(elid, infile, 'TYHIS', bconf)
if not result[0]:
errmsg = 'Tühistus-/ennistusnimekirja volituste ' \
'kontroll andis negatiivse tulemuse: '
errmsg += result[1]
raise Exception(errmsg)
_signercode = result[2]
tmp_f = bdocpythonutils.get_doc_content_file(infile)
all_, res_a, res_u = restore_revoke(elid, tmp_f, _signercode)
p_time = time.strftime("%H:%M:%S",
time.gmtime(long(time.time() - s_time)))
print 'Tühistamine/ennistamine'
def __init__(self):
self._election = election.Election()
self._gen_and_set_candidates()
self.gen_ballots(self.filename)
self._set_reported_results()
def __init__(self):
self._election = election.Election()
self._gen_and_set_candidates()
self._set_reported_results()
def __init__(self, bot):
self.__bot = bot
self.schedstop = threading.Event()
self.schedthread = threading.Thread(target=self.timer)
self.schedthread.start()
self.__bot.add_cog(election.Election(self.__bot))
