def task_create_ibm_ike_policy(self, task_id, cloud_id, region, ike_policy_id):
"""Create and configure ike policy"""
ibm_ike_policy = doosradb.session.query(IBMIKEPolicy).filter_by(id=ike_policy_id).first()
if not ibm_ike_policy:
return
self.resource_type = "ike_policies"
self.resource = ibm_ike_policy
self.report_utils.update_reporting(
task_id=task_id, resource_name=self.resource.name, resource_type=self.resource_type, stage=PROVISIONING,
status=IN_PROGRESS
)
configured_ike_policy = self.ibm_manager.rias_ops.fetch_ops.get_all_ike_policies(name=ibm_ike_policy.name)
configured_ike_policy = configured_ike_policy[0] if configured_ike_policy else None
if not configured_ike_policy:
ibm_ike_policy.status = CREATING
doosradb.session.commit()
configured_ike_policy = configure_and_save_obj_confs(self.ibm_manager, ibm_ike_policy)
ibm_ike_policy.status = CREATED
ibm_ike_policy.resource_id = configured_ike_policy.resource_id
doosradb.session.commit()
LOGGER.info(
"IBM IKE Policy with name '{}' created successfully".format(ibm_ike_policy.name)
)
log_resource_billing(self.cloud.project.user_id, self.cloud.project.id, ibm_ike_policy)
self.report_utils.update_reporting(
task_id=task_id, resource_name=self.resource.name, resource_type=self.resource_type, stage=PROVISIONING,
status=SUCCESS
)
def task_create_ibm_vpn(self, task_id, cloud_id, region, vpn_id):
"""Create and configure VPN and Connections """
ibm_vpn_gateway = doosradb.session.query(IBMVpnGateway).filter_by(id=vpn_id).first()
if not ibm_vpn_gateway:
return
ibm_vpn_gateway.status = CREATING
doosradb.session.commit()
self.resource = ibm_vpn_gateway
self.resource_type = "vpn_gateways"
self.report_utils.update_reporting(
task_id=task_id, resource_name=self.resource.name, resource_type=self.resource_type, stage=PROVISIONING,
status=IN_PROGRESS
)
configured_vpn_gateway = configure_and_save_obj_confs(self.ibm_manager, ibm_vpn_gateway)
ibm_vpn_gateway.status = CREATED
ibm_vpn_gateway.resource_id = configured_vpn_gateway.resource_id
ibm_vpn_gateway.gateway_status = configured_vpn_gateway.gateway_status
ibm_vpn_gateway.public_ip = configured_vpn_gateway.public_ip
doosradb.session.commit()
LOGGER.info("IBM VPN with name '{}' created successfully".format(ibm_vpn_gateway.name))
log_resource_billing(self.cloud.project.user_id, self.cloud.project.id, ibm_vpn_gateway)
self.report_utils.update_reporting(
task_id=task_id, resource_name=self.resource.name, resource_type=self.resource_type, stage=PROVISIONING,
status=SUCCESS
)
def task_configure_ibm_vpn_connection(self, task_id, cloud_id, region, vpn_connection_id, resource_group=None):
"""Configure vpn connection"""
ibm_vpn_connection = doosradb.session.query(IBMVpnConnection).filter_by(id=vpn_connection_id).first()
if not ibm_vpn_connection:
return
if resource_group:
ibm_resource_group = IBMResourceGroup(name=resource_group, cloud_id=cloud_id)
ibm_resource_group = ibm_resource_group.get_existing_from_db() or ibm_resource_group
ibm_vpn_connection.ibm_resource_group = ibm_resource_group
doosradb.session.commit()
self.resource = ibm_vpn_connection
self.resource_type = "vpn_connections"
self.report_utils.update_reporting(
task_id=task_id, resource_name=self.resource.name, resource_type=self.resource_type, stage=PROVISIONING,
status=IN_PROGRESS
)
configured_vpn_connection = configure_and_save_obj_confs(self.ibm_manager, ibm_vpn_connection)
ibm_vpn_connection = configured_vpn_connection.make_copy().add_update_db(ibm_vpn_connection.ibm_vpn_gateway)
LOGGER.info("IBM VPN Connection with name '{}' created successfully".format(ibm_vpn_connection.name))
log_resource_billing(self.cloud.project.user_id, self.cloud.project.id, ibm_vpn_connection)
self.report_utils.update_reporting(
task_id=task_id, resource_name=self.resource.name, resource_type=self.resource_type, stage=PROVISIONING,
status=SUCCESS
)
def task_add_ibm_address_prefix(self, task_id, cloud_id, region,
addr_prefix_id):
"""Create and configure address prefixes"""
ibm_address_prefix = doosradb.session.query(IBMAddressPrefix).filter_by(
id=addr_prefix_id).first()
if not ibm_address_prefix:
return
ibm_address_prefix.status = CREATING
doosradb.session.commit()
self.resource = ibm_address_prefix
self.resource_type = "address_prefixes"
self.report_utils.update_reporting(task_id=task_id,
resource_name=self.resource.name,
resource_type=self.resource_type,
stage=PROVISIONING,
status=IN_PROGRESS)
configured_address_prefix = configure_and_save_obj_confs(
self.ibm_manager, ibm_address_prefix)
ibm_address_prefix.status = CREATED
ibm_address_prefix.resource_id = configured_address_prefix.resource_id
doosradb.session.commit()
LOGGER.info(
"IBM Address Prefix with name '{}' created successfully".format(
ibm_address_prefix.name))
log_resource_billing(self.cloud.project.user_id, self.cloud.project.id,
ibm_address_prefix)
self.report_utils.update_reporting(task_id=task_id,
resource_name=self.resource.name,
resource_type=self.resource_type,
stage=PROVISIONING,
status=SUCCESS)
def task_create_ibm_route(self, task_id, cloud_id, region, route_id):
"""Create IBMRoute and configures on ibm cloud"""
ibm_route = doosradb.session.query(IBMVpcRoute).filter_by(
id=route_id).first()
if not ibm_route:
return
ibm_route.status = CREATING
doosradb.session.commit()
self.resource = ibm_route
self.resource_type = "routes"
self.report_utils.update_reporting(task_id=task_id,
resource_name=self.resource.name,
resource_type=self.resource_type,
stage=PROVISIONING,
status=IN_PROGRESS)
configured_route = configure_and_save_obj_confs(self.ibm_manager,
ibm_route)
ibm_route = configured_route.make_copy().add_update_db(
ibm_route.ibm_vpc_network)
ibm_route.status = CREATED
doosradb.session.commit()
LOGGER.info("IBM Route with name '{route}' created successfully".format(
route=ibm_route.name))
log_resource_billing(self.cloud.project.user_id, self.cloud.project.id,
ibm_route)
self.report_utils.update_reporting(task_id=task_id,
resource_name=self.resource.name,
resource_type=self.resource_type,
stage=PROVISIONING,
status=SUCCESS)
def task_add_ibm_security_group(self, task_id, cloud_id, region, security_group_id):
"""Create and configure Security Group"""
ibm_security_group = doosradb.session.query(IBMSecurityGroup).filter_by(id=security_group_id).first()
if not ibm_security_group:
return
ibm_security_group.status = CREATING
doosradb.session.commit()
self.resource = ibm_security_group
self.resource_type = "security_groups"
self.report_utils.update_reporting(
task_id=task_id, resource_name=self.resource.name, resource_type=self.resource_type, stage=PROVISIONING,
status=IN_PROGRESS
)
configured_security_group = configure_and_save_obj_confs(self.ibm_manager, ibm_security_group)
ibm_security_group = configured_security_group.make_copy().add_update_db(ibm_security_group.ibm_vpc_network)
LOGGER.info(
"IBM Security Group with name '{}' created successfully".format(ibm_security_group.name))
log_resource_billing(self.cloud.project.user_id, self.cloud.project.id, ibm_security_group)
self.report_utils.update_reporting(
task_id=task_id, resource_name=self.resource.name, resource_type=self.resource_type, stage=PROVISIONING,
status=SUCCESS
)
def task_create_ibm_ssh_key(self,
task_id,
cloud_id,
region,
ssh_key_id,
resource_group=None):
"""Create and configure ssh key"""
ibm_ssh_key = doosradb.session.query(IBMSshKey).filter_by(
id=ssh_key_id).first()
if not ibm_ssh_key:
return
self.resource = ibm_ssh_key
self.resource_type = "ssh_keys"
self.report_utils.update_reporting(task_id=task_id,
resource_name=self.resource.name,
resource_type=self.resource_type,
stage=PROVISIONING,
status=IN_PROGRESS)
configured_ssh_key = self.ibm_manager.rias_ops.fetch_ops.get_all_ssh_keys(
name=ibm_ssh_key.name, public_key=ibm_ssh_key.public_key)
configured_ssh_key = configured_ssh_key[0] if configured_ssh_key else None
if not configured_ssh_key:
ibm_ssh_key.status = CREATING
if resource_group:
ibm_resource_group = IBMResourceGroup(name=resource_group,
cloud_id=cloud_id)
ibm_resource_group = ibm_resource_group.get_existing_from_db(
) or ibm_resource_group
ibm_ssh_key.ibm_resource_group = ibm_resource_group
doosradb.session.commit()
self.resource = ibm_ssh_key
configured_ssh_key = configure_and_save_obj_confs(
self.ibm_manager, ibm_ssh_key)
ibm_ssh_key.status = CREATED
ibm_ssh_key.resource_id = configured_ssh_key.resource_id
doosradb.session.commit()
LOGGER.info("IBM SSH Key with name '{}' created successfully".format(
ibm_ssh_key.name))
log_resource_billing(self.cloud.project.user_id, self.cloud.project.id,
ibm_ssh_key)
self.report_utils.update_reporting(task_id=task_id,
resource_name=self.resource.name,
resource_type=self.resource_type,
stage=PROVISIONING,
status=SUCCESS)
def task_create_floating_ip(self, data, user_id, project_id):
time.sleep(1)
ibm_floating_ip = configure_floating_ip(data)
task = (doosradb.session.query(IBMTask).filter_by(
id=str(self.request.id).strip()).first())
if task and ibm_floating_ip and ibm_floating_ip.status == CREATED:
task.status = SUCCESS
task.resource_id = ibm_floating_ip.id
log_resource_billing(user_id, project_id, ibm_floating_ip)
elif task and ibm_floating_ip:
task.status = FAILED
task.resource_id = ibm_floating_ip.id
elif task:
task.status = FAILED
doosradb.session.commit()
def task_create_ibm_vpn_gateway(self, name, vpc_id, data, user_id, project_id):
time.sleep(1)
ibm_vpn_gateway = configure_ibm_vpn_gateway(name, vpc_id, data)
task = (doosradb.session.query(IBMTask).filter_by(
id=str(self.request.id).strip()).first())
if task and ibm_vpn_gateway and ibm_vpn_gateway.status == CREATED:
task.status = SUCCESS
task.resource_id = ibm_vpn_gateway.id
log_resource_billing(user_id, project_id, ibm_vpn_gateway)
elif task and ibm_vpn_gateway:
task.status = FAILED
task.resource_id = ibm_vpn_gateway.id
elif task:
task.status = FAILED
doosradb.session.commit()
def task_create_ibm_vpc_address_prefix(self, data, vpc_id, user_id,
project_id):
time.sleep(1)
ibm_vpc_address_prefix = configure_address_prefix(data, vpc_id)
task = (doosradb.session.query(IBMTask).filter_by(
id=str(self.request.id).strip()).first())
if task and ibm_vpc_address_prefix and ibm_vpc_address_prefix.status == CREATED:
task.status = SUCCESS
task.resource_id = ibm_vpc_address_prefix.id
log_resource_billing(user_id, project_id, ibm_vpc_address_prefix)
elif task and ibm_vpc_address_prefix:
task.status = FAILED
task.resource_id = ibm_vpc_address_prefix.id
elif task:
task.status = FAILED
doosradb.session.commit()
def task_create_ibm_network_acl_rule(self, rule_name, acl_id, data, user_id,
project_id):
time.sleep(1)
ibm_acl_rule = configure_network_acl_rule(acl_id, rule_name, data)
task = (doosradb.session.query(IBMTask).filter_by(
id=str(self.request.id).strip()).first())
if task and ibm_acl_rule and ibm_acl_rule.status == CREATED:
task.status = SUCCESS
task.resource_id = ibm_acl_rule.id
log_resource_billing(user_id, project_id, ibm_acl_rule)
elif task and ibm_acl_rule:
task.status = FAILED
task.resource_id = ibm_acl_rule.id
elif task:
task.status = FAILED
doosradb.session.commit()
def task_create_ibm_subnet(self, name, vpc_id, data, user_id, project_id):
time.sleep(1)
ibm_vpc = IBMVpcNetwork.query.get(vpc_id)
subnet = configure_ibm_subnet(name, ibm_vpc, data)
task = (doosradb.session.query(IBMTask).filter_by(
id=str(self.request.id).strip()).first())
if task and subnet and subnet.status == CREATED:
task.status = SUCCESS
task.resource_id = subnet.id
log_resource_billing(user_id, project_id, subnet)
elif task and subnet:
task.status = FAILED
task.resource_id = subnet.id
elif task:
task.status = FAILED
doosradb.session.commit()
def task_create_ibm_route_for_vpc_network(self, cloud_id, vpc_id, data,
user_id, project_id):
time.sleep(1)
route = configure_ibm_vpc_route(cloud_id, vpc_id, data)
task = (doosradb.session.query(IBMTask).filter_by(
id=str(self.request.id).strip()).first())
if task and route and route.status == CREATED:
task.status = SUCCESS
task.resource_id = route.id
log_resource_billing(user_id, project_id, route)
elif task and route:
task.status = FAILED
task.resource_id = route.id
elif task:
task.status = FAILED
doosradb.session.commit()
def task_create_ibm_vpc_network(self, cloud_id, vpc_name, region, data,
user_id, project_id):
time.sleep(1)
vpc = configure_ibm_vpc(cloud_id, vpc_name, region, data)
task = (doosradb.session.query(IBMTask).filter_by(
id=str(self.request.id).strip()).first())
if task and vpc and vpc.status == CREATED:
task.status = SUCCESS
task.resource_id = vpc.id
log_resource_billing(user_id, project_id, vpc)
elif task and vpc:
task.status = FAILED
task.resource_id = vpc.id
elif task:
task.status = FAILED
doosradb.session.commit()
def task_create_ibm_public_gateway(self,
task_id,
cloud_id,
region,
public_gateway_id,
resource_group=None):
"""Create and configure public gateway"""
ibm_public_gateway = doosradb.session.query(IBMPublicGateway).filter_by(
id=public_gateway_id).first()
if not ibm_public_gateway:
return
ibm_public_gateway.status = CREATING
if resource_group:
ibm_resource_group = IBMResourceGroup(name=resource_group,
cloud_id=cloud_id)
ibm_resource_group = ibm_resource_group.get_existing_from_db(
) or ibm_resource_group
ibm_public_gateway.ibm_resource_group = ibm_resource_group
doosradb.session.commit()
self.resource = ibm_public_gateway
self.resource_type = "public_gateways"
self.report_utils.update_reporting(task_id=task_id,
resource_name=self.resource.name,
resource_type=self.resource_type,
stage=PROVISIONING,
status=IN_PROGRESS)
configured_public_gateway = configure_and_save_obj_confs(
self.ibm_manager, ibm_public_gateway)
ibm_public_gateway = configured_public_gateway.make_copy().add_update_db(
ibm_public_gateway.ibm_vpc_network)
LOGGER.info(
"IBM Public Gateway with name '{}' created successfully".format(
ibm_public_gateway.name))
log_resource_billing(self.cloud.project.user_id, self.cloud.project.id,
ibm_public_gateway)
self.report_utils.update_reporting(task_id=task_id,
resource_name=self.resource.name,
resource_type=self.resource_type,
stage=PROVISIONING,
status=SUCCESS)
def task_create_ibm_acl(self,
task_id,
cloud_id,
region,
acl_id,
resource_group=None):
"""Create and configure ACL"""
ibm_acl = doosradb.session.query(IBMNetworkAcl).filter_by(
id=acl_id).first()
if not ibm_acl:
return
ibm_acl.status = CREATING
if resource_group:
ibm_resource_group = IBMResourceGroup(name=resource_group,
cloud_id=cloud_id)
ibm_resource_group = ibm_resource_group.get_existing_from_db(
) or ibm_resource_group
ibm_acl.ibm_resource_group = ibm_resource_group
doosradb.session.commit()
self.resource = ibm_acl
self.resource_type = "acls"
self.report_utils.update_reporting(task_id=task_id,
resource_name=self.resource.name,
resource_type=self.resource_type,
stage=PROVISIONING,
status=IN_PROGRESS)
configured_acl = configure_and_save_obj_confs(self.ibm_manager, ibm_acl)
ibm_acl.status = CREATED
ibm_acl.resource_id = configured_acl.resource_id
doosradb.session.commit()
LOGGER.info("IBM ACL with name '{acl}' created successfully".format(
acl=ibm_acl.name))
log_resource_billing(self.cloud.project.user_id, self.cloud.project.id,
ibm_acl)
self.report_utils.update_reporting(task_id=task_id,
resource_name=self.resource.name,
resource_type=self.resource_type,
stage=PROVISIONING,
status=SUCCESS)
