/snf-cyclades-app/synnefo/neutron/subnet_views.py - Diff - Synnefo - Greek Research and Technology Network's projects

Revision 0dae1b9f snf-cyclades-app/synnefo/neutron/subnet_views.py

     from django.utils import simplejson as json
     from snf_django.lib.api import utils
     from models import Subnet
     from models import Subnet, Network
     from synnefo.logic import networks
     import ipaddr
     from ipaddr import IPv4Network, IPv6Network
     log = getLogger(__name__)
-...
             return api.api_method_not_allowed(request)
     def subnet_demux(request, offset):
     def subnet_demux(request, sub_id):
         if request.method == 'GET':
             return get_subnet(request, offset)
             return get_subnet(request, sub_id)
         elif request.method == 'DELETE':
             return delete_subnet(request, offset)
             return delete_subnet(request, sub_id)
         elif request.method == 'PUT':
             return update_subnet(request, offset)
             return update_subnet(request, sub_id)
         else:
             return api.api_method_not_allowed(request)
-...
         log.debug('list_subnets')
         user_subnets = Subnet.objects.filter(network__userid=request.user_uniq)
         subnets_dict = [subnet_to_dict(user_subnets)
                         for net in user_subnets.order_by('name')]
         subnets_dict = [subnet_to_dict(sub)
                         for sub in user_subnets.order_by('id')]
         data = json.dumps({'subnets': subnets_dict})
         return HttpResponse(data, status=200)
-...
     def create_subnet(request):
         '''Create a subnet'''
         dic = utils.get_request_dict(request)
         log.info('create subnet %s', dic)
         dictionary = utils.get_request_dict(request)
         log.info('create subnet %s', dictionary)
         user_id = request.user_uniq
         try:
             subnet = dic['subnet']
             subnet = dictionary['subnet']
             network_id = subnet['network_id']
             cidr = subnet['cidr']
         except KeyError:
             raise api.faults.BadRequest("Malformed request")
         try:
             network = Network.objects.get(id=network_id)
         except Network.DoesNotExist:
             raise api.faults.ItemNotFound("No networks found with that id")
         if user_id != network.userid:
             raise api.faults.Unauthorized("Unauthorized operation")
         ipversion = subnet.get('ip_version', 4)
         if ipversion not in [4, 6]:
             raise api.faults.BadRequest("Malformed IP version type")
         dhcp = subnet.get('enable_dhcp', True)
         if dhcp not in [True, False]:
             raise api.faults.BadRequest("Malformed request, enable_dhcp must be"
                                         " True or False")
             raise api.faults.BadRequest("Malformed request, enable_dhcp must be "
                                         "True or False")
         name = subnet.get('name', None)
         if len(str(name)) > Subnet.SUBNET_NAME_LENGTH:
             raise api.faults.BadRequest("Subnet name too long")
         # FIX ME, SNF:gateway6 vs gateway6
         gateway6 = subnet.get('SNF:gateway6', None)
         subnet6 = subnet.get('SNF:subnet6', None)
         # Returns the first available IP in the subnet
         potential_gateway = ipaddr.IPv4Network(cidr).network + 1
         gateway = subnet.get('gateway_ip', potential_gateway)
         if ipversion == 6:
             potential_gateway = IPv6Network(cidr).network + 1
             check_number_of_subnets(network, 6)
         else:
             potential_gateway = IPv4Network(cidr).network + 1
             check_number_of_subnets(network, 4)
         networks.validate_network_params(cidr, gateway, subnet6, gateway6)
         gateway = subnet.get('gateway_ip', potential_gateway)
         networks.validate_network_params(cidr, gateway)
         # FIX ME
         try:
             sub = Subnet.objects.create(name=name, network_id=network_id,
                                         cidr=cidr, ipversion=ipversion,
                                         gateway=gateway, gateway6=gateway6,
                                         subnet6=subnet6)
             sub = Subnet.objects.create(name=name, network=network, cidr=cidr,
                                         ipversion=ipversion, gateway=gateway,
                                         dhcp=dhcp)
         except:
             print "Error"
             return "Error"
         return HttpResponse("test")
         return HttpResponse(sub, status=200)
     @api.api_method(http_method='GET', user_required=True, logger=log)
     def get_subnet(request, offset):
     def get_subnet(request, sub_id):
         '''Show info of a specific subnet'''
         log.debug('get_subnet %s', sub_id)
         user_id = request.user_uniq
         try:
             subnet = Subnet.objects.get(subnet_id=offset)
             subnet = Subnet.objects.get(id=sub_id)
         except Subnet.DoesNotExist:
             raise api.faults.ItemNotFound("Subnet not found")
         subnet_dic = subnet_to_dict(subnet)
         data = json.dumps({'subnet': subnet_dic})
         if subnet.network.userid != user_id:
             raise api.failts.Unauthorized("You're not allowed to view this subnet")
         subnet_dict = subnet_to_dict(subnet)
         data = json.dumps({'subnet': subnet_dict})
         return HttpResponse(data, status=200)
     @api.api_method(http_method='DELETE', user_required=True, logger=log)
     def delete_subnet(request, offset):
         '''Delete a subnet'''
         # Commented until we have a design document
         #log.info('delete_subnet %s', offset)
         #try:
         #    subnet = Subnet.objects.get(subnet_id=offset)
         #except Subnet.DoesNotExist:
         #    raise api.faults.ItemNotFound("Subnet not found")
             # Add support for 409 error, subnet in use
         #subnets.delete()
         #return HttpResponse(status=204)
     def delete_subnet(request, sub_id):
         '''Delete a subnet -- Operation not allowed'''
         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'''
     def subnet_to_dict(subnet):
         '''Returns a dictionary containing the info of a subnet'''
         # FIX ME, allocation pools
         dic = dict({'id': subnet.sunbet_id, 'network_id': subnet.network.id,
                     'name': subnet.name, 'tenant_id': subnet.network.userid,
                     'gateway_ip': subnet.gateway, 'ip_version': subnet.ipversion,
                     'cidr': subnet.cidr, 'enable_dhcp': subnet.dhcp,
                     'dns_nameservers': [], 'host_routes': [],
                     'allocation_pools': [], 'SNF:gateway6': subnet.gateway6,
                     'SNF:subnet6': subnet.subnet6})
     #    dic = dict(id=subnet.subnet_id, network_id=subnet.network.id,
     #               name=subnet.name, tenant_id=subnet.network.userid,
     #               gateway_ip=subnet.gateway, ip_version=subnet.ipversion,
     #               cidr=subnet.cidr, enable_dhcp=subnet.dhcp,
     #               dns_nameservers=[], allocation_pools=[], host_routes=[],
     #               snf-gateway6=subnet.gateway6, snf-subnet6=subnet.subnet6)
         return dic
         dictionary = dict({'id': subnet.id, 'network_id': subnet.network.id,
                            'name': subnet.name, 'tenant_id': subnet.network.userid,
                            'gateway_ip': subnet.gateway,
                            'ip_version': subnet.ipversion, 'cidr': subnet.cidr,
                            'enable_dhcp': subnet.dhcp, 'dns_nameservers': [],
                            'host_routes': [], 'allocation_pools': []})
         return dictionary
     def check_number_of_subnets(network, version):
         '''Checks if a user can add a subnet in a network'''
         if network.subnet_set.filter(ipversion=version):
             raise api.faults.BadRequest("Only one subnet of IPv4/IPv6 per "
                                         "network is allowed")

Also available in: Unified diff