/ - Diff - Synnefo - Greek Research and Technology Network's projects

Revision 5cf968ab

+        )
         name = models.CharField('nic name', max_length=128)
         machine = models.ForeignKey(VirtualMachine, related_name='neutron_nics')
         machine = models.ForeignKey(VirtualMachine, null=True,
                                     related_name='neutron_nics')
         network = models.ForeignKey(Network, related_name='neutron_nics')
         subnet = models.ForeignKey(Subnet, related_names='neutron_nics')
         subnet = models.ForeignKey(Subnet, related_name='neutron_nics', null=True)
         created = models.DateTimeField(auto_now_add=True)
         updated = models.DateTimeField(auto_now=True)
         index = models.IntegerField(null=True)
-...
                 return network.floating_ips.filter(machine=self.machine,
                                                    ipv4=self.ipv4,
                                                    deleted=False).exists()

             d['status'] = network.state
             d['public'] = network.public
             d['admin_state_up'] = "true"
             subnet_cidr = [s.subnet_id for s in network.subnet_set.all()]
             subnet_cidr = [s.id for s in network.subnet_set.all()]
             d['subnets'] = subnet_cidr
         return d

     from synnefo.db.models import VirtualMachine
     import models
     import subnet_views
     from logging import getLogger
     import network_views as nv
-...
             #return HttpResponse("list routers")
             return list_routers(request)
         elif request.method == 'POST':
             #return create_router(request)
             return HttpResponse("create router")
             return create_router(request)
             #return HttpResponse("create router")
         else:
             return api.api_method_not_allowed(request)
-...
             return delete_router(request, offset)
         elif request.method == 'PUT':
             #return HttpResponse("put router")
             return update_router(request,offset)
             return update_router(request, offset)
         else:
             return api.api_method_not_allowed(request)
-...
         if request.method == 'PUT':
             if offset2 == "add_router_interface":
                 #return HttpResponse("add interface")
                 return add_interface(request, offset2)
                 return add_interface(request, offset1)
             elif offset2 == "remove_router_interface":
                 #return HttpResponse("remove interface")
                 return remove_interface(request, offset22)
                 return remove_interface(request, offset1)
         else:
             return api.api_method_not_allowed(request)
-...
     def list_routers(request):
         log.debug('list_routers')
         user_routers = VirtualMachine.objects.filter(userid=request.user_uniq, router=True)
         user_routers = VirtualMachine.objects.filter(userid=request.user_uniq,
                                                      router=True)
         user_routers = utils.filter_modified_since(request, objects=user_routers)
-...
         return HttpResponse(data, status=200)
     '''
     @api.api_method(http_method='POST', user_required=True, logger=log)
     @transaction.commit_manually
     def create_router(request):
-...
             name = server['name']
         except (KeyError, AssertionError):
             raise api.faults.BadRequest("Malformed request")
         metadata = server.get('metadata', {})
         assert isinstance(metadata, dict)
         image_id = server['imageRef']
         flavor_id = server['flavorRef']
         personality = server.get('personality', [])
         assert isinstance(personality, list)
         private_networks = server.get("networks", [])
         assert isinstance(private_networks, list)
         floating_ips = server.get("floating_ips", [])
         assert isinstance(floating_ips, list)
         # Verify that personalities are well-formed
         util.verify_personality(personality)
         # Get image information
         image = util.get_image_dict(image_id, user_id)
         # Get flavor (ensure it is active)
         flavor = util.get_flavor(flavor_id, include_deleted=False)
         # Generate password
         password = util.random_password()
         try:
             netid = server[external_gateway_info]["network_id"]
             net = nv.get_network_fromdb(netid, request.user_uniq)
         except (KeyError, AssertionError):
             pass
         '''
         vm = servers.create(user_id,
                             name,
                             #password,
-...
                             #private_networks=private_networks,
                             #floating_ips=floating_ips
+                            )
         '''
         try:
             net
             mock_connect(vm, net)
         except NameError:
             pass
             #mock_connect(vm, random_public_net)
         server = router_to_dict(vm, detail=True)
         server['status'] = 'BUILD'
         server['adminPass'] = password
         response = render_router(request, server, status=202)
         return response
     '''
     @api.api_method(http_method='GET', user_required=True, logger=log)
     def get_router(request, router_id):
         log.debug('get_router_details %s', router_id)
-...
         router = util.get_vm(router_id, request.user_uniq)
         if router.neutron_networks.filter(public=False):
             return HttpResponse("There are internal interfaces on the router", status=409)
             return HttpResponse("There are internal interfaces on the router",
                                 status=409)
         #servers.destroy(router)
-...
     @api.api_method(http_method='PUT', user_required=True, logger=log)
     def add_interface(request, router_id):
         log.debug('add interface to router %s', router_id)
         info = utils.get_request_dict(request)
         router = util.get_vm(router_id, request.user_uniq)
         router_info = utils.get_request_dict(request)
         subnet = False
         try:
             subnet_id = router_info["subnet_id"]
             subnet_id = info["subnet_id"]
             subnet = True
             subnet_obj = subnet_views.get_subnet_fromdb(subnet_id,
                                             request.user_unique)
                                                         request.user_uniq)
         except KeyError:
             pass
         try:
             port_id = router_info['port_id']
             port_id = info['port_id']
             if subnet:
                 raise api.faults.BadRequest("Both subnet and port provided")
             try:
                 nic_obj = models.NetworkInteface.objects.get(id=port_id)
             except (ValueError, models.NetworkInteraface.DoesNotExist):
                 nic_obj = models.NetworkInterface.objects.get(id=port_id)
             except (ValueError, models.NetworkInterface.DoesNotExist):
                 raise api.faults.ItemNotFound('Port not found')
             if not nic_obj.ipv4:
                 raise api.faults.BadRequest("No ip-address")
-...
         if subnet:
             #create nic with the subnet and add to the vm
             nic = models.NetworkInteface(machine=router,
                                         subnet=subnet_obj,
                                         network=subnet_obj.network
                                         ipv4=subnet.gateway
+                                        )
             nic.save()
             port_id = nic.id
             nic_obj = models.NetworkInterface(machine=router,
                                               subnet=subnet_obj,
                                               network=subnet_obj.network,
                                               ipv4=subnet_obj.gateway)
             nic_obj.save()
         else:
             #connect the nic
             nic_obj.machine = router
             nic_obj.save()
             subnet_id = nic.subnet.id
         #FIX ME : do backend connection
         res = {"port_id":port_db.id,
                 "subnet_id":subnet_db.id
+              }
         res = {"port_id": nic_obj.id,
                "subnet_id": nic_obj.subnet.id}
         data = json.dumps(res)
         return HttpResponse(data, status=200)
     @api.api_method(http_method='PUT', user_required=True, logger=log)
     def remove_interface(request, router_id):
         log.debug('remove interface from router %s', router_id)
         router = util.get_vm(router_id, request.user_uniq)
         info = utils.get_request_dict(request)
         router = util.get_vm(router_id, request.user_uniq)
         subnet = False
         try:
             subnet_id = info["subnet_id"]
             subnet = True
             subnet_db = subnet_views.get_subnet_fromdb(subnet_id,
                                     request.user_unique)
                                                        request.user_uniq)
         except KeyError:
             pass
-...
             port_id = info['port_id']
             port = True
             try:
                 nic_obj = models.NetworkInteface.objects.get(id=port_id)
             except (ValueError, models.NetworkInteraface.DoesNotExist):
                 port_db = models.NetworkInterface.objects.get(id=port_id)
             except (ValueError, models.NetworkInterface.DoesNotExist):
                 raise api.faults.ItemNotFound('Port not found')
         except KeyError:
             pass
         if port and subnet:
         if (port and subnet):
             #validate port-subnet combination else return 409
             #subnet must be the first of the port
             if not port_db is subnet_db:
             if not (port_db.subnet.id == subnet_db.id):
                 return HttpResponse(status=409)
         if subnet:
             #get the port
             if not port_db:
                 port_db = subnet_db.neutron_nics.get(machine=router)
             try:
                 port_db
             except NameError:
                 try:
                     port_db = subnet_db.neutron_nics.get(machine=router)
                 except (ValueError, models.NetworkInterface.DoesNotExist):
                     raise api.faults.ItemNotFound('Port not found')
         elif port:
             #get the subnet
             if not subnet_db:
             try:
                 subnet_db
             except NameError:
                 subnet_db = port_db.subnet
         else:
             raise api.faults.BadRequest("Malformed request")
         res = {"id":str(router.id),
                 "tenant_id":request.user_uniq,
                 "port_id":port_db.id,
                 "subnet_id":subnet_db.id
+              }
         res = {"id": str(router.id),
                "tenant_id": request.user_uniq,
                "port_id": port_db.id,
                "subnet_id": subnet_db.id}
         port_db.delete()  # need to add backend stuff
         data = json.dumps(res)
-...
         nic = models.NetworkInterface.objects.get(network=net, machine=router)
         nic.delete()
     def mock_connect(router, net):
         nic = models.NetworkInterface(network=net, machine=router)
         nic.save()

         raise api.faults.BadRequest("Deletion of a subnet is not supported")
     @api.api_method(http_method='PUT', user_required=True, logger=log)
     def update_subnet(request, sub_id):
         '''Update info of a subnet'''
-...
             raise api.faults.BadRequest("Only one subnet of IPv4/IPv6 per "
                                         "network is allowed")
     def get_subnet_fromdb(subnet_id, user_id, for_update=False):
         """
         Return a Subnet instance or raise ItemNotFound.
-...
             objects = Subnet.objects
             if for_update:
                 objects = objects.select_for_update()
             return objects.get(userid=user_id, id=subnet_id)
             return objects.get(id=subnet_id, network__userid=user_id)
         except (ValueError, Subnet.DoesNotExist):
             raise api.faults.ItemNotFound('Network not found.')
             raise api.faults.ItemNotFound('Subnet not found.')

     SUBNETS_URL = join_urls(NEUTRON_URL, "subnets/")
     ROUTERS_URL = join_urls(NEUTRON_URL, "routers/")
     class NetworkTest(BaseAPITest):
         def test_list_networks(self):
-...
             router = dbmf.VirtualMachineFactory.create(router=True)
             url = join_urls(ROUTERS_URL, str(router.id))
             response = self.delete(url, user=router.userid)
             print response.content
             self.assertEqual(response.status_code, 204)
         def test_delete_router_with_private_net(self):
-...
             nic = mf.NetworkInterfaceFactory.create(network=net, machine=router)
             url = join_urls(ROUTERS_URL, str(router.id))
             response = self.delete(url, user=router.userid)
             print response.content
             self.assertEqual(response.status_code, 409)
         def test_update_router(self):
-...
             net1 = mf.NetworkFactory.create(public=True)
             net2 = mf.NetworkFactory.create(public=True)
             nic = mf.NetworkInterfaceFactory.create(network=net1, machine=router)
             request = {"router":{
                             "name": "new_name",
                             "external_gateway_info":{
                                "network_id": net2.id
+                               }
+                        }
             request = {
                 "router": {
                     "name": "new_name",
                     "external_gateway_info": {"network_id": net2.id}
+                    }
+                }
             url = join_urls(ROUTERS_URL, str(router.id))
             response = self.put(url, params=json.dumps(request), user=router.userid)
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             info = json.loads(response.content)
             self.assertEqual(info['router']['external_gateway_info']['network_id'], net2.id)
             self.assertEqual(info['router']['external_gateway_info']['network_id'],
                              net2.id)
             self.assertEqual(info['router']['name'], "new_name")
         def test_remove_interface(self):
             url = join_urls(join_urls(ROUTERS_URL,"123"), "remove_router_interface")
         def test_remove_interface_no_body(self):
             url = join_urls(join_urls(ROUTERS_URL, "123"),
                             "remove_router_interface")
             response = self.put(url, params="")
             print response.content
             self.assertEqual(response.status_code, 400)
         def test_remove_interface_unfound_port(self):
             router = dbmf.VirtualMachineFactory.create(router=True)
             request = {"port_id": "123"}
             url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
                             "remove_router_interface")
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             self.assertEqual(response.status_code, 404)
         def test_remove_interface_unfound_subnet(self):
             router = dbmf.VirtualMachineFactory.create(router=True)
             request = {"subnet_id": "123"}
             url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
                             "remove_router_interface")
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             self.assertEqual(response.status_code, 404)
         def test_remove_interface_no_info(self):
             router = dbmf.VirtualMachineFactory.create(router=True)
             request = {"wrong": "123"}
             url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
                             "remove_router_interface")
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             self.assertEqual(response.status_code, 400)
         def test_remove_interface_both_info_wrong(self):
             router = dbmf.VirtualMachineFactory.create(router=True)
             net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
             subnet = mf.SubnetFactory.create(network=net1)
             subnet2 = mf.SubnetFactory.create(network=net1)
             nic = mf.NetworkInterfaceFactory.create(network=net1, machine=router,
                                                     subnet=subnet2)
             request = {"subnet_id": subnet.id, "port_id": nic.id}
             url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
                             "remove_router_interface")
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             self.assertEqual(response.status_code, 409)
         def test_remove_interface_subnet(self):
             router = dbmf.VirtualMachineFactory.create(router=True)
             net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
             subnet = mf.SubnetFactory.create(network=net1)
             nic = mf.NetworkInterfaceFactory.create(network=net1, machine=router,
                                                     subnet=subnet)
             request = {"subnet_id": subnet.id}
             url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
                             "remove_router_interface")
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             self.assertEqual(response.status_code, 200)
         def test_remove_interface_port(self):
             router = dbmf.VirtualMachineFactory.create(router=True)
             net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
             subnet = mf.SubnetFactory.create(network=net1)
             nic = mf.NetworkInterfaceFactory.create(network=net1, machine=router,
                                                     subnet=subnet)
             request = {"port_id": nic.id}
             url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
                             "remove_router_interface")
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             self.assertEqual(response.status_code, 200)
         def test_remove_interface_both_info(self):
             router = dbmf.VirtualMachineFactory.create(router=True)
             net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
             subnet = mf.SubnetFactory.create(network=net1)
             nic = mf.NetworkInterfaceFactory.create(network=net1, machine=router,
                                                     subnet=subnet)
             request = {"subnet_id": subnet.id, "port_id": nic.id}
             url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
                             "remove_router_interface")
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             self.assertEqual(response.status_code, 200)
         def test_add_interface_no_info(self):
             url = join_urls(join_urls(ROUTERS_URL, "123"), "add_router_interface")
             response = self.put(url, params="")
             self.assertEqual(response.status_code, 400)
         def test_add_interface_wrong_info(self):
             router = dbmf.VirtualMachineFactory.create(router=True)
             url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
                             "add_router_interface")
             request = {}
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             self.assertEqual(response.status_code, 400)
         def test_add_interface_unfound_port(self):
             router = dbmf.VirtualMachineFactory.create(router=True)
             url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
                             "add_router_interface")
             request = {"port_id": "123"}
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             self.assertEqual(response.status_code, 404)
         def test_add_interface_unfound_subnet(self):
             router = dbmf.VirtualMachineFactory.create(router=True)
             url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
                             "add_router_interface")
             request = {"subnet_id": "123"}
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             self.assertEqual(response.status_code, 404)
         def test_add_interface_both(self):
             router = dbmf.VirtualMachineFactory.create(router=True)
             net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
             subnet = mf.SubnetFactory.create(network=net1)
             url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
                             "add_router_interface")
             request = {"subnet_id": subnet.id, "port_id": "123"}
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             self.assertEqual(response.status_code, 400)
         def test_add_interface_subnet(self):
             router = dbmf.VirtualMachineFactory.create(router=True)
             net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
             subnet = mf.SubnetFactory.create(network=net1)
             url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
                             "add_router_interface")
             request = {"subnet_id": subnet.id}
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             self.assertEqual(response.status_code, 200)
         def test_add_interface_port_no_ip(self):
             router = dbmf.VirtualMachineFactory.create(router=True)
             net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
             subnet = mf.SubnetFactory.create(network=net1)
             nic = mf.NetworkInterfaceFactory.create(network=net1, machine=router,
                                                     subnet=subnet)
             url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
                             "add_router_interface")
             request = {"port_id": nic.id}
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             self.assertEqual(response.status_code, 400)
         def test_add_interface_port_connected(self):
             router = dbmf.VirtualMachineFactory.create(router=True)
             vm = dbmf.VirtualMachineFactory.create()
             net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
             subnet = mf.SubnetFactory.create(network=net1)
             nic = mf.NetworkInterfaceFactory.create(network=net1, machine=vm,
                                                     subnet=subnet,
                                                     ipv4="192.168.0.1")
             url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
                             "add_router_interface")
             request = {"port_id": nic.id}
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             self.assertEqual(response.status_code, 409)
         def test_add_interface_port(self):
             router = dbmf.VirtualMachineFactory.create(router=True)
             net1 = mf.NetworkFactory.create(public=True, userid=router.userid)
             subnet = mf.SubnetFactory.create(network=net1)
             nic = mf.NetworkInterfaceFactory.create(network=net1,
                                                     machine=None,
                                                     subnet=subnet,
                                                     ipv4="192.168.0.1")
             url = join_urls(join_urls(ROUTERS_URL, str(router.id)),
                             "add_router_interface")
             request = {"port_id": nic.id}
             response = self.put(url, params=json.dumps(request),
                                 user=router.userid)
             self.assertEqual(response.status_code, 200)
         def test_add_interface(self):
             url = join_urls(join_urls(ROUTERS_URL,"123"), "add_router_interface")
             request =  {"port_id": "a2f1f29d-571b-4533-907f-5803ab96ead1","subnet_id": "a2f1f29d-571b-4533-907f-5803ab96ead1"}
             print json.dumps(request)
             response = self.put(url, params=json.dumps(request))
             print response.content
     class SubnetTest(BaseAPITest):
         def test_list_subnets(self):
-...
             test_net = mf.NetworkFactory()
             test_subnet_ipv4 = mf.SubnetFactory(network=test_net)
             test_subnet_ipv6 = mf.SubnetFactory(network=test_net, ipversion=6,
                                                 cidr='2620:0:2d0:200::7/32')
                                                 cidr='2620: 0:2d0:200::7/32')
             response = self.get(SUBNETS_URL, user=test_net.userid)
             self.assertSuccess(response)

         (r'^ports/(\w+)(?:/|.json|.xml)?$', 'port_views.port_demux'),
         (r'^routers(?:/|.json|.xml)?$', 'router_views.demux'),
         (r'^routers/(\w+)(?:/|.json|.xml)?$', 'router_views.router_demux'),
         (r'^routers/(\w+)/(remove_router_interface|add_router_interface)$', 'router_views.rinterface_demux'))
         (r'^routers/(\w+)/(remove_router_interface|add_router_interface)$',
             'router_views.rinterface_demux'))
     urlpatterns = patterns(
         '',

Also available in: Unified diff