fix bug 973

[osm/LW-UI.git] / instancehandler / views.py

diff --git a/instancehandler/views.py b/instancehandler/views.py
index 212fbbf..64b5fd6 100644 (file)
--- a/instancehandler/views.py
+++ b/instancehandler/views.py
@@ -15,93 +15,293 @@
 #
 
 from django.shortcuts import render, redirect
 #
 
 from django.shortcuts import render, redirect

-from django.contrib.auth.decorators import login_required

 from django.http import HttpResponse, JsonResponse
 import yaml
 import json
 import logging
 from lib.osm.osmclient.clientv2 import Client
 from django.http import HttpResponse, JsonResponse
 import yaml
 import json
 import logging
 from lib.osm.osmclient.clientv2 import Client

+from lib.osm.osm_rdcl_parser import OsmParser

 import authosm.utils as osmutils
 import authosm.utils as osmutils

+from sf_t3d.decorators import login_required

 
 logging.basicConfig(level=logging.DEBUG)
 log = logging.getLogger('instancehandler/view.py')
 
 
 logging.basicConfig(level=logging.DEBUG)
 log = logging.getLogger('instancehandler/view.py')
 

+

 @login_required
 @login_required

-def list(request, type=None):
+def get_list(request, type=None):

     user = osmutils.get_user(request)
     project_id = user.project_id
     client = Client()
     user = osmutils.get_user(request)
     project_id = user.project_id
     client = Client()

+    result = {'type': type, 'project_id': project_id}
+    if "OSM_ERROR" in request.session:
+        result['alert_error'] = request.session["OSM_ERROR"]
+        del request.session["OSM_ERROR"]
+    raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
+    if 'application/json' not in raw_content_types:
+        return __response_handler(request, result, 'instance_list.html')
+    instance_list = None

     if type == 'ns':
         instance_list = client.ns_list(user.get_token())
     elif type == 'vnf':
         instance_list = client.vnf_list(user.get_token())
     if type == 'ns':
         instance_list = client.ns_list(user.get_token())
     elif type == 'vnf':
         instance_list = client.vnf_list(user.get_token())

+    elif type == 'pdu':
+        instance_list = client.pdu_list(user.get_token())
+    elif type == 'nsi':
+        instance_list = client.nsi_list(user.get_token())

 
 

-    result = {'instances': instance_list['data'] if instance_list and instance_list['error'] is False else [],
-              'type': type, 'project_id': project_id}
-
-    if "OSM_ERROR" in request.session:
-        result['alert_error'] = request.session["OSM_ERROR"]
-        del request.session["OSM_ERROR"]
+    result['instances'] = instance_list['data'] if instance_list and instance_list['error'] is False else []

 
     return __response_handler(request, result, 'instance_list.html')
 
 
     return __response_handler(request, result, 'instance_list.html')
 

-

 @login_required
 @login_required

-def create(request):
+def create(request, type=None):

     result = {}
     result = {}

-    try:
+    config_vim_account_id = {}
+    config_wim_account_id = {}
+    user = osmutils.get_user(request)
+    client = Client()

 
 

-        ns_data = {
-            "nsName": request.POST.get('nsName', 'WithoutName'),
-            "nsDescription": request.POST.get('nsDescription', ''),
-            "nsdId": request.POST.get('nsdId', ''),
-            "vimAccountId": request.POST.get('vimAccountId', ''),
-        }
-        if 'ssh_key' in request.POST and request.POST.get('ssh_key') != '':
-            ns_data["ssh-authorized-key"] = [request.POST.get('ssh_key')]
-
-        if 'config' in request.POST:
-            ns_config = yaml.load(request.POST.get('config'))
-            if isinstance(ns_config, dict):
-                if "vim-network-name" in ns_config:
-                    ns_config["vld"] = ns_config.pop("vim-network-name")
-                if "vld" in ns_config:
-                    print ns_config
-                    for vld in ns_config["vld"]:
+    def get_vim_account_id(vim_account):
+        if config_vim_account_id.get(vim_account):
+            return config_vim_account_id[vim_account]
+        result_client = client.vim_list(user.get_token())
+        vim_list = result_client['data'] if result_client and result_client['error'] is False else []
+        if vim_list is None or len(vim_list) == 0:
+            raise ValueError("cannot find vim account '{}'".format(vim_account))
+        for vim in vim_list:
+            if vim_account == vim['name']:
+                config_vim_account_id[vim_account] = vim['uuid']
+                return vim['uuid']
+    
+    def get_wim_account_id(wim_account):
+
+        if config_wim_account_id.get(wim_account):
+            return config_wim_account_id[wim_account]
+        result_client = client.wim_list(user.get_token())
+        wim_list = result_client['data'] if result_client and result_client['error'] is False else []
+        if wim_list is None or len(wim_list) == 0:
+            raise ValueError("cannot find wim account '{}'".format(wim_account))
+        for wim in wim_list:
+            if wim_account == wim['name']:
+                config_wim_account_id[wim_account] = wim['uuid']
+                return wim['uuid']
+
+
+    if type == 'ns':
+        try:
+
+            ns_data = {
+                "nsName": request.POST.get('nsName', 'WithoutName'),
+                "nsDescription": request.POST.get('nsDescription', ''),
+                "nsdId": request.POST.get('nsdId', ''),
+                "vimAccountId": request.POST.get('vimAccountId', ''),
+            }
+            ns_data["ssh_keys"] = []
+            if 'ssh_key' in request.POST and request.POST.get('ssh_key') != '':
+                ns_data["ssh_keys"].append(request.POST.get('ssh_key'))
+            ssh_key_files = request.FILES.getlist('ssh_key_files')
+            for ssh_key_file in ssh_key_files:
+                ssh_key = ''
+                for line in ssh_key_file:
+                    ssh_key = ssh_key + line.decode()
+                ns_data["ssh_keys"].append(ssh_key)
+            
+
+            config_file = request.FILES.get('config_file')
+            
+            if config_file is not None:
+                config = ''
+                for line in config_file:
+                    config = config + line.decode()
+                ns_config = yaml.load(config)
+            elif 'config' in request.POST and request.POST.get('config') != '':
+                ns_config = yaml.load(request.POST.get('config'))
+            else:
+                ns_config = None
+            
+           
+            if ns_config is not None:
+                if isinstance(ns_config, dict):
+                    if "vim-network-name" in ns_config:
+                        ns_config["vld"] = ns_config.pop("vim-network-name")
+                    if "vld" in ns_config:
+                        for vld in ns_config["vld"]:
+                            if vld.get("vim-network-name"):
+                                if isinstance(vld["vim-network-name"], dict):
+                                    vim_network_name_dict = {}
+                                    for vim_account, vim_net in list(vld["vim-network-name"].items()):
+                                        vim_network_name_dict[get_vim_account_id(vim_account)] = vim_net
+                                    vld["vim-network-name"] = vim_network_name_dict
+                            if "wim_account" in vld and vld["wim_account"] is not None:
+                                vld["wimAccountId"] = get_wim_account_id(vld.pop("wim_account"))
+                        ns_data["vld"] = ns_config["vld"]
+                    if "vnf" in ns_config:
+                        for vnf in ns_config["vnf"]:
+                            if vnf.get("vim_account"):
+                                vnf["vimAccountId"] = get_vim_account_id(vnf.pop("vim_account"))
+                        ns_data["vnf"] = ns_config["vnf"]
+
+                    if "additionalParamsForNs" in ns_config:
+                        ns_data["additionalParamsForNs"] = ns_config.pop("additionalParamsForNs")
+                        if not isinstance(ns_data["additionalParamsForNs"], dict):
+                            raise ValueError("Error  'additionalParamsForNs' must be a dictionary")
+                    if "additionalParamsForVnf" in ns_config:
+                        ns_data["additionalParamsForVnf"] = ns_config.pop("additionalParamsForVnf")
+                        if not isinstance(ns_data["additionalParamsForVnf"], list):
+                            raise ValueError("Error  'additionalParamsForVnf' must be a list")
+                        for additional_param_vnf in ns_data["additionalParamsForVnf"]:
+                            if not isinstance(additional_param_vnf, dict):
+                                raise ValueError("Error  'additionalParamsForVnf' items must be dictionaries")
+                            if not additional_param_vnf.get("member-vnf-index"):
+                                raise ValueError("Error  'additionalParamsForVnf' items must contain "
+                                                "'member-vnf-index'")
+                            if not additional_param_vnf.get("additionalParams"):
+                                raise ValueError("Error  'additionalParamsForVnf' items must contain "
+                                                "'additionalParams'")
+                    if "wim_account" in ns_config:
+                        wim_account = ns_config.pop("wim_account")
+                        if wim_account is not None:
+                            ns_data['wimAccountId'] = get_wim_account_id(wim_account)
+
+        except Exception as e:
+            return __response_handler(request, {'status': 400, 'code': 'BAD_REQUEST', 'detail': e.message} , url=None, status=400)
+        result = client.ns_create(user.get_token(), ns_data)
+        
+        if result['error']:
+            return __response_handler(request, result['data'], url=None,
+                                  status=result['data']['status'] if 'status' in result['data'] else 500)
+        else:
+            return __response_handler(request, {}, url=None, status=200)
+
+    elif type == 'nsi':
+        try:
+            nsi_data = {
+                "nsiName": request.POST.get('nsiName', 'WithoutName'),
+                "nsiDescription": request.POST.get('nsiDescription', ''),
+                "nstId": request.POST.get('nstId', ''),
+                "vimAccountId": request.POST.get('vimAccountId', ''),
+            }
+            
+            nsi_data["ssh_keys"] = []
+            if 'ssh_key' in request.POST and request.POST.get('ssh_key') != '':
+                nsi_data["ssh_keys"].append(request.POST.get('ssh_key'))
+            ssh_key_files = request.FILES.getlist('ssh_key_files')
+            for ssh_key_file in ssh_key_files:
+                ssh_key = ''
+                for line in ssh_key_file:
+                    ssh_key = ssh_key + line.decode()
+                nsi_data["ssh_keys"].append(ssh_key)
+            nsi_data["ssh_keys"] = ','.join(nsi_data["ssh_keys"])
+          
+            config_file = request.FILES.get('config_file')
+            
+            if config_file is not None:
+                config = ''
+                for line in config_file:
+                    config = config + line.decode()
+                nsi_config = yaml.load(config)
+            elif 'config' in request.POST and request.POST.get('config') != '':
+                nsi_config = yaml.load(request.POST.get('config'))
+            else:
+                nsi_config = None
+            
+            if nsi_config is not None:
+                if "netslice-vld" in nsi_config:
+                    for vld in nsi_config["netslice-vld"]:

                         if vld.get("vim-network-name"):
                             if isinstance(vld["vim-network-name"], dict):
                                 vim_network_name_dict = {}
                         if vld.get("vim-network-name"):
                             if isinstance(vld["vim-network-name"], dict):
                                 vim_network_name_dict = {}

-                                for vim_account, vim_net in vld["vim-network-name"].items():
-                                    vim_network_name_dict[ns_data["vimAccountId"]] = vim_net
+                                for vim_account, vim_net in list(vld["vim-network-name"].items()):
+                                    vim_network_name_dict[get_vim_account_id(vim_account)] = vim_net

                                 vld["vim-network-name"] = vim_network_name_dict
                                 vld["vim-network-name"] = vim_network_name_dict

-                    ns_data["vld"] = ns_config["vld"]
-                if "vnf" in ns_config:
-                    for vnf in ns_config["vnf"]:
-                        if vnf.get("vim_account"):
-                            vnf["vimAccountId"] = ns_data["vimAccountId"]
-
-                    ns_data["vnf"] = ns_config["vnf"]
-    except Exception as e:
-        request.session["OSM_ERROR"] = "Error creating the NS; Invalid parameters provided."
-        return __response_handler(request, {}, 'instances:list', to_redirect=True, type='ns', )
-
-    print ns_data
-    user = osmutils.get_user(request)
-    client = Client()
-    result = client.ns_create(user.get_token(), ns_data)
-    return __response_handler(request, result, 'instances:list', to_redirect=True, type='ns',)
-
+                    nsi_data["netslice-vld"] = nsi_config["netslice-vld"]
+                if "netslice-subnet" in nsi_config:
+                    for nssubnet in nsi_config["netslice-subnet"]:
+                        if "vld" in nssubnet:
+                            for vld in nssubnet["vld"]:
+                                if vld.get("vim-network-name"):
+                                    if isinstance(vld["vim-network-name"], dict):
+                                        vim_network_name_dict = {}
+                                        for vim_account, vim_net in list(vld["vim-network-name"].items()):
+                                            vim_network_name_dict[get_vim_account_id(vim_account)] = vim_net
+                                        vld["vim-network-name"] = vim_network_name_dict
+                        if "vnf" in nssubnet:
+                            for vnf in nsi_config["vnf"]:
+                                if vnf.get("vim_account"):
+                                    vnf["vimAccountId"] = get_vim_account_id(vnf.pop("vim_account"))
+                    nsi_data["netslice-subnet"] = nsi_config["netslice-subnet"]
+                if "additionalParamsForNsi" in nsi_config:
+                    nsi_data["additionalParamsForNsi"] = nsi_config.pop("additionalParamsForNsi")
+                    if not isinstance(nsi_data["additionalParamsForNsi"], dict):
+                        raise ValueError("Error at 'additionalParamsForNsi' must be a dictionary")
+                if "additionalParamsForSubnet" in nsi_config:
+                    nsi_data["additionalParamsForSubnet"] = nsi_config.pop("additionalParamsForSubnet")
+                    if not isinstance(nsi_data["additionalParamsForSubnet"], list):
+                        raise ValueError("Error 'additionalParamsForSubnet' must be a list")
+                    for additional_param_subnet in nsi_data["additionalParamsForSubnet"]:
+                        if not isinstance(additional_param_subnet, dict):
+                            raise ValueError("Error 'additionalParamsForSubnet' items must be dictionaries")
+                        if not additional_param_subnet.get("id"):
+                            raise ValueError("Error 'additionalParamsForSubnet' items must contain subnet 'id'")
+                        if not additional_param_subnet.get("additionalParamsForNs") and\
+                                not additional_param_subnet.get("additionalParamsForVnf"):
+                            raise ValueError("Error 'additionalParamsForSubnet' items must contain "
+                                            "'additionalParamsForNs' and/or 'additionalParamsForVnf'")
+        except Exception as e:
+            return __response_handler(request, {'status': 400, 'code': 'BAD_REQUEST', 'detail': e.message} , url=None, status=400)
+
+        result = client.nsi_create(user.get_token(), nsi_data)
+        if result['error']:
+            return __response_handler(request, result['data'], url=None,
+                                  status=result['data']['status'] if 'status' in result['data'] else 500)
+        else:
+            return __response_handler(request, {}, url=None, status=200)
+
+    elif type == 'pdu':
+        interface_param_name = request.POST.getlist('interfaces_name')
+        interface_param_ip = request.POST.getlist('interfaces_ip')
+        interface_param_mgmt = request.POST.getlist('interfaces_mgmt')
+        interface_param_netname = request.POST.getlist('interfaces_vimnetname')
+
+        pdu_payload = {
+            "name": request.POST.get('name'),
+            "type": request.POST.get('pdu_type'),
+            "vim_accounts": request.POST.getlist('pdu_vim_accounts'),
+            "description": request.POST.get('description'),
+            "interfaces": []
+        }
+        for i in (0,len(interface_param_name)-1):
+            pdu_payload['interfaces'].append({
+                'name': interface_param_name[i],
+                'mgmt': True if interface_param_mgmt[i] == 'true' else False,
+                'ip-address': interface_param_ip[i],
+                'vim-network-name': interface_param_netname[i]
+            })
+        result = client.pdu_create(user.get_token(), pdu_payload)
+        if result['error']:
+            return __response_handler(request, result['data'], url=None,
+                                  status=result['data']['status'] if 'status' in result['data'] else 500)
+        else:
+            return __response_handler(request, {}, url=None, status=200)

 
 @login_required
 def ns_operations(request, instance_id=None, type=None):
     user = osmutils.get_user(request)
     project_id = user.project_id
 
 @login_required
 def ns_operations(request, instance_id=None, type=None):
     user = osmutils.get_user(request)
     project_id = user.project_id

+
+    result = {'type': type, 'project_id': project_id, 'instance_id': instance_id}
+    raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
+    if 'application/json' not in raw_content_types:
+        return __response_handler(request, result, 'instance_operations_list.html')

     client = Client()
     client = Client()

-    op_list = client.ns_op_list(user.get_token(), instance_id)
-    return __response_handler(request,
-                              {'operations': op_list['data'] if op_list and op_list['error'] is False else [],
-                               'type': 'ns', 'project_id': project_id}, 'instance_operations_list.html')
+    if type == 'ns':
+        op_list = client.ns_op_list(user.get_token(), instance_id)
+    elif type == 'nsi':
+        op_list = client.nsi_op_list(user.get_token(), instance_id)
+    result['operations'] = op_list['data'] if op_list and op_list['error'] is False else []

 
 

+    return __response_handler(request, result, 'instance_operations_list.html')

 
 @login_required
 def ns_operation(request, op_id, instance_id=None, type=None):
 
 @login_required
 def ns_operation(request, op_id, instance_id=None, type=None):


@@ -125,11 +325,9 @@ def action(request, instance_id=None, type=None):
     }
 
     result = client.ns_action(user.get_token(), instance_id, action_payload)
     }
 
     result = client.ns_action(user.get_token(), instance_id, action_payload)

-    print result

     if result['error']:
         return __response_handler(request, result['data'], url=None,
                                   status=result['data']['status'] if 'status' in result['data'] else 500)
     if result['error']:
         return __response_handler(request, result['data'], url=None,
                                   status=result['data']['status'] if 'status' in result['data'] else 500)

-

     else:
         return __response_handler(request, {}, url=None, status=200)
 
     else:
         return __response_handler(request, {}, url=None, status=200)
 


@@ -140,160 +338,43 @@ def delete(request, instance_id=None, type=None):
     result = {}
     user = osmutils.get_user(request)
     client = Client()
     result = {}
     user = osmutils.get_user(request)
     client = Client()

-    result = client.ns_delete(user.get_token(), instance_id, force)
-    print result
-    return __response_handler(request, result, 'instances:list', to_redirect=True, type='ns')
+    if type == 'ns':
+        result = client.ns_delete(user.get_token(), instance_id, force)
+    elif type == 'pdu':
+        result = client.pdu_delete(user.get_token(), instance_id)
+    elif type == 'nsi':
+        result = client.nsi_delete(user.get_token(), instance_id, force)

 
 

+    if result['error']:
+        return __response_handler(request, result['data'], url=None,
+                                  status=result['data']['status'] if 'status' in result['data'] else 500)
+    else:
+        return __response_handler(request, {}, url=None, status=200)

 
 

+@login_required

 def show_topology(request, instance_id=None, type=None):
     user = osmutils.get_user(request)
     project_id = user.project_id
     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
     if 'application/json' in raw_content_types:
 def show_topology(request, instance_id=None, type=None):
     user = osmutils.get_user(request)
     project_id = user.project_id
     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
     if 'application/json' in raw_content_types:

-        result = {'vertices': [
-            {"info": {"type": "vnf", "property": {"custom_label": ""},
-                      "group": []}, "id": "ping"},
-            {"info": {"type": "vnf", "property": {"custom_label": ""},
-                      "group": []}, "id": "pong"},
-            {"info": {"type": "vdu", "property": {"custom_label": ""},
-                      "group": ['pong']}, "id": "pong/ubuntu"},
-            {"info": {"type": "vdu", "property": {"custom_label": ""},
-                      "group": ['ping']}, "id": "ping/ubuntu"},
-            {"info": {"type": "cp", "property": {"custom_label": ""},
-                      "group": ['ping']}, "id": "ping/cp0"},
-            {"info": {"type": "cp", "property": {"custom_label": ""},
-                      "group": ['ping']}, "id": "ping/cp1"},
-            {"info": {"type": "cp", "property": {"custom_label": ""},
-                      "group": ['pong']}, "id": "pong/cp0"},
-            {"info": {"type": "cp", "property": {"custom_label": ""},
-                      "group": ['pong']}, "id": "pong/cp1"},
-            {"info": {"type": "ns_vl", "property": {"custom_label": ""},
-                      "group": []}, "id": "mgmt_vl"},
-        ],
-            'edges': [
-                # {"source": "ping", "group": [], "target": "ping/cp0", "view": "Data"},
-                {"source": "pong/ubuntu", "group": ['pong'], "target": "pong/cp0", "view": "vnf"},
-                {"source": "ping/ubuntu", "group": ['ping'], "target": "ping/cp0", "view": "vnf"},
-                {"source": "pong/ubuntu", "group": ['pong'], "target": "pong/cp1", "view": "vnf"},
-                {"source": "ping/ubuntu", "group": ['ping'], "target": "ping/cp1", "view": "vnf"},
-                {"source": "pong", "group": [], "target": "mgmt_vl", "view": "ns"},
-                {"source": "ping", "group": [], "target": "mgmt_vl", "view": "ns"},
-            ], 'graph_parameters': [],
-            'model': {
-                "layer": {
-
-                    "ns": {
-                        "nodes": {
-                            "vnf": {
-                                "addable": {
-                                    "callback": "addNode"
-                                },
-                                "removable": {
-                                    "callback": "removeNode"
-                                },
-                                "expands": "vnf"
-                            },
-                            "ns_vl": {
-                                "addable": {
-                                    "callback": "addNode"
-                                },
-                                "removable": {
-                                    "callback": "removeNode"
-                                }
-                            },
-
-                        },
-                        "allowed_edges": {
-                            "ns_vl": {
-                                "destination": {
-                                    "vnf": {
-                                        "callback": "addLink",
-                                        "direct_edge": False,
-                                        "removable": {
-                                            "callback": "removeLink"
-                                        }
-                                    }
-                                }
-                            },
-                            "vnf": {
-                                "destination": {
-                                    "ns_vl": {
-                                        "callback": "addLink",
-                                        "direct_edge": False,
-                                        "removable": {
-                                            "callback": "removeLink"
-                                        }
-                                    },
-
-                                }
-                            }
-
-                        }
-                    },
-                    "vnf": {
-                        "nodes": {
-                            "vdu": {
-                                "addable": {
-                                    "callback": "addNode"
-                                },
-                                "removable": {
-                                    "callback": "removeNode"
-                                }
-                            },
-                            "cp": {
-                                "addable": {
-                                    "callback": "addNode"
-                                },
-                                "removable": {
-                                    "callback": "removeNode"
-                                }
-                            },
-
-                        },
-                        "allowed_edges": {
-                            "vdu": {
-                                "destination": {
-                                    "cp": {
-                                        "callback": "addLink",
-                                        "direct_edge": False,
-                                        "removable": {
-                                            "callback": "removeLink"
-                                        }
-                                    }
-                                }
-                            },
-                            "cp": {
-                                "destination": {
-                                    "vdu": {
-                                        "callback": "addLink",
-                                        "direct_edge": False,
-                                        "removable": {
-                                            "callback": "removeLink"
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    },
-                    "name": "OSM",
-                    "version": 1,
-                    "nodes": {
-                        "vnf": {
-                            "label": "vnf"
-                        },
-                        "ns_vl": {
-                            "label": "vl"
-                        },
-                        "cp": {
-                            "label": "cp"
-                        },
-                        "vdu": {
-                            "label": "vdu"
-                        }
-                    },
-                    "description": "osm"
-                }
-            }}
+        client = Client()
+        nsr_object = {'nsr': {}, 'vnfr': {}, 'vnfd': {}}
+        if type == 'ns':
+
+            nsr_resp = client.ns_get(user.get_token(), instance_id)
+            nsr_object['nsr'] = nsr_resp['data']
+            if 'constituent-vnfr-ref' in nsr_object['nsr'] :
+                for vnfr_id in nsr_object['nsr']['constituent-vnfr-ref']:
+                    vnfr_resp = client.vnf_get(user.get_token(), vnfr_id)
+                    vnfr = vnfr_resp['data']
+                    nsr_object['vnfr'][vnfr['id']] = vnfr
+                    if vnfr['vnfd-id'] not in nsr_object['vnfd']:
+                        vnfd_resp = client.vnfd_get(user.get_token(), vnfr['vnfd-id'])
+                        nsr_object['vnfd'][vnfr['vnfd-id']] = vnfd_resp['vnfd:vnfd-catalog']['vnfd'][0]
+
+        test = OsmParser()
+
+        result = test.nsr_to_graph(nsr_object)

         return __response_handler(request, result)
     else:
         result = {'type': type, 'project_id': project_id, 'instance_id': instance_id}
         return __response_handler(request, result)
     else:
         result = {'type': type, 'project_id': project_id, 'instance_id': instance_id}


@@ -310,7 +391,11 @@ def show(request, instance_id=None, type=None):
         result = client.ns_get(user.get_token(), instance_id)
     elif type == 'vnf':
         result = client.vnf_get(user.get_token(), instance_id)
         result = client.ns_get(user.get_token(), instance_id)
     elif type == 'vnf':
         result = client.vnf_get(user.get_token(), instance_id)

-    print result
+    elif type == 'pdu':
+        result = client.pdu_get(user.get_token(), instance_id)
+    elif type == 'nsi':
+        result = client.nsi_get(user.get_token(), instance_id)
+

     return __response_handler(request, result)
 
 
     return __response_handler(request, result)
 
 


@@ -331,7 +416,6 @@ def export_metric(request, instance_id=None, type=None):
     result = client.ns_metric_export(user.get_token(), instance_id, metric_data)
 
     if result['error']:
     result = client.ns_metric_export(user.get_token(), instance_id, metric_data)
 
     if result['error']:

-        print result

         return __response_handler(request, result['data'], url=None,
                                   status=result['data']['status'] if 'status' in result['data'] else 500)
     else:
         return __response_handler(request, result['data'], url=None,
                                   status=result['data']['status'] if 'status' in result['data'] else 500)
     else:


@@ -341,7 +425,6 @@ def export_metric(request, instance_id=None, type=None):
 @login_required
 def create_alarm(request, instance_id=None, type=None):
     metric_data = request.POST.dict()
 @login_required
 def create_alarm(request, instance_id=None, type=None):
     metric_data = request.POST.dict()

-    print metric_data

     user = osmutils.get_user(request)
     project_id = user.project_id
     client = Client()
     user = osmutils.get_user(request)
     project_id = user.project_id
     client = Client()


@@ -359,7 +442,6 @@ def create_alarm(request, instance_id=None, type=None):
 
     result = client.ns_alarm_create(user.get_token(), instance_id, metric_data)
     if result['error']:
 
     result = client.ns_alarm_create(user.get_token(), instance_id, metric_data)
     if result['error']:

-        print result

         return __response_handler(request, result['data'], url=None,
                                   status=result['data']['status'] if 'status' in result['data'] else 500)
     else:
         return __response_handler(request, result['data'], url=None,
                                   status=result['data']['status'] if 'status' in result['data'] else 500)
     else:


@@ -368,8 +450,8 @@ def create_alarm(request, instance_id=None, type=None):
 
 def __response_handler(request, data_res, url=None, to_redirect=None, *args, **kwargs):
     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')
 
 def __response_handler(request, data_res, url=None, to_redirect=None, *args, **kwargs):
     raw_content_types = request.META.get('HTTP_ACCEPT', '*/*').split(',')

-    if 'application/json' in raw_content_types or url is None:
-        return HttpResponse(json.dumps(data_res), content_type="application/json")
+    if not to_redirect and ('application/json' in raw_content_types or url is None):
+        return HttpResponse(json.dumps(data_res), content_type="application/json", *args, **kwargs)

     elif to_redirect:
         return redirect(url, *args, **kwargs)
     else:
     elif to_redirect:
         return redirect(url, *args, **kwargs)
     else: