def list_sddcs(event, db): message_handler(msg_const.SDDCS_TXT, event) event.update({ # "sddcs": list_sddcs_( "sddcs": sddc_list( # event.get("token"), event.get("access_token"), event.get("org_id")) }) message_handler(msg_const.SDDCS_MSG, event)
def aws_region(event): #update AWS Region and send sddc name message message_handler(msg_const.SDDC_NAME, event) write_event_db( event.get("db_url"), event.get("user_id"), { "region": event.get("response"), "status": cmd_const.SDDC_NAME } )
def sddc_name(event, db): if event.get("max_hosts") == 1: message_handler(msg_const.LINK_AWS, event) db.write_event_db(event.get("user_id"), { "status": cmd_const.AWS_ACCOUNT, "sddc_name": event.get("text") }) else: message_handler(msg_const.SINGLE_MULTI, event) db.write_event_db(event.get("user_id"), { "status": cmd_const.SINGLE_MULTI, "sddc_name": event.get("text") })
def mgmt_cidr(event, db): text = event.get("text") if is_network(text): if is_valid_network(text): event.update({"vpc_cidr": text}) message_handler(msg_const.SDDC_CONFIRM, event) db.write_event_db(event.get("user_id"), { "status": cmd_const.CHECK_CONFIG, "vpc_cidr": text }) else: message_handler(msg_const.WRONG_NETWORK, event)
def lambda_handler(event, context): # logging.info(event) event.update({"lambda_name": "check_task"}) vmc_client = get_vmc_client(event.get("token")) try: task_id = delete_sddc(event.get("org_id"), event.get("sddc_id"), vmc_client) event.update({"task_id": task_id}) except Exception as e: event.update({ "message": "Sorry, failed to delete sddc. {}".format(e.message), "status": "task_failed" }) message_handler(constant.SDDC_RESULT, event) call_lambda("check_task", event) return message_handler(constant.TASK_MSG, event) message_handler(constant.CRUD_SDDC, event) message_handler(constant.TASK_WH, event) event.update({"status": "task_started"}) call_lambda("check_task", event)
def lambda_handler(event, context): # logging.info(event) event.update({"lambda_name": "check_task"}) vmc_client = get_vmc_client(event.get("token")) try: task = create_sddc(event.get("org_id"), event.get("region"), event.get("sddc_name"), event.get("sddc_type"), event.get("vpc_cidr"), event.get("provider"), event.get("customer_subnet_id"), event.get("connected_account_id"), event.get("num_hosts"), strtobool(event.get("link_aws")) == 1, vmc_client) event.update({"task_id": task}) except Exception as e: event.update({ "message": "Sorry, failed to create sddc. {}".format(e.message), "status": "task_failed" }) message_handler(constant.SDDC_RESULT, event) call_lambda("check_task", event) return logging.info(event) #need this log to ckech config later. message_handler(constant.TASK_MSG, event) message_handler(constant.CRUD_SDDC, event) message_handler(constant.TASK_WH, event) event.update({"status": "task_started"}) call_lambda("check_task", event)
def create_sddc(event): #first create sddc command from text message message_handler(msg_const.SDDC_WIZARD, event) message_handler(msg_const.CHECK_RESOURCE, event) data = prepare_data_for_lambda(event, "check_max_hosts") max_hosts = call_lambda_sync( "slack_vmc", data ) # max_hosts = 10 #for test max_hosts = 5 #for test event.update({"max_hosts": max_hosts}) if max_hosts < 1: message_handler(msg_const.NOT_ENOUGH, event) delete_event_db(event.get("db_url"), event.get("user_id")) else: message_handler(msg_const.MAX_HOSTS, event) write_event_db( event.get("db_url"), event.get("user_id"), { "command": cmd_const.COMMAND_SDDC[event.get("text")], "status": cmd_const.CHECK_MAX_HOSTS, "max_hosts": max_hosts, "provider": "AWS" } )
def selected_sddc_to_delete(event): sddc_name = event.get("response").split("+")[0] sddc_id = event.get("response").split("+")[1] event.update( {"sddc_name": sddc_name} ) write_event_db( event.get("db_url"), event.get("user_id"), { "sddc_name": sddc_name, "sddc_id": sddc_id # "sddc_id": "ffcdc226-c3a6-4c8c-bc9b-3b14de2e089c" } ) message_handler(msg_const.CONFIRM_DELETE, event)
def storage_capacity(event): #storage capacity is 15003 or 20004,25005,30006,35007 per host event.update( { "num_hosts_list": list_num_hosts( event.get("max_hosts"), event.get("deployment_type") ) } ) message_handler(msg_const.NUM_HOSTS, event) write_event_db( event.get("db_url"), event.get("user_id"), { "status": cmd_const.NUM_HOSTS, "storage_capacity": int(event.get("response")) #need to multiply by num_hosts later } )
def link_aws(event): #in case of Single host sddc, and update link aws and send AWS account menu or enter mgmt cider message if "True" in event.get("response"): #in case of linking customer AWS VPC to this SDDC list_aws_account(event) status = cmd_const.AWS_ACCOUNT else: #in case of not linking customer AWS VPC message_handler(msg_const.CIDR, event) status = cmd_const.MGMT_CIDR write_event_db( event.get("db_url"), event.get("user_id"), { "status": status, "num_hosts": 1, "sddc_type": "1NODE", "link_aws": event.get("response") } )
def list_aws_account(event): data = prepare_data_for_lambda(event, "list_aws_account") event.update( { "aws_account_list": call_lambda_sync( "slack_vmc", data ) # "aws_account_list": [ # { # "text": event.get("aws_internal_account"), #for internal use # "value": "{}+{}".format( # event.get("aws_internal_account"), # event.get("aws_internal_id") # ) #for internal use # } # ] } ) message_handler(msg_const.AWS_ACCOUNT, event)
def register_token(event): # cred = read_cred_db(event.get("db_url"), event.get("user_id")) # user_name = validate_token(event.get("text"), cred.get("org_id")) data = { "vmc_command": "validate_token", "token": event.get("text"), "org_id": event.get("org_id") } try: user_name = call_lambda_sync( "slack_vmc", data ) message_handler(msg_const.SUCCESS_TOKEN, event) write_cred_db( event.get("db_url"), event.get("user_id"), { "status": cmd_const.REGISTERED, "token": event.get("text"), "user_name": user_name } ) except Exception as e: message_handler(msg_const.FAILED_TOKEN, event) event.update({"text": str(e)}) message_handler(msg_const.WRONG_TOKEN, event) delete_cred_db(event.get("db_url"), event.get("user_id"))
def single_multi(event): #update single or multi hosts and send link aws nemu or max hosts menu if "single" in event.get("response"): message_handler(msg_const.LINK_AWS, event) write_event_db( event.get("db_url"), event.get("user_id"), { "status": cmd_const.LINK_AWS, "host_instance_type": "I3_METAL" } ) elif "multi" in event.get("response"): message_handler(msg_const.INSTANCE_TYPE, event) write_event_db( event.get("db_url"), event.get("user_id"), { "status": cmd_const.INSTANCE_TYPE, "link_aws": "True" } ) else: message_handler(msg_const.INSTANCE_TYPE, event) write_event_db( event.get("db_url"), event.get("user_id"), { "status": cmd_const.INSTANCE_TYPE, "deployment_type": "MultiAZ", "link_aws": "True" } )
def interactive_handler(event): user_id = event.get("user_id") db = dbutils.DocmentDb(event.get("db_url")) event_db = db.read_event_db(user_id, 5) if event_db is None: message_handler(constant.MAY_I, event) return cred_db = db.read_cred_db(event.get("user_id")) event.update( { "token": cred_db.get("token"), "org_id": cred_db.get("org_id"), "user_name": cred_db.get("user_name") } ) event.update(event_db) callback_id = event.get("callback_id") command_handler(callback_id, event, db)
def lambda_handler(event, context): # logging.info(event) user_id = event.get("user_id") db_url = event.get("db_url") event_db = read_event_db(db_url, user_id, 5) if event_db is None: message_handler(msg_const.MAY_I, event) return cred_db = read_cred_db(db_url, user_id) event.update({ "token": cred_db.get("token"), "org_id": cred_db.get("org_id"), "user_name": cred_db.get("user_name"), "access_token": cred_db.get("access_token"), "expire_time": cred_db.get("expire_time") }) event.update(event_db) command_handler(event.get("callback_id"), event)
def delete_sddc(event): data = prepare_data_for_lambda(event, "list_sddcs_name_id") try: event.update( { "option_list": call_lambda_sync( "slack_vmc", data ) } ) except Exception as e: event.update({"text": str(e)}) message_handler(msg_const.ERROR, event) else: message_handler(msg_const.DELETE_SDDC, event) write_event_db( event.get("db_url"), event.get("user_id"), { "command": cmd_const.COMMAND_SDDC[event.get("text")], "status": cmd_const.DELETE_SDDC } )
def sddc_name(event): #update sddc name and send link aws menu or single mult menu # max_hosts = event.get("max_hosts") message_handler(msg_const.MEDIUM_LARGE, event) status = cmd_const.MEDIUM_LARGE # if max_hosts == 1: # message_handler(msg_const.LINK_AWS, event) # status = cmd_const.AWS_ACCOUNT # elif max_hosts < 6: # message_handler(msg_const.SINGLE_MULTI, event) # status = cmd_const.SINGLE_MULTI # else: # message_handler(msg_const.STRETCH, event) # status = cmd_const.SINGLE_MULTI write_event_db( event.get("db_url"), event.get("user_id"), { "status": status, "sddc_name": event.get("text") } )
def create_sddc(event, db): message_handler(msg_const.SDDC_WIZARD, event) message_handler(msg_const.CHECK_RESOURCE, event) max_hosts = get_max_num_hosts(event.get("token"), event.get("org_id")) event.update({"max_hosts": max_hosts}) if max_hosts < 1: message_handler(msg_const.NOT_ENOUGH, event) db.delete_event_db(event.get("user_id")) else: message_handler(msg_const.MAX_HOSTS, event) db.write_event_db( event.get("user_id"), { "command": cmd_const.COMMAND_SDDC[event.get("text")], "status": cmd_const.CHECK_MAX_HOSTS, "max_hosts": max_hosts, "provider": "AWS" })
def register_token(event, db): cred = db.read_cred_db(event.get("user_id")) user_name = validate_token(event.get("text"), cred.get("org_id")) if user_name is not None: message_handler(msg_const.SUCCESS_TOKEN, event) db.write_cred_db( event.get("user_id"), { "status": cmd_const.REGISTERED, "token": event.get("text"), "user_name": user_name }) else: message_handler(msg_const.FAILED_TOKEN, event) message_handler(msg_const.WRONG_TOKEN, event) db.delete_cred_db(event.get("user_id"))
def list_sddcs(event): data = prepare_data_for_lambda(event, "list_sddcs") try: event.update( { "sddcs": call_lambda_sync( "slack_vmc", data ) } ) message_handler(msg_const.SDDCS_TXT, event) message_handler(msg_const.SDDCS_MSG, event) except Exception as e: event.update({"text": str(e)}) message_handler(msg_const.ERROR, event)
def delete_confirmation(event, db): response = event.get("response") if "yes" in response: message_handler(msg_const.START_DELETE, event) # event.update(result) event.update({"user_name": event.get("user_name")}) if check_sddc_user(event.get("token"), event.get("org_id"), event.get("sddc_id"), event.get("user_name")): call_lambda("delete_sddc", event) else: message_handler(msg_const.CANT_DELETE, event) db.delete_event_db(event.get("user_id")) else: message_handler(msg_const.CANCEL_DELETE, event) db.delete_event_db(event.get("user_id"))
def medium_large(event): max_hosts = event.get("max_hosts") data = { "size": event.get("response") } if max_hosts == 1: message_handler(msg_const.LINK_AWS, event) # status = cmd_const.AWS_ACCOUNT data.update( { "status": cmd_const.AWS_ACCOUNT, "host_instance_type": "I3_METAL" } ) elif max_hosts < 6: message_handler(msg_const.SINGLE_MULTI, event) # status = cmd_const.SINGLE_MULTI data.update( { "status": cmd_const.SINGLE_MULTI } ) else: message_handler(msg_const.STRETCH, event) # status = cmd_const.SINGLE_MULTI data.update( { "status": cmd_const.SINGLE_MULTI } ) write_event_db( event.get("db_url"), event.get("user_id"), data )
def delete_org(event): message_handler(msg_const.DELETE_ORG, event) delete_cred_db(event.get("db_url"), event.get("user_id"))
def delete_confirmation(event): response = event.get("response") if "yes" in response: message_handler(msg_const.START_DELETE, event) if check_sddc_user(event): event.update( { "status": "task_started", "lambda_name": "check_task" } ) try: task_id = call_lambda_async("delete_sddc", event) except Exception as e: event.update( { "message": "Sorry, failed to delete sddc. {}".format(str(e)), # "status": "task_failed" } ) message_handler(msg_const.SDDC_RESULT, event) delete_event_db(event.get("db_url"), event.get("user_id")) else: event.update( { "status": "task_started" } ) call_lambda_async("check_task", event) message_handler(msg_const.TASK_MSG, event) message_handler(msg_const.CRUD_SDDC, event) message_handler(msg_const.TASK_WH, event) else: message_handler(msg_const.CANT_DELETE, event) delete_event_db( event.get("db_url"), event.get("user_id") ) else: message_handler(msg_const.CANCEL_DELETE, event) delete_event_db( event.get("db_url"), event.get("user_id") )
def event_handler(event): text = event.get("text").lower() db = dbutils.DocmentDb(event.get("db_url")) current = db.read_event_db(event.get("user_id"), 120) if current is not None and current.get("status") == "creating": message_handler(constant.ASK_WAIT_TASK, event) return result = db.read_event_db(event.get("user_id"), 5) __cred_data = db.read_cred_db(event.get("user_id")) if result is None: if "create sddc on zerocloud" in text: #for internal use only if __cred_data is None: message_handler(constant.ASK_REGISTER_TOKEN, event) elif "registered" in __cred_data.get("status"): event_cred_update(event, __cred_data) message_handler(constant.SDDC_WIZARD, event) message_handler(constant.CHECK_RESOURCE, event) event.update( { "max_hosts": get_max_num_hosts( event.get("token"), event.get("org_id") ) } ) if event.get("max_hosts") < 1: message_handler(constant.NOT_ENOUGH, event) db.delete_event_db(event.get("user_id")) return message_handler(constant.MAX_HOSTS, event) db.write_event_db( event.get("user_id"), { "command": "create", "status": "create_sddc", "max_hosts": event.get("max_hosts"), "provider": "ZEROCLOUD" } ) return elif "create sddc" in text: if __cred_data is None: message_handler(constant.ASK_REGISTER_TOKEN, event) elif "registered" in __cred_data.get("status"): event_cred_update(event, __cred_data) message_handler(constant.SDDC_WIZARD, event) message_handler(constant.CHECK_RESOURCE, event) event.update( { "max_hosts": get_max_num_hosts( event.get("token"), event.get("org_id") ) } ) if event.get("max_hosts") < 1: message_handler(constant.NOT_ENOUGH, event) db.delete_event_db(event.get("user_id")) return message_handler(constant.MAX_HOSTS, event) db.write_event_db( event.get("user_id"), { "command": "create", "status": "create_sddc", "max_hosts": event.get("max_hosts"), "provider": "AWS" } ) return elif "delete sddc" in text: if __cred_data is None: message_handler(constant.ASK_REGISTER_TOKEN, event) elif "registered" in __cred_data.get("status"): event_cred_update(event, __cred_data) event.update( { "option_list": list_sddcs( event.get("token"), event.get("org_id") ) } ) message_handler(constant.DELETE_SDDC, event) db.write_event_db( event.get("user_id"), { "command": "delete", "status": "delete_sddc" } ) elif "restore sddc" in text: #for internal use if __cred_data is None: message_handler(constant.ASK_REGISTER_TOKEN, event) elif "registered" in __cred_data.get("status"): message_handler(constant.RESTORE_WIZARD, event) config = db.get_backedup_sddc_config() event.update(config) event_cred_update(event, __cred_data) config.update( { "command": "restore", "status": "restore_sddc" } ) db.write_event_db(event.get("user_id"), config) message_handler(constant.RESTORE, event) elif "list sddcs" in text: if __cred_data is None: message_handler(constant.ASK_REGISTER_TOKEN, event) elif "registered" in __cred_data.get("status"): event_cred_update(event, __cred_data) vmc_client = get_vmc_client(event.get("token")) sddcs = vmc_client.orgs.Sddcs.list(event.get("org_id")) message_handler(constant.SDDCS_TXT, event) for sddc in sddcs: event.update( { "sddc_name": sddc.name, "user_name": sddc.user_name, "created": sddc.created.isoformat(), "num_hosts": len(sddc.resource_config.esx_hosts) } ) message_handler(constant.SDDCS_MSG, event) return elif "register org" in text: message_handler(constant.REGISTER_ORG, event) db.write_cred_db( event.get("user_id"), { "status": "registering" } ) db.write_event_db( event.get("user_id"), { "command": "register org", "status": "registering org" } ) return elif "delete org" in text: message_handler(constant.DELETE_ORG, event) db.delete_cred_db(event["user_id"]) return elif "help" in text: message_handler(constant.HELP, event) return elif "cancel" in text: if __cred_data is not None and "registering" in __cred_data.get("status"): message_handler(constant.CANCEL_TOKEN, event) db.delete_cred_db(event.get("user_id")) else: message_handler(constant.MAY_I, event) return else: message_handler(constant.MAY_I, event) return elif "create" in result.get("command"): if "create sddc" in text: return elif "cancel" in text: message_handler(constant.CANCEL_SDDC, event) db.delete_event_db(event.get("user_id")) return elif text.find(" ") != -1: return elif is_network(text): if result.get("status") == "link_aws" or "subnet": if is_valid_network(text): event.update( {"vpc_cidr": event.get("text")} ) event.update(result) message_handler(constant.SDDC_CONFIRM, event) db.write_event_db( event.get("user_id"), { "status": "vpc_cidr", "vpc_cidr": event.get("text") } ) else: message_handler(constant.WRONG_NETWORK, event) return else: if result.get("status") == "region": if result.get("max_hosts") == 1: message_handler(constant.LINK_AWS, event) else: message_handler(constant.SINGLE_MULTI, event) db.write_event_db( event.get("user_id"), { "status": "sddc_name", "sddc_name": event.get("text") } ) elif result.get("status") in constant.INT_STATUS: message_handler(constant.ASK_SELECT_BUTTON, event) return elif "delete" in result.get("command"): if "cancel" in text: message_handler(constant.CANCEL_DELETE, event) db.delete_event_db(event.get("user_id")) elif "restore" in result.get("command"): if "cancel" in text: message_handler(constant.CANCEL_RESTORE, event) db.delete_event_db(event.get("user_id")) elif "register org" in result.get("command"): if "cancel" in text: message_handler(constant.CANCEL_ORG, event) db.delete_event_db(event.get("user_id")) db.delete_cred_db(event.get("user_id")) elif "registering org" in result.get("status"): db.write_cred_db( event.get("user_id"), { "org_id": event.get("text") } ) db.write_event_db( event.get("user_id"), { "status": "registering token" } ) message_handler(constant.REGISTER_TOKEN, event) elif "registering token" in result.get("status"): user_name = validate_token(event.get("text"), __cred_data.get("org_id")) if user_name is not None: message_handler(constant.SUCCESS_TOKEN, event) db.write_cred_db( event.get("user_id"), { "status": "registered", "token": event.get("text"), "user_name": user_name } ) db.delete_event_db(event.get("user_id")) else: message_handler(constant.FAILED_TOKEN, event) message_handler(constant.WRONG_TOKEN, event) db.delete_event_db(event.get("user_id")) db.delete_cred_db(event.get("user_id"))
def interactive_handler(event): user_id = event.get("user_id") db = dbutils.DocmentDb(event.get("db_url")) result = db.read_event_db(user_id, 5) if result is None: message_handler(constant.MAY_I, event) return __cred_data = db.read_cred_db(event.get("user_id")) event.update({ "token": __cred_data.get("token"), "org_id": __cred_data.get("org_id") }) if "delete_sddc" in event.get("callback_id"): if "delete_sddc" in result.get("status"): sddc_name = event.get("response").split("+")[0] sddc_id = event.get("response").split("+")[1] event.update({"sddc_name": sddc_name}) db.write_event_db(user_id, { "sddc_name": sddc_name, "sddc_id": sddc_id }) message_handler(constant.CONFIRM_DELETE, event) return elif "delete_confirmation" in event.get("callback_id"): if "yes" in event.get("response"): message_handler(constant.START_DELETE, event) event.update(result) event.update({"user_name": __cred_data.get("user_name")}) if check_sddc_user(event.get("token"), event.get("org_id"), event.get("sddc_id"), event.get("user_name")): call_lambda("delete_sddc", event) else: message_handler(constant.CANT_DELETE, event) db.delete_event_db(user_id) else: message_handler(constant.CANCEL_DELETE, event) db.delete_event_db(user_id) return elif "create_sddc" in event.get("callback_id"): if "yes" in event.get("response"): event.update( # { # "region_list": list_region( # event.get("token"), # event.get("org_id") # ) # } { "region_list": [{ "text": "AP_NORTHEAST_1", #for internal use "value": "AP_NORTHEAST_1" #for internal use }] }) message_handler(constant.REGION, event) db.write_event_db(event.get("user_id"), {"status": "resource_check"}) else: message_handler(constant.CANCEL_SDDC, event) db.delete_event_db(user_id) return elif "link_aws_sddc" in event.get("callback_id"): if "True" in event.get("response"): event.update({ # "aws_account_list": list_aws_account( # event.get("token"), # event.get("org_id") # ) "aws_account_list": [{ "text": event.get("aws_internal_account"), #for internal use "value": "{}+{}".format( event.get("aws_internal_account"), event.get("aws_internal_id")) #for internal use }] }) message_handler(constant.AWS_ACCOUNT, event) else: message_handler(constant.CIDR, event) db.write_event_db( user_id, { "status": "link_aws", "num_hosts": 1, "sddc_type": "1NODE", "link_aws": event.get("response") }) return elif "region" in event.get("callback_id"): message_handler(constant.SDDC_NAME, event) db.write_event_db(user_id, { "status": "region", "region": event.get("response") }) return elif "single_multi" in event.get("callback_id"): if "single" in event.get("response"): message_handler(constant.LINK_AWS, event) db.write_event_db(user_id, {"status": "single_multi"}) else: event.update( {"num_hosts_list": list_num_hosts(result.get("max_hosts"))}) message_handler(constant.NUM_HOSTS, event) db.write_event_db(user_id, { "status": "single_multi", "link_aws": "True" }) return elif "num_hosts" in event.get("callback_id"): event.update({ # "aws_account_list": list_aws_account( # event.get("token"), # event.get("org_id") # ) "aws_account_list": [{ "text": event.get("aws_internal_account"), #for internal use "value": "{}+{}".format(event.get("aws_internal_account"), event.get("aws_internal_id")) #for internal use }] }) message_handler(constant.AWS_ACCOUNT, event) db.write_event_db( user_id, { "status": "num_hosts", "num_hosts": int(event.get("response")), "link_aws": "True" }) return elif "aws_account" in event.get("callback_id"): aws_account = event.get("response").split("+")[0] aws_id = event.get("response").split("+")[1] event.update({ "vpc_list": list_vpc(event.get("token"), event.get("org_id"), aws_id, result.get("region")) }) message_handler(constant.AWS_VPC, event) db.write_event_db( user_id, { "status": "aws_account", "aws_account": aws_account, "connected_account_id": aws_id }) return elif "vpc" in event.get("callback_id"): event.update({ "subnet_list": list_subnet(event.get("token"), event.get("org_id"), result.get("connected_account_id"), result.get("region"), event.get("response")) }) message_handler(constant.AWS_SUBNET, event) db.write_event_db(user_id, { "status": "vpc", "vpc_id": event.get("response") }) return elif "subnet" in event.get("callback_id"): message_handler(constant.CIDR, event) db.write_event_db(user_id, { "status": "subnet", "customer_subnet_id": event.get("response") }) return elif "confirmation" in event.get("callback_id"): if "yes" in event.get("response"): message_handler(constant.CREATE, event) db.write_event_db(user_id, { "status": "creating", }) event.update(result) call_lambda("create_sddc", event) else: message_handler(constant.CANCEL_SDDC, event) db.delete_event_db(user_id) return elif "restore_sddc" in event.get("callback_id"): if "yes" in event.get("response"): message_handler(constant.CHECK_RESOURCE, event) event.update(result) call_lambda("check_resources", event) db.write_event_db(event.get("user_id"), {"status": "check_resources"}) else: message_handler(constant.CANCEL_RESTORE, event) db.delete_event_db(user_id) return else: return
def check_config(event): if "yes" in event.get("response"): message_handler(msg_const.CREATE, event) event.update({"vmc_command": "create_sddc"}) try: task_id = call_lambda_sync("slack_vmc", event) except Exception as e: event.update( { "message": "Sorry, failed to create sddc. {}".format(str(e)), # "text": str(e), # "status": "task_failed" } ) message_handler(msg_const.SDDC_RESULT, event) delete_event_db(event.get("db_url"), event.get("user_id")) else: event.update( { "task_id": task_id, "status": "task_started", "lambda_name": "check_task" } ) write_event_db( event.get("db_url"), event.get("user_id"), { "status": "creating", } ) call_lambda_async("check_task", event) message_handler(msg_const.TASK_MSG, event) message_handler(msg_const.CRUD_SDDC, event) message_handler(msg_const.TASK_WH, event) else: message_handler(msg_const.CANCEL_SDDC, event) delete_event_db(event.get("db_url"), event.get("user_id"))
def event_handler(event): text = event.get("text").lower() db = dbutils.DocmentDb(event.get("db_url")) current = db.read_event_db(event.get("user_id"), 120) if current is not None and current.get("status") in [ cmd_const.CREATING, cmd_const.DELETING ]: message_handler(msg_const.ASK_WAIT_TASK, event) return event_db = db.read_event_db(event.get("user_id"), 5) cred_db = db.read_cred_db(event.get("user_id")) if event_db is None: if cred_db is not None and text == "cancel": if cmd_const.REGISTERED not in cred_db.get("status"): command_handler(cmd_const.CANCEL_REGISTER, event, db) elif text in cmd_const.COMMAND_ORG: command_handler(cmd_const.COMMAND_ORG[text], event, db) return elif text in cmd_const.COMMAND_SDDC: if cred_db is not None and cmd_const.REGISTERED in cred_db.get( "status"): event_cred_update(event, cred_db) command_handler(cmd_const.COMMAND_SDDC[text], event, db) return else: message_handler(msg_const.ASK_REGISTER_TOKEN, event) return elif cred_db is not None and cmd_const.REGISTER_ORG_ID in cred_db.get( "status"): command_handler(cmd_const.REGISTER_ORG_ID, event, db) elif cred_db is not None and cmd_const.REGISTER_TOKEN in cred_db.get( "status"): command_handler(cmd_const.REGISTER_TOKEN, event, db) elif text == "help": message_handler(msg_const.HELP, event) else: message_handler(msg_const.MAY_I, event) return else: command = event_db.get("command") status = event_db.get("status") if text == "cancel": if "create_sddc" in command: message_handler(msg_const.CANCEL_SDDC, event) elif "delete_sddc" in command: message_handler(msg_const.CANCEL_DELETE, event) db.delete_event_db(event.get("user_id")) return elif cmd_const.SDDC_NAME in status: event.update(event_db.get("max_hosts")) command_handler(cmd_const.SDDC_NAME, event, db) return elif cmd_const.MGMT_CIDR in status: event.update(event_db) command_handler(cmd_const.MGMT_CIDR, event, db) return elif command in ["create_sddc", "delete_sddc"]: message_handler(constant.ASK_SELECT_BUTTON, event) return
def lambda_handler(event, context): text = event.get("text").lower() # current = read_event_db( # event.get("db_url"), # event.get("user_id"), # 120 # ) # logging.info(current) # if current is not None and current.get("status") in [cmd_const.CREATING, cmd_const.DELETING]: # message_handler(msg_const.ASK_WAIT_TASK, event) # return event_db = read_event_db(event.get("db_url"), event.get("user_id"), 5) if event_db is None: # in the case of event db does not exist cred_db = read_cred_db(event.get("db_url"), event.get("user_id")) if cred_db is not None: # in the case of cred db exists cred_status = cred_db.get("status") if cred_status == cmd_const.REGISTERED: if text in cmd_const.COMMAND_SDDC: event_cred_update(event, cred_db) command_handler(cmd_const.COMMAND_SDDC[text], event) #elif text = cmd_const.CANCEL: # cancel might come here in case of canceling create sddc etc. elif text == cmd_const.DELETE_ORG: command_handler(cmd_const.COMMAND_ORG[text], event) elif text == cmd_const.HELP: message_handler(msg_const.HELP, event) else: message_handler(msg_const.MAY_I, event) elif cred_status == cmd_const.REGISTER_ORG_ID: if text == cmd_const.CANCEL: command_handler(cmd_const.CANCEL_REGISTER, event) else: command_handler(cmd_const.REGISTER_ORG_ID, event) elif cred_status == cmd_const.REGISTER_TOKEN: if text == cmd_const.CANCEL: command_handler(cmd_const.CANCEL_REGISTER, event) else: event_cred_update(event, cred_db) command_handler(cmd_const.REGISTER_TOKEN, event) else: # in the case of cred db does not exist if text == cmd_const.HELP: message_handler(msg_const.HELP, event) elif text == cmd_const.REGISTER_ORG: command_handler(cmd_const.COMMAND_ORG[text], event) elif text in cmd_const.COMMAND_SDDC: message_handler(msg_const.ASK_REGISTER_TOKEN, event) elif text == cmd_const.DELETE_ORG: message_handler(msg_const.ASK_REGISTER_TOKEN, event) else: message_handler(msg_const.MAY_I, event) else: # in the case of event db exists command = event_db.get("command") status = event_db.get("status") if text == cmd_const.CANCEL: if command == cmd_const.CREATE_SDDC_FUNC: message_handler(msg_const.CANCEL_SDDC, event) elif command == cmd_const.DELETE_SDDC_FUNC: message_handler(msg_const.CANCEL_DELETE, event) delete_event_db(event.get("db_url"), event.get("user_id")) elif status == cmd_const.SDDC_NAME: event.update(event_db) command_handler(cmd_const.SDDC_NAME, event) elif status == cmd_const.MGMT_CIDR: event.update(event_db) command_handler(cmd_const.MGMT_CIDR, event) elif command in ["create_sddc", "delete_sddc"]: message_handler(msg_const.ASK_SELECT_BUTTON, event)
def cancel_register(event): message_handler(msg_const.CANCEL_TOKEN, event) delete_cred_db(event.get("db_url"), event.get("user_id"))