Exemple #1
0
def allocate_floating_ip(request):
    """Allocate a floating IP."""
    req = utils.get_json_body(request)
    floating_ip_dict = api.utils.get_attribute(req, "floatingip",
                                               required=True, attr_type=dict)
    userid = request.user_uniq
    project = floating_ip_dict.get("project", None)
    log.info('allocate_floating_ip user: %s request: %s', userid, req)

    # the network_pool is a mandatory field
    network_id = api.utils.get_attribute(floating_ip_dict,
                                         "floating_network_id",
                                         required=False,
                                         attr_type=(basestring, int))
    if network_id is None:
        floating_ip = ips.create_floating_ip(userid, project=project)
    else:
        try:
            network_id = int(network_id)
        except ValueError:
            raise faults.BadRequest("Invalid networkd ID.")

        network = util.get_network(network_id, userid, for_update=True,
                                   non_deleted=True)
        address = api.utils.get_attribute(floating_ip_dict,
                                          "floating_ip_address",
                                          required=False,
                                          attr_type=basestring)
        floating_ip = ips.create_floating_ip(userid, network, address,
                                             project=project)

    log.info("User '%s' allocated floating IP '%s'", userid, floating_ip)
    request.serialization = "json"
    data = json.dumps({"floatingip": ip_to_dict(floating_ip)})
    return HttpResponse(data, status=200)
Exemple #2
0
def allocate_floating_ip(request):
    """Allocate a floating IP."""
    req = utils.get_request_dict(request)
    floating_ip_dict = api.utils.get_attribute(req, "floatingip",
                                               required=True, attr_type=dict)
    userid = request.user_uniq
    log.info('allocate_floating_ip user: %s request: %s', userid, req)

    # the network_pool is a mandatory field
    network_id = api.utils.get_attribute(floating_ip_dict,
                                         "floating_network_id",
                                         required=False,
                                         attr_type=(basestring, int))
    if network_id is None:
        floating_ip = ips.create_floating_ip(userid)
    else:
        try:
            network_id = int(network_id)
        except ValueError:
            raise faults.BadRequest("Invalid networkd ID.")

        network = util.get_network(network_id, userid, for_update=True,
                                   non_deleted=True)
        address = api.utils.get_attribute(floating_ip_dict,
                                          "floating_ip_address",
                                          required=False,
                                          attr_type=basestring)
        floating_ip = ips.create_floating_ip(userid, network, address)

    log.info("User '%s' allocated floating IP '%s'", userid, floating_ip)
    request.serialization = "json"
    data = json.dumps({"floatingip": ip_to_dict(floating_ip)})
    return HttpResponse(data, status=200)
Exemple #3
0
def allocate_floating_ip(request):
    """Allocate a floating IP."""
    req = utils.get_json_body(request)

    log.debug("User: %s, Action: create_floating_ip, Request: %s",
              request.user_uniq, req)

    floating_ip_dict = api.utils.get_attribute(req,
                                               "floatingip",
                                               required=True,
                                               attr_type=dict)
    userid = request.user_uniq
    project = floating_ip_dict.get("project", None)
    shared_to_project = floating_ip_dict.get("shared_to_project", False)

    # the network_pool is a mandatory field
    network_id = api.utils.get_attribute(floating_ip_dict,
                                         "floating_network_id",
                                         required=False,
                                         attr_type=(basestring, int))

    if network_id is None:
        floating_ip = \
            ips.create_floating_ip(userid, project=project,
                                   shared_to_project=shared_to_project)
    else:
        try:
            network_id = int(network_id)
        except ValueError:
            raise faults.BadRequest("Invalid networkd ID.")

        network = util.get_network(network_id,
                                   userid,
                                   request.user_projects,
                                   for_update=True,
                                   non_deleted=True)
        address = api.utils.get_attribute(floating_ip_dict,
                                          "floating_ip_address",
                                          required=False,
                                          attr_type=basestring)
        floating_ip = \
            ips.create_floating_ip(userid, network, address,
                                   project=project,
                                   shared_to_project=shared_to_project)

    log.info("User %s created floating IP %s, network %s, address %s", userid,
             floating_ip.id, floating_ip.network_id, floating_ip.address)

    request.serialization = "json"
    data = json.dumps({"floatingip": ip_to_dict(floating_ip)})
    return HttpResponse(data, status=200)
Exemple #4
0
    def handle(self, *args, **options):
        if args:
            raise CommandError("Command doesn't accept any arguments")

        network_id = options['network_id']
        address = options['address']
        user = options['user']
        project = options['project']

        if not user:
            raise CommandError("'user' is required for floating IP creation")
        if not project:
            project = user

        if network_id is not None:
            network = common.get_resource("network", network_id)
            if network.deleted:
                raise CommandError("Network '%s' is deleted" % network.id)
            if not network.floating_ip_pool:
                raise CommandError("Network '%s' is not a floating IP pool." %
                                   network)

        credentials = Credentials(user)
        floating_ip = ips.create_floating_ip(credentials,
                                             project=project,
                                             network_id=network_id,
                                             address=address)

        self.stdout.write("Created floating IP '%s'.\n" % floating_ip)
Exemple #5
0
    def handle(self, *args, **options):
        if args:
            raise CommandError("Command doesn't accept any arguments")

        network_id = options['network_id']
        address = options['address']
        owner = options['owner']

        if not owner:
            raise CommandError("'owner' is required for floating IP creation")

        if network_id is not None:
            network = util.get_network(network_id, owner, for_update=True,
                                       non_deleted=True)
            if not network.floating_ip_pool:
                raise CommandError("Network '%s' is not a floating IP pool."
                                   % network)
        else:
            network = None

        floating_ip = ips.create_floating_ip(userid=owner,
                                             network=network,
                                             address=address)

        self.stdout.write("Created floating IP '%s'.\n" % floating_ip)
    def handle(self, *args, **options):
        if args:
            raise CommandError("Command doesn't accept any arguments")

        network_id = options['network_id']
        address = options['address']
        user = options['user']

        if not user:
            raise CommandError("'user' is required for floating IP creation")

        if network_id is not None:
            network = common.get_resource("network", network_id,
                                          for_update=True)
            if network.deleted:
                raise CommandError("Network '%s' is deleted" % network.id)
            if not network.floating_ip_pool:
                raise CommandError("Network '%s' is not a floating IP pool."
                                   % network)
        else:
            network = None

        floating_ip = ips.create_floating_ip(userid=user,
                                             network=network,
                                             address=address)

        self.stdout.write("Created floating IP '%s'.\n" % floating_ip)
Exemple #7
0
 def test_create(self):
     """Test if a floating IP is created properly."""
     with mocked_quotaholder():
         ip = ips.create_floating_ip(
             self.credentials, network_id=self.network.id)
     self.assertEqual(len(self.network.ips.all()), 1)
     self.assertEqual(self.network.ips.all()[0], ip)
Exemple #8
0
 def test_create(self):
     """Test if a floating IP is created properly."""
     with mocked_quotaholder():
         ip = ips.create_floating_ip(self.credentials,
                                     network_id=self.network.id)
     self.assertEqual(len(self.network.ips.all()), 1)
     self.assertEqual(self.network.ips.all()[0], ip)
Exemple #9
0
    def handle(self, *args, **options):
        if args:
            raise CommandError("Command doesn't accept any arguments")

        network_id = options['network_id']
        address = options['address']
        user = options['user']

        if not user:
            raise CommandError("'user' is required for floating IP creation")

        if network_id is not None:
            network = common.get_resource("network",
                                          network_id,
                                          for_update=True)
            if network.deleted:
                raise CommandError("Network '%s' is deleted" % network.id)
            if not network.floating_ip_pool:
                raise CommandError("Network '%s' is not a floating IP pool." %
                                   network)
        else:
            network = None

        floating_ip = ips.create_floating_ip(userid=user,
                                             network=network,
                                             address=address)

        self.stdout.write("Created floating IP '%s'.\n" % floating_ip)
Exemple #10
0
    def handle(self, *args, **options):
        if args:
            raise CommandError("Command doesn't accept any arguments")

        network_id = options['network_id']
        address = options['address']
        user = options['user']
        project = options['project']

        if not user:
            raise CommandError("'user' is required for floating IP creation")
        if not project:
            project = user

        if network_id is not None:
            network = common.get_resource("network", network_id)
            if network.deleted:
                raise CommandError("Network '%s' is deleted" % network.id)
            if not network.floating_ip_pool:
                raise CommandError("Network '%s' is not a floating IP pool."
                                   % network)

        credentials = Credentials(user)
        floating_ip = ips.create_floating_ip(credentials,
                                             project=project,
                                             network_id=network_id,
                                             address=address)

        self.stdout.write("Created floating IP '%s'.\n" % floating_ip)
Exemple #11
0
def allocate_floating_ip(request):
    """Allocate a floating IP."""
    req = utils.get_json_body(request)
    credentials = request.credentials

    log.debug("User: %s, Action: create_floating_ip, Request: %s",
              credentials.userid, req)

    floating_ip_dict = api.utils.get_attribute(req,
                                               "floatingip",
                                               required=True,
                                               attr_type=dict)
    userid = credentials.userid
    project = floating_ip_dict.get("project", None)
    shared_to_project = floating_ip_dict.get("shared_to_project", False)

    # the network_pool is a mandatory field
    network_id = api.utils.get_attribute(floating_ip_dict,
                                         "floating_network_id",
                                         required=False,
                                         attr_type=(basestring, int))

    if network_id is None:
        floating_ip = \
            ips.create_floating_ip(credentials, project=project,
                                   shared_to_project=shared_to_project)
    else:
        try:
            network_id = int(network_id)
        except ValueError:
            raise faults.BadRequest("Invalid networkd ID.")

        address = api.utils.get_attribute(floating_ip_dict,
                                          "floating_ip_address",
                                          required=False,
                                          attr_type=basestring)
        floating_ip = \
            ips.create_floating_ip(credentials, network_id, address,
                                   project=project,
                                   shared_to_project=shared_to_project)

    log.info("User %s created floating IP %s, network %s, address %s", userid,
             floating_ip.id, floating_ip.network_id, floating_ip.address)

    return HttpResponse(_floatingip_details_view(floating_ip), status=200)
Exemple #12
0
def allocate_floating_ip(request):
    """Allocate a floating IP."""
    req = utils.get_json_body(request)
    credentials = request.credentials

    log.debug("User: %s, Action: create_floating_ip, Request: %s",
              credentials.userid, req)

    floating_ip_dict = api.utils.get_attribute(req, "floatingip",
                                               required=True, attr_type=dict)
    userid = credentials.userid
    project = floating_ip_dict.get("project", None)
    shared_to_project = floating_ip_dict.get("shared_to_project", False)

    # the network_pool is a mandatory field
    network_id = api.utils.get_attribute(floating_ip_dict,
                                         "floating_network_id",
                                         required=False,
                                         attr_type=(basestring, int))

    if network_id is None:
        floating_ip = \
            ips.create_floating_ip(credentials, project=project,
                                   shared_to_project=shared_to_project)
    else:
        try:
            network_id = int(network_id)
        except ValueError:
            raise faults.BadRequest("Invalid networkd ID.")

        address = api.utils.get_attribute(floating_ip_dict,
                                          "floating_ip_address",
                                          required=False,
                                          attr_type=basestring)
        floating_ip = \
            ips.create_floating_ip(credentials, network_id, address,
                                   project=project,
                                   shared_to_project=shared_to_project)

    log.info("User %s created floating IP %s, network %s, address %s",
             userid, floating_ip.id, floating_ip.network_id,
             floating_ip.address)

    return HttpResponse(_floatingip_details_view(floating_ip), status=200)
Exemple #13
0
def compute_allocate_floating_ip(request):
    """Allocate a floating IP."""
    log.debug("User: %s, Action: compute_create_floating_ip, Request: %s",
              request.user_uniq, request)

    userid = request.user_uniq
    floating_ip = ips.create_floating_ip(userid)

    log.info("User %s created floating IP %s, network %s, address %s", userid,
             floating_ip.id, floating_ip.network_id, floating_ip.address)

    return HttpResponse(_compute_floatingip_details_view(floating_ip),
                        status=200)
Exemple #14
0
    def test_delete(self):
        """Test if the delete action succeeds/fails properly."""
        # Create a floating IP and force-attach it to a NIC instance.
        vm = mfactory.VirtualMachineFactory()
        nic = mfactory.NetworkInterfaceFactory(network=self.network,
                                               machine=vm)
        with mocked_quotaholder():
            ip = ips.create_floating_ip(
                self.credentials, network_id=self.network.id)
        ip.nic = nic
        ip.save()

        # Test 1 - Check if we can delete an IP attached to a VM.
        #
        # The validate function and the action should both fail with the
        # following message.
        expected_msg = "IP '{}' is used by server '{}'".format(ip.id, vm.id)

        # Verify that the validate function fails in silent mode.
        res, msg = ips.validate_ip_action(ip, "DELETE", silent=True)
        self.assertFalse(res)
        self.assertEqual(msg, expected_msg)

        # Verify that the validate function fails in non-silent mode.
        with self.assertRaises(faults.Conflict) as cm:
            ips.validate_ip_action(ip, "DELETE", silent=False)
        self.assertEqual(cm.exception.message, expected_msg)

        # Verify that the delete action fails with exception.
        with mocked_quotaholder():
            with self.assertRaises(faults.Conflict) as cm:
                ips.delete_floating_ip(ip.id, self.credentials)
        self.assertEqual(cm.exception.message, expected_msg)

        # Test 2 - Check if we can delete a free IP.
        #
        # Force-detach IP from NIC.
        ip.nic = None
        ip.save()

        # Verify that the validate function passes in silent mode.
        res, _ = ips.validate_ip_action(ip, "DELETE", silent=True)
        self.assertTrue(res)

        # Verify that the delete action succeeds.
        with mocked_quotaholder():
            ips.delete_floating_ip(ip.id, self.credentials)
        with self.assertRaises(ObjectDoesNotExist):
            IPAddress.objects.get(id=ip.id)
Exemple #15
0
    def test_delete(self):
        """Test if the delete action succeeds/fails properly."""
        # Create a floating IP and force-attach it to a NIC instance.
        vm = mfactory.VirtualMachineFactory()
        nic = mfactory.NetworkInterfaceFactory(network=self.network,
                                               machine=vm)
        with mocked_quotaholder():
            ip = ips.create_floating_ip(self.credentials,
                                        network_id=self.network.id)
        ip.nic = nic
        ip.save()

        # Test 1 - Check if we can delete an IP attached to a VM.
        #
        # The validate function and the action should both fail with the
        # following message.
        expected_msg = "IP '{}' is used by server '{}'".format(ip.id, vm.id)

        # Verify that the validate function fails in silent mode.
        res, msg = ips.validate_ip_action(ip, "DELETE", silent=True)
        self.assertFalse(res)
        self.assertEqual(msg, expected_msg)

        # Verify that the validate function fails in non-silent mode.
        with self.assertRaises(faults.Conflict) as cm:
            ips.validate_ip_action(ip, "DELETE", silent=False)
        self.assertEqual(cm.exception.message, expected_msg)

        # Verify that the delete action fails with exception.
        with mocked_quotaholder():
            with self.assertRaises(faults.Conflict) as cm:
                ips.delete_floating_ip(ip.id, self.credentials)
        self.assertEqual(cm.exception.message, expected_msg)

        # Test 2 - Check if we can delete a free IP.
        #
        # Force-detach IP from NIC.
        ip.nic = None
        ip.save()

        # Verify that the validate function passes in silent mode.
        res, _ = ips.validate_ip_action(ip, "DELETE", silent=True)
        self.assertTrue(res)

        # Verify that the delete action succeeds.
        with mocked_quotaholder():
            ips.delete_floating_ip(ip.id, self.credentials)
        with self.assertRaises(ObjectDoesNotExist):
            IPAddress.objects.get(id=ip.id)
Exemple #16
0
def compute_allocate_floating_ip(request):
    """Allocate a floating IP."""
    credentials = request.credentials
    userid = credentials.userid
    log.debug("User: %s, Action: compute_create_floating_ip, Request: %s",
              userid, request)

    floating_ip = ips.create_floating_ip(credentials)

    log.info("User %s created floating IP %s, network %s, address %s",
             userid, floating_ip.id, floating_ip.network_id,
             floating_ip.address)

    return HttpResponse(
        _compute_floatingip_details_view(floating_ip), status=200)