def get_response_time():
global PERIOD, offset, prev_utc
end = datetime.utcnow() - offset
start = end - timedelta(seconds=PERIOD)
if start <= prev_utc:
# We're polled more often than our check period, ignore until we're ready again
return None
r = requests.get(
"%s/api/2.0/summary.average/%s" % (PINGDOM_API, PINGDOM_CHECKID),
auth=(PINGDOM_USER, PINGDOM_PASSWORD),
headers={'App-Key': PINGDOM_API_KEY},
params={
'from': unix_time(start),
'to': unix_time(end),
'probes': probes
}
)
result = json.loads(r.text)
if not 'summary' in result or not 'responsetime' in result['summary'] or not 'avgresponse' in result['summary']['responsetime']:
# Some sort of error, ignore for now
return None
# Accept this measurement
prev_utc = end
# Set measure time to the middle of this measure period
measure_time = unix_time(end - timedelta(seconds=(PERIOD / 2)))
return {
'name': 'sherpa.pingdom.response_time',
'value': result['summary']['responsetime']['avgresponse'],
'measure_time': measure_time
}
def check_timeout(storage_id, user_id, timeout):
now = util.unix_time()
last = 0
with ratelimiter_lock:
if user_id in ratelimiter_storage[storage_id]:
last = ratelimiter_storage[storage_id][user_id]
return now - last < timeout
def is_the_same_connection(self, state_db, cl):
"""
Returns true if state representation of the user connection is the same as mentioned in the status file.
:param VpnUserState state_db: VPN user state - DB
:param OvpnClient cl: client info from VPN state file
:return:
"""
# IP check, should be the same remote socket
if cl.addr != (
'%s:%s' %
(state_db.client_remote_ip, state_db.client_remote_port)):
return False
# Bytes stats check. Status file has to be greater or equal
if state_db.bytes_sent > cl.bytes_sent or state_db.bytes_recv > cl.bytes_recv:
return False
# Check connection time, tolerance 5 minutes.
connected_db_utc = calendar.timegm(state_db.date_connected.timetuple())
connected_stat_utc = util.unix_time(cl.connected_since)
time_diff = abs(connected_db_utc - connected_stat_utc)
if time_diff > 60 * 5:
return False
return True
def getSubmissionsFromDaysAgo(targetSubreddit, daysAgo, limit=25, feed_type="hot"):
try:
now = datetime.datetime.utcnow()
now -= datetime.timedelta(hours=4,days=daysAgo)
#print now
now2 = now - datetime.timedelta(hours=now.hour,minutes=now.minute,seconds=now.second)
#print now2
now3 = now + datetime.timedelta(hours=(23 - now.hour),minutes=(59-now.minute),seconds=(59-now.second))
#print now3
lower = unix_time(now2)
upper = unix_time(now3)
#query = '(and author:"%s" (and timestamp:%d..%d))' % (usermode, lower, upper)
query = 'timestamp:%d..%d' % (lower, upper)
r = praw.Reddit(user_agent='redditd') # Note: Be sure to change the user-agent to something unique.
searchresults = list(r.search(query, subreddit=targetSubreddit, sort=feed_type, limit=limit, syntax='cloudsearch'))
return searchresults
except Exception as exception:
#print exception
return []
def inject_custom_jinja_vars():
return dict(
error_message=request.args.get('error', None),
format_unix_time=util.format_unix_time,
unix_time=util.unix_time,
round=round,
len=len,
int=int,
getattr=getattr,
now=util.unix_time(),
request=request,
)
def main():
# TBD use sys.argv[0] for num_iter or dataset
print("loading..")
dfs = unix_time(load)["return"]
print("name,real,user,sys")
print("------------------")
benchmark(analytics, init_pd, dfs, num_iter=3)
benchmark(search, init_pd, dfs, num_iter=3)
benchmark(search_concat, init_pd, dfs, num_iter=3)
benchmark(discovery, init_pd, dfs, num_iter=3)
def __call__(self, environ, start_response, path=None):
if util.unix_time() >= config.EVENT_END and util.get_real_ip(
environ) != config.ADMIN_IP:
start_response(
'200 Bepis',
[('Access-Control-Allow-Origin', '*'),
('Access-Control-Allow-Methods', 'POST, GET, OPTIONS'),
('Content-Type', 'application/json')])
return [
b'{"success": false, "message": "Fools2019 is over - the event servers will be shut down soon.<br><br>Stay tuned for the source code release!"}'
]
if torbanlist.is_banned(environ):
start_response(
'200 ZZAZZ Is Legion',
[('Access-Control-Allow-Origin', '*'),
('Access-Control-Allow-Methods', 'POST, GET, OPTIONS'),
('Content-Type', 'application/json')])
return [
b'{"success": false, "message": "To help minimize abuse, Fools2019 is not accessible from public proxies and Tor exit nodes. We\'re sorry for the inconvenience."}'
]
try:
method = environ['REQUEST_METHOD']
if path is None:
path = self.path_info(environ)
result = self.resolve(method, path)
if result.app is not None:
kwargs = result.match.groupdict()
if kwargs:
args = ()
else:
kwargs = {}
args = result.match.groups()
environ['wsgiorg.routing_args'] = (args, kwargs)
if isinstance(result.app, Router):
return result.app(environ,
start_response,
path=result.rest)
else:
return result.app(environ, start_response)
except Exception as e:
if config.DEBUG:
raise e
logger.log_exc(TAG)
start_response(
'200 Oopsie Woopsie',
[('Access-Control-Allow-Origin', '*'),
('Access-Control-Allow-Methods', 'POST, GET, OPTIONS'),
('Content-Type', 'application/json')])
return [
b'{"success": false, "message": "Oopsie Woopsie! The event server made a fucky wucky. A wittle fucko boingo. The code monkeys at our headquarters are working VEWY HAWD to fix this. Please come back later once they\'re done!"}'
]
def appTravel(environ, start_response):
data = util.get_json_post(environ)
user = storage.get_user_by_sessid(data.sessid)
if user is None:
start_response('200 OK', HEADERS_JSON + HEADERS_CORS)
return [util.err_json("You are not logged in.")]
logger.bigbrother("/travel", user, environ)
q = storage.sql(
"""
SELECT
users.id AS id,
leaderboard.achievements AS achievements,
progress.visited_kingdoms AS kingdoms,
progress.cur_kingdom AS cur_kingdom,
progress.save_uid AS save_uid,
progress.cur_visit_started AS cur_visit_started
FROM users
LEFT OUTER JOIN progress ON progress.user_id = users.id
LEFT OUTER JOIN leaderboard ON leaderboard.user_id = users.id
WHERE users.id = ?
""", (user.id, ))[0]
visit_delay = util.time_delta(q.cur_visit_started,
config.RATELIMIT_VISIT_KINGDOM)
if visit_delay and user.id != config.ADMIN_USER_ID:
start_response('200 OK', HEADERS_JSON + HEADERS_CORS)
return [
util.err_json(
"You need to wait %i more seconds before visiting a new kingdom."
% visit_delay)
]
if q.cur_kingdom != 'none' or q.save_uid:
start_response('200 OK', HEADERS_JSON + HEADERS_CORS)
return [util.err_json("You are already visiting a kingdom.")]
kingdoms = json.loads(q.kingdoms)
achievements = json.loads(q.achievements)
if not checks.is_kingdom_accessible(data.kingdom, kingdoms, achievements):
start_response('200 OK', HEADERS_JSON + HEADERS_CORS)
return [util.err_json("You can't access this kingdom yet.")]
storage.sql(
"""
UPDATE progress SET
cur_kingdom = ?,
cur_visit_started = ?,
save_uid = ''
WHERE user_id = ?
""", (data.kingdom, util.unix_time(), user.id))
compiler.queue_compilation(user.id, data.kingdom)
start_response('200 OK', HEADERS_JSON + HEADERS_CORS)
return [util.json_bytes({"success": True})]
def create(self):
"""Saves a new "apps" table entry in the database for the app
represented by this App-object.
"""
if self.enabled is None:
self.enabled = False
client.get_autoscaler() \
.import_app(self.app_id,
app_id=self.app_id,
app_name=self.app_name,
space_id=self.space_id,
time_created=util.unix_time(),
enabled=self.enabled)\
.assert_no_error()
return self
def register_app_with_space(self):
data = json.dumps({
'token': self.config.token,
'app_id': self.config.app_id
})
return self.make_request('spaces/register',
method='POST',
headers={
'x-registration-token':
util.encode_signature(
self.config.secret,
data,
300,
time=util.unix_time(),
join='.')
})
def update(user_id, session, save_data):
q = storage.sql(
"""
SELECT achievements, score, highest_rank
FROM leaderboard
WHERE user_id = ?
""", (user_id, ))[0]
old_achievements = json.loads(q.achievements)
new_achievements = copy.deepcopy(old_achievements)
for k, v in ACHIEVEMENTS.items():
if v(save_data, session):
new_achievements[k] = True
rewards = calc_pending_rewards(old_achievements, new_achievements)
monsters = generate_monsters(save_data)
storage.sql(
"""
UPDATE progress
SET tokens_got = tokens_got + ?
WHERE user_id = ?
""", (rewards[1], user_id))
if rewards[0]:
storage.sql(
"""
UPDATE leaderboard
SET last_update = ?
WHERE user_id = ?
""", (util.unix_time(), user_id))
storage.sql(
"""
UPDATE leaderboard SET
score = score + ?,
achievements = ?,
monsters = ?
WHERE user_id = ?
""", (rewards[0], json.dumps(new_achievements), json.dumps(monsters),
user_id))
storage.sql(
"""
UPDATE leaderboard
SET highest_rank = MIN(highest_rank, (
SELECT COUNT(1)
FROM leaderboard
WHERE score >= (SELECT score FROM leaderboard WHERE user_id = ?)
))
WHERE user_id = ?
""", (user_id, user_id))
def appRegister(environ, start_response):
data = util.get_json_post(environ)
q = storage.sql(
"""
SELECT id FROM users WHERE username = ?
""", (data.username, ))
if q:
start_response('200 OK', HEADERS_JSON + HEADERS_CORS)
return [
util.err_json(
"That username already exists. Please choose a different one.")
]
if not (data.username.strip() and data.password.strip()):
start_response('200 OK', HEADERS_JSON + HEADERS_CORS)
return [util.err_json("Username and password may not be empty.")]
if len(data.username) > 20:
start_response('200 OK', HEADERS_JSON + HEADERS_CORS)
return [util.err_json("Username is too long.")]
if len(data.message) > 150:
start_response('200 OK', HEADERS_JSON + HEADERS_CORS)
return [util.err_json("Message is too long.")]
if data.password != data.password2:
start_response('200 OK', HEADERS_JSON + HEADERS_CORS)
return [util.err_json("Your passwords do not match.")]
if data.starter not in ("CYNDAQUIL", "TOTODILE", "CHIKORITA"):
start_response('200 OK', HEADERS_JSON + HEADERS_CORS)
return [util.err_json("Invalid starter choice. You dirty hacker.")]
if not util.recaptcha_verify(data.recaptcha):
start_response('200 OK', HEADERS_JSON + HEADERS_CORS)
return [
util.err_json(
"Bot verification failed. Please complete the reCAPTCHA challenge. Refresh the page if you encounter any problems."
)
]
sessid = util.new_session_key()
storage.sql(
"""
INSERT INTO users
(username, password, sessid, message, fun, rtc, registered_ip)
VALUES
(?, ?, ?, ?, ?, 1, ?)
""", [
data.username,
util.password_hash(data.password), sessid, data.message,
util.new_fun_value(),
util.get_real_ip(environ)
])
user_id = storage.get_user_id_by_username(data.username)
if user_id is None:
start_response('200 OK', HEADERS_JSON + HEADERS_CORS)
return [
util.err_json(
"An unknown error occured (17). Try again in a few minutes.")
]
save_data = util.create_starter_save()
storage.sql(
"""
INSERT INTO progress
(user_id, tokens_got, tokens_used, cur_kingdom, cur_visit_started, save_blob, visited_kingdoms, starter, laylah_blessing, save_uid)
VALUES
(?, 0, 0, 'none', 0, ?, '[]', ?, 0, '')
""", (user_id, json.dumps(save_data), data.starter))
monsters = '[{"nick":"%s","species":"%s","level":20}]' % (data.starter,
data.starter)
storage.sql(
"""
INSERT INTO leaderboard
(user_id, score, achievements, highest_rank, monsters, last_update)
VALUES
(?, 0, '{}', (SELECT COUNT(1)+1 FROM leaderboard WHERE score >= 0), ?, ?)
""", (user_id, monsters, util.unix_time()))
start_response('200 OK', HEADERS_JSON + HEADERS_CORS)
return [util.json_bytes({"success": True, "sessid": sessid})]
def save_current_time(storage_id, user_id):
with ratelimiter_lock:
ratelimiter_storage[storage_id][user_id] = util.unix_time()
