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"))
