Beispiel #1
0
def update_vpc_network(user_id, user, vpc_id, cloud_project_id):
    """
    Update Google VPC network with provided data
    """
    from doosra.tasks.other.gcp_tasks import task_update_vpc_network

    data = request.get_json(force=True)
    vpc = doosradb.session.query(GcpVpcNetwork).filter_by(id=vpc_id).first()
    if not vpc:
        current_app.logger.info(
            "No VPC network found with ID {id}".format(id=vpc_id))
        return Response(status=404)

    if not vpc.gcp_cloud_project.user_project_id == user.project.id:
        return Response("INVALID_CLOUD", status=400)

    if data.get("subnets") and not validate_subnets(data.get('subnets')):
        return Response('INVALID_SUBNETS', status=400)

    task = GcpTask(
        task_update_vpc_network.delay(vpc.id, data.get("subnets")).id, "VPC",
        "UPDATE", vpc.gcp_cloud_project.gcp_cloud.id, vpc.id)
    doosradb.session.add(task)
    doosradb.session.commit()

    current_app.logger.info(VPC_UPDATE.format(user.email))
    resp = jsonify({"task_id": task.id})
    resp.status_code = 202
    return resp
Beispiel #2
0
def delete_instance_group(user_id, user, cloud_project_id, load_balancer_id):
    """
    Delete load-balancer on selected cloud
    """
    from doosra.tasks.other.gcp_tasks import task_delete_load_balancer

    load_balancer = doosradb.session.query(GcpLoadBalancer).filter_by(
        id=load_balancer_id).first()
    if not load_balancer:
        current_app.logger.info(
            "No Google 'Load-Balancer' found with ID {id}".format(
                id=load_balancer_id))
        return Response(status=404)

    if not load_balancer.gcp_cloud_project.user_project_id == user.project.id:
        return Response("INVALID_CLOUD", status=400)

    task = GcpTask(
        task_delete_load_balancer.delay(load_balancer.id).id, "LOAD-BALANCER",
        "DELETE", load_balancer.gcp_cloud_project.gcp_cloud.id,
        load_balancer.id)
    doosradb.session.add(task)
    load_balancer.status = DELETING
    doosradb.session.commit()

    current_app.logger.info(LOAD_BALANCER_DELETE.format(user.email))
    resp = jsonify({"task_id": task.id})
    resp.status_code = 202
    return resp
Beispiel #3
0
def add_vpc_network(user_id, user, cloud_project_id):
    """
    Deploy VPC network on selected cloud
    """
    from doosra.tasks.other.gcp_tasks import task_create_vpc_network

    data = request.get_json(force=True)
    project = doosradb.session.query(GcpCloudProject).filter_by(
        id=cloud_project_id, user_project_id=user.project.id).first()
    if not project:
        current_app.logger.info(
            "No GCP cloud project found with ID {id}".format(
                id=cloud_project_id))
        return Response(status=404)

    vpc = doosradb.session.query(GcpVpcNetwork).filter_by(
        name=data['name'], cloud_project_id=cloud_project_id).first()
    if vpc:
        return Response("ERROR_CONFLICTING_VPC_NAME", status=409)

    if data.get("subnets") and not validate_subnets(data.get('subnets')):
        return Response('INVALID_SUBNETS', status=400)

    task = GcpTask(
        task_create_vpc_network.delay(project.id, data.get("name"),
                                      data.get("description"),
                                      data.get("subnets")).id, "VPC", "ADD",
        project.gcp_cloud.id)
    doosradb.session.add(task)
    doosradb.session.commit()

    current_app.logger.info(VPC_CREATE.format(user.email))
    resp = jsonify({"task_id": task.id})
    resp.status_code = 202
    return resp
Beispiel #4
0
def delete_instance_group(user_id, user, cloud_project_id, vpc_id,
                          instance_group_id):
    """
    Delete instance-group on selected cloud
    """
    from doosra.tasks.other.gcp_tasks import task_delete_instance_group

    instance_group = doosradb.session.query(GcpInstanceGroup).filter_by(
        id=instance_group_id).first()
    if not instance_group:
        current_app.logger.info(
            "No Google 'Instance Group' found with ID {id}".format(
                id=instance_group_id))
        return Response(status=404)

    if not instance_group.gcp_vpc_network.gcp_cloud_project.user_project_id == user.project.id:
        return Response("INVALID_CLOUD", status=400)

    task = GcpTask(
        task_delete_instance_group.delay(instance_group.id).id,
        "INSTANCE-GROUP", "DELETE",
        instance_group.gcp_vpc_network.gcp_cloud_project.gcp_cloud.id,
        instance_group.id)
    doosradb.session.add(task)
    instance_group.status = DELETING
    doosradb.session.commit()

    current_app.logger.info(INSTANCE_GROUP_DELETE.format(user.email))
    resp = jsonify({"task_id": task.id})
    resp.status_code = 202
    return resp
Beispiel #5
0
def delete_vpc_network(user_id, user, vpc_id, cloud_project_id):
    """
    Delete VPC network on selected cloud
    """
    from doosra.tasks.other.gcp_tasks import task_delete_vpc_network

    vpc = doosradb.session.query(GcpVpcNetwork).filter_by(id=vpc_id).first()
    if not vpc:
        current_app.logger.info(
            "No Google VPC found with ID {id}".format(id=vpc_id))
        return Response(status=404)

    if not vpc.gcp_cloud_project.user_project_id == user.project.id:
        return Response("INVALID_CLOUD", status=400)

    if vpc.name == "default":
        current_app.logger.info("VPC network 'default' cannot be deleted")
        return Response(status=400)

    task = GcpTask(
        task_delete_vpc_network.delay(vpc.id).id, "VPC", "DELETE",
        vpc.gcp_cloud_project.gcp_cloud.id, vpc.id)
    doosradb.session.add(task)
    vpc.status = DELETING
    doosradb.session.commit()

    current_app.logger.info(VPC_DELETE.format(user.email))
    resp = jsonify({"task_id": task.id})
    resp.status_code = 202
    return resp
Beispiel #6
0
def delete_instance(user_id, user, instance_id, cloud_project_id):
    """
    Delete an Instance on selected cloud
    """
    from doosra.tasks.other.gcp_tasks import task_delete_instance

    instance = doosradb.session.query(GcpInstance).filter_by(
        id=instance_id).first()
    if not instance:
        current_app.logger.info(
            "No Instance found with ID {id}".format(id=instance_id))
        return Response("No Instance Found.", status=404)

    if not instance.gcp_cloud_project.user_project_id == user.project.id:
        return Response("INVALID_CLOUD", status=400)

    if instance.gcp_instance_groups:
        current_app.logger.info(
            "Instance with ID {} has instance groups".format(instance_id))
        return Response(
            "Instance has InstanceGroup attached. Delete them first.",
            status=400)

    task = GcpTask(
        task_delete_instance.delay(instance.id).id, "INSTANCE", "DELETE",
        instance.gcp_cloud_project.gcp_cloud.id, instance.id)
    doosradb.session.add(task)
    doosradb.session.commit()

    current_app.logger.info(INSTANCE_DELETE.format(user.email))
    resp = jsonify({"task_id": task.id})
    resp.status_code = 202
    return resp
Beispiel #7
0
def delete_firewall_rule(user_id, user, firewall_id, cloud_project_id):
    """
    Delete firewall rule on selected cloud
    """
    from doosra.tasks.other.gcp_tasks import task_delete_firewall_rule

    firewall = doosradb.session.query(GcpFirewallRule).filter_by(
        id=firewall_id).first()
    if not firewall:
        current_app.logger.info(
            "No Google Firewall Rule found with ID {id}".format(
                id=firewall_id))
        return Response(status=404)

    if not user.project.id == firewall.gcp_vpc_network.gcp_cloud_project.user_project_id:
        return Response("INVALID_FIREWALL_RULE", status=400)

    firewall.status = DELETING
    doosradb.session.commit()

    task = GcpTask(
        task_delete_firewall_rule.delay(firewall.id).id, "FIREWALL", "DELETE",
        firewall.gcp_vpc_network.gcp_cloud_project.gcp_cloud.id, firewall.id)
    doosradb.session.add(task)
    doosradb.session.commit()

    current_app.logger.info(FIREWALL_DELETE.format(user.email))
    resp = jsonify({"task_id": task.id})
    resp.status_code = 202
    return resp
Beispiel #8
0
def add_gcp_instance(user_id, user, cloud_project_id):
    """
    Create Instance on selected cloud
    """
    from doosra.tasks.other.gcp_tasks import task_create_instance

    data = request.get_json(force=True)
    project = doosradb.session.query(GcpCloudProject).filter_by(
        id=data['cloud_project_id']).first()
    if not project:
        current_app.logger.info(
            "No GCP cloud project found with ID {id}".format(
                id=data['cloud_project_id']))
        return Response(status=404)

    instance = doosradb.session.query(GcpInstance).filter_by(
        name=data['name'], cloud_project_id=project.id).first()
    if instance:
        return Response("INSTANCE_NAME_CONFLICT", status=409)

    if data.get('interfaces'):
        for interface in data.get('interfaces'):
            vpc = doosradb.session.query(GcpVpcNetwork).filter_by(
                id=interface['vpc_id']).first()
            if not vpc:
                return Response("VPC_NOT_FOUND", status=404)

            subnet = vpc.subnets.filter_by(
                id=interface['subnetwork_id']).first()
            if not subnet:
                return Response("SUBNET_NOT_FOUND", status=404)

    task = GcpTask(
        task_create_instance.delay(project.id, data.get("zone"),
                                   data.get("name"), data.get("machine_type"),
                                   data.get("description"),
                                   data.get('network_tags'),
                                   data.get("interfaces"),
                                   data.get("disks")).id, "INSTANCE", "ADD",
        project.gcp_cloud.id)
    doosradb.session.add(task)
    doosradb.session.commit()

    resp = jsonify({"task_id": task.id})
    resp.status_code = 202
    return resp
Beispiel #9
0
def create_instance_group(user_id, user, cloud_project_id, vpc_id):
    """
    Create instance group resource
    :return:
    """
    from doosra.tasks.other.gcp_tasks import task_create_instance_group

    data = request.get_json(force=True)
    project = doosradb.session.query(GcpCloudProject).filter_by(
        id=data['cloud_project_id'], user_project_id=user.project.id).first()
    if not project:
        current_app.logger.info(
            "No GCP cloud project found with ID {id}".format(
                id=data['cloud_project_id']))
        return Response(status=404)

    vpc = doosradb.session.query(GcpVpcNetwork).filter_by(
        id=vpc_id, cloud_project_id=data['cloud_project_id']).first()
    if not vpc:
        return Response("VPC_NOT_FOUND", status=404)

    instance_group = doosradb.session.query(GcpInstanceGroup).filter_by(
        name=data['name'], vpc_network_id=vpc_id).first()
    if instance_group:
        return Response("ERROR_CONFLICTING_INSTANCE_GROUP_NAME", status=409)

    for instance in data.get('instances'):
        gcp_instance = doosradb.session.query(GcpInstance).filter_by(
            id=instance['instance_id']).first()
        if not gcp_instance:
            return Response("INSTANCE_NOT_FOUND", status=404)

    task = GcpTask(
        task_create_instance_group.delay(project.id, data.get("name"),
                                         data).id, "INSTANCE-GROUP", "ADD",
        project.gcp_cloud.id)
    doosradb.session.add(task)
    doosradb.session.commit()

    current_app.logger.info(INSTANCE_GROUP_CREATE.format(user.email))
    resp = jsonify({"task_id": task.id})
    resp.status_code = 202
    return resp
Beispiel #10
0
def add_firewall_rule(user_id, user, cloud_project_id):
    """
    Deploy Firewall rule on selected Google Cloud
    """
    from doosra.tasks.other.gcp_tasks import task_create_firewall_rule

    data = request.get_json(force=True)
    project = doosradb.session.query(GcpCloudProject).filter_by(
        id=data['cloud_project_id'], user_project_id=user.project.id).first()
    if not project:
        current_app.logger.info(
            "No GCP cloud project found with ID {id}".format(
                id=data['cloud_project_id']))
        return Response(status=404)

    firewall_rule = doosradb.session.query(GcpFirewallRule).filter_by(
        name=data['name'], vpc_network_id=data['vpc_network_id']).first()
    if firewall_rule:
        return Response("ERROR_CONFLICTING_FIREWALL_NAME", status=409)

    vpc = doosradb.session.query(GcpVpcNetwork).filter_by(
        id=data['vpc_network_id']).first()
    if not vpc:
        return Response("VPC_NOT_FOUND", status=404)

    if data.get('ip_ranges'):
        for ip in data.get('ip_ranges'):
            if not validate_ip_range(ip):
                return Response('INVALID_IP_RANGE', status=400)

    task = GcpTask(
        task_create_firewall_rule.delay(vpc.id, data['name'], data).id,
        "FIREWALL", "ADD", project.gcp_cloud.id)
    doosradb.session.add(task)
    doosradb.session.commit()

    current_app.logger.info(FIREWALL_CREATE.format(user.email))
    resp = jsonify({"task_id": task.id})
    resp.status_code = 202
    return resp
Beispiel #11
0
def create_instance_group(user_id, user, cloud_project_id):
    """
    Create load-balancer resource
    :return:
    """
    from doosra.tasks.other.gcp_tasks import task_create_load_balancer

    data = request.get_json(force=True)
    project = doosradb.session.query(GcpCloudProject).filter_by(
        id=data['cloud_project_id'], user_project_id=user.project.id).first()
    if not project:
        current_app.logger.info(
            "No GCP cloud project found with ID {id}".format(
                id=data['cloud_project_id']))
        return Response(status=404)

    load_balancer = doosradb.session.query(GcpLoadBalancer).filter_by(
        name=data['name'], cloud_project_id=data['cloud_project_id']).first()
    if load_balancer:
        return Response("ERROR_CONFLICTING_LOAD_BALANCER_NAME", status=409)

    for backend_service in data.get('backend_services'):
        for backend in backend_service.get('backends'):
            instance_group = doosradb.session.query(
                GcpInstanceGroup).filter_by(
                    id=backend['instance_group_id']).first()
            if not instance_group:
                return Response("INSTANCE_GROUP_NOT_FOUND", status=404)

    task = GcpTask(
        task_create_load_balancer.delay(project.id, data.get("name"), data).id,
        "LOAD-BALANCER", "ADD", project.gcp_cloud.id)
    doosradb.session.add(task)
    doosradb.session.commit()

    current_app.logger.info(LOAD_BALANCER_CREATE.format(user.email))
    resp = jsonify({"task_id": task.id})
    resp.status_code = 202
    return resp