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"