def invite_if_needed():
event = db.get_event_in_need_of_invitations(DAYS_IN_ADVANCE_TO_INVITE,
PEOPLE_PER_EVENT)
if event is None:
print("No users were invited")
return
event_id, timestamp, place, number_of_already_invited = event
number_of_employees = sync_db_with_slack_and_return_count()
number_to_invite = PEOPLE_PER_EVENT - number_of_already_invited
users_to_invite = db.get_users_to_invite(number_to_invite, event_id,
number_of_employees,
PEOPLE_PER_EVENT)
if len(users_to_invite) == 0:
print("Event in need of users, but noone to invite"
) # TODO: needs to be handled
return
db.save_invitations(users_to_invite, event_id)
for user_id in users_to_invite:
slack.send_slack_message(
user_id,
"Du er invitert til 🍕 på %s, %s. Pls svar innen %d timer 🙏. Kan du?"
% (place, timestamp.strftime("%A %d. %B kl %H:%M"),
REPLY_DEADLINE_IN_HOURS), BUTTONS_ATTACHMENT)
print("%s was invited to event on %s" % (user_id, timestamp))
def auto_reply():
users_that_did_not_reply = db.auto_reply_after_deadline(
REPLY_DEADLINE_IN_HOURS)
if users_that_did_not_reply is None:
return
for user_id in users_that_did_not_reply:
slack.send_slack_message(
user_id,
"Neivel, da antar jeg du ikke kan/gidder. Håper du blir med neste gang! 🤞"
)
print("%s didn't answer. Setting RSVP to not attending.")
def send_reminders():
inviations = db.get_unanswered_invitations()
for invitation in inviations:
slack_id, invited_at, reminded_at = invitation
remind_timestamp = datetime.now(
pytz.utc) + timedelta(hours=-HOURS_BETWEEN_REMINDERS)
if (reminded_at < remind_timestamp):
slack.send_slack_message(
slack_id,
"Hei du! Jeg hørte ikke noe mer? Er du gira? (ja/nei)")
db.update_reminded_at(slack_id)
print("%s was reminded about an event." % slack_id)
def wrapper(environment, output_path):
dump_command = template.format(
host=environment.get('DATABASE_HOST'),
user=environment.get('DATABASE_USER'),
password=environment.get('DATABASE_PASSWORD'),
database=environment.get('DATABASE_NAME'),
port=environment.get('DATABASE_PORT'),
dump_path=output_path,
)
wait_exit_status = os.system(dump_command)
exit_status = os.waitstatus_to_exitcode(wait_exit_status)
if wait_exit_status != 0 or exit_status != 0:
logger.error("RETURN CODE OF DUMP PROCESS != 0. CHECK OUTPUT ABOVE FOR ERRORS!")
send_slack_message(environment, "Failed to create DB dump. Please check the error in the container logs.", 'FAIL')
raise Exception('Failed to create dump of database')
def finalize_event_if_complete():
event = db.get_event_ready_to_finalize(PEOPLE_PER_EVENT)
if event is None:
print("No events ready to finalize")
else:
event_id, timestamp, place = event
sync_db_with_slack_and_return_count()
slack_ids = [
'<@%s>' % user for user in db.get_attending_users(event_id)
]
db.mark_event_as_finalized(event_id)
ids_string = ", ".join(slack_ids)
slack.send_slack_message(
'#pizza',
"Halloi! %s! Dere skal spise 🍕 på %s, %s. %s booker bord, og %s legger ut for maten. Blank betaler!"
% (ids_string, place, timestamp.strftime("%A %d. %B kl %H:%M"),
slack_ids[0], slack_ids[1]))
def dump_database(environment):
logger.info(f'{datetime.now()}: Creating backup')
filename = f'{environment.get("DATABASE_TYPE")}_{environment.get("DATABASE_NAME")}_{datetime.now().strftime("%d_%m_%Y")}.sql.gz'
dump_path = os.path.join('/tmp', filename)
dump_database_methods = {
'mysql': dump_general('/bin/bash -c \'set -o pipefail; mysqldump -h "{host}" -u "{user}" -p"{password}" --databases "{database}" -P {port} --protocol tcp | gzip -9 > {dump_path}\''),
'postgresql': dump_general('PGPASSWORD="******" pg_dump -h "{host}" -U "{user}" -d "{database}" -p {port} -Fp -Z9 > {dump_path}'),
'clickhouse': dump_clickhouse,
}
database_type = environment.get('DATABASE_TYPE').lower()
dump_database_method = dump_database_methods.get(database_type)
if dump_database_method:
dump_database_method(environment, dump_path)
file_size = 0
try:
file_size = os.path.getsize(dump_path)
except Exception as e:
logger.error("Failed to get size of file.")
logger.exception(e)
logger.info(f'{datetime.now()}: Backup created. Uploading to glacier')
try:
glacier = boto3.client('glacier')
glacier.create_vault(vaultName=environment.get('GLACIER_VAULT_NAME'))
with open(dump_path, 'rb') as f:
logger.info(glacier.upload_archive(
vaultName=environment.get('GLACIER_VAULT_NAME'),
archiveDescription=filename,
body=f,
))
logger.info('Glacier upload done.')
send_slack_message(environment, f"Successfully created and uploaded DB dump ({sizeof_fmt(file_size)}).")
except Exception as e:
logger.exception(e)
send_slack_message(environment,
f"Failed to upload DB dump ({sizeof_fmt(file_size)}) to AWS Glacier. Please check the error in the container logs.",
'FAIL')
else:
logger.error(f'Database of type {database_type} is not supported. Supported types are: {dump_database_methods.keys()}')
def main():
repos_list = get_repos_list(REPOS_FILENAME)
urls = map(create_url, repos_list)
atom_feeds = map(get_atom_feed, urls)
parsed_atom_feeds = map(lambda x: atoma.parse_atom_bytes(x), atom_feeds)
releases_last_24h = list(retrieve_releases_in_last_24h(parsed_atom_feeds))
version_list = []
url_list = []
for i in range(len(releases_last_24h)):
versions_list = list(map(lambda x: x.title.value,
releases_last_24h[i]))
version_urls = list(map(lambda x: x.links, releases_last_24h[i]))
version_list.extend(versions_list)
url_list.extend(version_urls)
url_decoded_list = []
for j in range(len(url_list)):
ver_urls = list(map(lambda x: x.href, url_list[j]))
url_decoded_list.extend(ver_urls)
pd.set_option('display.max_colwidth', -1)
df = pd.DataFrame(list(zip(version_list, url_decoded_list)),
columns=['version', 'url'])
df['repo'] = df['url'].str.split('/').str[4]
if len(version_list) < 1:
print("No new versions released")
else:
print('New versions released: ' + '\n' +
tabulate(df, headers='keys', tablefmt="psql", showindex=False))
for i in range(len(df)):
data = {
'version': [df.loc[i, 'version']],
'url': [df.loc[i, 'url']],
'repo': [df.loc[i, 'repo']]
}
df2 = pd.DataFrame(data, columns=['version', 'url', 'repo'])
data = np.squeeze(np.asarray(df2))
slack.send_slack_message(data)
import json
import slack
import random
candidates = json.loads(open('../config/candidates-default.json').read())
number_of_candidates = len(candidates)
chosen_candidate = random.randint(0, number_of_candidates - 1)
slack.send_slack_message(
f"{candidates[chosen_candidate]['name']} ha sido elegido!")
def send_slack_message(channel_id, text, attachments=None, thread_ts=None):
return slack.send_slack_message(channel_id, text, attachments, thread_ts)
def on_get():
send_slack_message(environment, 'Backup triggered from server', 'OTHER')
dump_database(environment)
return f"{environment['PROJECT_NAME']} Backup Done"
