From: smbaker <smbaker@fc8-storktest.lan>
Date: Wed, 30 Oct 2013 00:25:25 +0000 (-0700)
Subject: legacy api for GetConfiguration
X-Git-Url: http://git.onelab.eu/?p=plstackapi.git;a=commitdiff_plain;h=e36a7de2c544696e89aebff42af5c04b3e7184aa

legacy api for GetConfiguration
---

diff --git a/planetstack/core/views/legacyapi.py b/planetstack/core/views/legacyapi.py
new file mode 100644
index 0000000..b6494e1
--- /dev/null
+++ b/planetstack/core/views/legacyapi.py
@@ -0,0 +1,287 @@
+import os
+import json
+import socket
+import sys
+import time
+import traceback
+import xmlrpclib
+from core.models import Slice, Sliver, ServiceClass, Reservation, Tag, Network, User, Node, Image, Deployment, Site, NetworkTemplate, NetworkSlice
+
+from django.http import HttpResponse
+from django.views.decorators.csrf import csrf_exempt
+
+slice_name_map = {}
+
+def ps_id_to_pl_id(x):
+    # Since we don't want the PlanetStack object IDs to conflict with existing
+    # PlanetLab object IDs in the CMI, just add 100000 to the PlanetStack object
+    # IDs.
+    return 100000 + x
+
+def pl_id_to_ps_id(x):
+    return x - 100000
+
+def pl_slice_id(slice):
+    if slice.name.startswith("princeton_vcoblitz"):
+        # 70 is the slice id of princeton_vcoblitz on vicci
+        return 70
+    else:
+        return ps_id_to_pl_id(slice.id)
+
+def ps_slicename_to_pl_slicename(x):
+    return slice_name_map.get(x,x)
+
+def filter_fields(src, fields):
+    dest = {}
+    for (key,value) in src.items():
+        if (not fields) or (key in fields):
+            dest[key] = value
+    return dest
+
+def GetSlices(filter={}):
+    ps_slices = Slice.objects.filter(**filter)
+    slices = []
+    for ps_slice in ps_slices:
+        node_ids=[]
+        for ps_sliver in ps_slice.slivers.all():
+            node_ids.append(ps_id_to_pl_id(ps_sliver.node.id))
+
+        slice = {"instantiation": "plc-instantiated",
+                 "description": "planetstack slice",
+                 "slice_id": pl_slice_id(ps_slice),
+                 "node_ids": node_ids,
+                 "url": "planetstack",
+                 "max_nodes": 1000,
+                 "peer_slice_id": None,
+                 "slice_tag_ids": [],
+                 "peer_id": None,
+                 "site_id": ps_id_to_pl_id(ps_slice.site_id),
+                 "name": ps_slicename_to_pl_slicename(ps_slice.name)}
+
+                 # creator_person_id, person_ids, expires, created
+
+        slices.append(slice)
+    return slices
+
+def GetNodes(node_ids=None, fields=None):
+    if node_ids:
+        ps_nodes = Node.objects.filter(id__in=[pl_id_to_ps_id(nid) for nid in node_ids])
+    else:
+        ps_nodes = Node.objects.all()
+    nodes = []
+    for ps_node in ps_nodes:
+        slice_ids=[]
+        for ps_sliver in ps_node.slivers.all():
+            slice_ids.append(pl_slice_id(ps_sliver.slice))
+
+        node = {"node_id": ps_id_to_pl_id(ps_node.id),
+                "site_id": ps_id_to_pl_id(ps_node.site_id),
+                "node_type": "regular",
+                "peer_node_id": None,
+                "hostname": ps_node.name,
+                "conf_file_ids": [],
+                "slice_ids": slice_ids,
+                "model": "planetstack",
+                "peer_id": None,
+                "node_tag_ids": []}
+
+                # last_updated, key, boot_state, pcu_ids, node_type, session, last_boot,
+                # interface_ids, slice_ids_whitelist, run_level, ssh_rsa_key, last_pcu_reboot,
+                # nodegroup_ids, verified, last_contact, boot_nonce, version,
+                # last_pcu_configuration, last_download, date_created, ports
+
+        nodes.append(node)
+
+    nodes = [filter_fields(node, fields) for node in nodes]
+
+    return nodes
+
+def GetTags(slicename,node_id):
+    return {}
+
+def GetSites():
+    ps_sites = Site.objects.all()
+    sites = []
+    for ps_site in ps_sites:
+        slice_ids=[]
+        for ps_slice in ps_site.slices.all():
+            slice_ids.append(pl_slice_id(ps_slice))
+
+        node_ids=[]
+        for ps_node in ps_site.nodes.all():
+            node_ids.append(ps_id_to_pl_id(ps_node.id))
+
+
+        site = {"site_id": ps_id_to_pl_id(ps_site.id),
+                "node_ids": node_ids,
+                "pcu_ids": [],
+                "max_slices": 100,
+                "max_slivers": 1000,
+                "is_public": False,
+                "peer_site_id": None,
+                "abbrebiated_name": ps_site.abbreviated_name,
+                "address_ids": [],
+                "name": ps_site.name,
+                "url": None,
+                "site_tag_ids": [],
+                "enabled": True,
+                "longitude": float(ps_site.location.longitude),
+                "latitude": float(ps_site.location.latitude),
+                "slice_ids": slice_ids,
+                "login_base": ps_site.login_base,
+                "peer_id": None}
+
+                # last_updated, ext_consortium_id, person_ids, date_created
+
+        sites.append(site)
+
+    return sites
+
+def GetInterfaces(slicename, node_ids):
+    interfaces = []
+    ps_slices = Slice.objects.filter(name=slicename)
+    for ps_slice in ps_slices:
+        for ps_sliver in ps_slice.slivers.all():
+            node_id = ps_id_to_pl_id(ps_sliver.node_id)
+            if node_id in node_ids:
+                ps_node = ps_sliver.node
+                interface = {"node_id": node_id,
+                             "ip": socket.gethostbyname(ps_node.name),
+                             "broadcast": None,
+                             "mac": "11:22:33:44:55:66",
+                             "bwlimit": None,
+                             "network": None,
+                             "is_primary": True,
+                             "dns1": None,
+                             "hostname": None,
+                             "netmask": None,
+                             "interface_tag_ids": [],
+                             "interface_id": node_id,     # assume each node has only one interface
+                             "gateway": None,
+                             "dns2": None,
+                             "type": "ipv4",
+                             "method": "dhcp"}
+                interfaces.append(interface)
+    return interfaces
+
+def find_multi_slicename(orig_slicename):
+    """
+         Because we sometimes have issues deleting a slice in planetstack and
+         creating a new one, allow us to use a prefix match, that way someone
+         can put a version number of the end of the slicename
+    """
+    global slice_name_map
+    slices = Slice.objects.filter()
+    for slice in slices:
+        if slice.name.startswith(orig_slicename):
+            slice_name_map[slice.name] = orig_slicename
+            return slice.name
+
+    return orig_slicename
+
+
+def GetConfiguration(name):
+    slicename = name["name"]
+    if "node_id" in name:
+        node_id = name["node_id"]
+    else:
+        node_id = 0
+
+    slicename = find_multi_slicename(slicename)
+
+    node_sliver_tags = GetTags(slicename, node_id)
+
+    slices = GetSlices({"name": slicename})
+    perhost = {}
+    allinterfaces = {}
+    hostipmap = {}
+    nodes = []
+    if len(slices)==1:
+        slice = slices[0]
+        node_ids = slice['node_ids']
+        nodes = GetNodes(node_ids, ['hostname', 'node_id', 'site_id'])
+        nodemap = {}
+        for node in nodes:
+            nodemap[node['node_id']]=node['hostname']
+
+        interfaces = GetInterfaces(slicename, node_ids)
+        hostipmap = {}
+        for interface in interfaces:
+            if nodemap[interface['node_id']] not in allinterfaces:
+                allinterfaces[nodemap[interface['node_id']]] = []
+            interface['interface_tags'] = []
+            allinterfaces[nodemap[interface['node_id']]].append(interface)
+            if interface['is_primary']:
+                hostipmap[nodemap[interface['node_id']]] = interface['ip']
+
+        for nid in node_ids:
+            sliver_tags = GetTags(slicename,nid)
+            perhost[nodemap[nid]] = sliver_tags
+
+    slivers = GetSlices()
+    if node_id != 0:
+        slivers = [slice for slice in slivers if (node_id in slice.node_ids)]
+
+    sites = GetSites()
+    for site in sites:
+        site["site_tags"] = []
+
+    timestamp = int(time.time())
+    return {'version': 3,
+            'timestamp': timestamp,
+            'configuration': node_sliver_tags,
+            'allconfigurations':perhost,
+            'hostipmap':hostipmap,
+            'slivers': slivers,
+            'interfaces': allinterfaces,
+            'sites': sites,
+            'nodes': nodes}
+
+def DoGetConfiguration():
+    find_multi_slicename("princeton_vcoblitz")
+    slices = GetSlices()
+    nodes = GetNodes()
+    configs={}
+    for slicename in ["princeton_vcoblitz"]:
+        configs[slicename] = GetConfiguration({"name": slicename})
+
+    result = {"configs": configs,
+              "slices": slices,
+              "nodes": nodes}
+
+    return result
+
+@csrf_exempt
+def LegacyXMLRPC(request):
+    if request.method == "POST":
+        try:
+            (args, method) = xmlrpclib.loads(request.body)
+            result = None
+            if (method == "GetConfiguration"):
+                result = DoGetConfiguration()
+            return HttpResponse(xmlrpclib.dumps((result,), methodresponse=True, allow_none=1))
+        except:
+            traceback.print_exc()
+            return HttpResponseServerError()
+    else:
+        return HttpResponse("Not Implemented")
+
+if __name__ == '__main__':
+    find_multi_slicename("princeton_vcoblitz")  # set up the mapping for princeton_vcoblitz2 -> princeton_vcoblitz
+
+    slices = GetSlices()
+    nodes = GetNodes()
+
+    if ("-d" in sys.argv):
+        config = GetConfiguration({"name": "princeton_vcoblitz"})
+        print config
+        print slices
+        print nodes
+    else:
+        configs={}
+        for slicename in ["princeton_vcoblitz"]:
+            configs[slicename] = GetConfiguration({"name": slicename})
+
+        file("planetstack_config","w").write(json.dumps(configs))
+        file("planetstack_slices","w").write(json.dumps(slices))
+        file("planetstack_nodes","w").write(json.dumps(nodes))
diff --git a/planetstack/planetstack/urls.py b/planetstack/planetstack/urls.py
index cc8375a..5197000 100644
--- a/planetstack/planetstack/urls.py
+++ b/planetstack/planetstack/urls.py
@@ -17,6 +17,7 @@ from core.views.slice_privileges import SlicePrivilegeList, SlicePrivilegeDetail
 from core.views.slivers import SliverList, SliverDetail
 from core.views.tags import TagList, TagDetail
 from core.views.users import UserList, UserDetail
+from core.views.GetConfiguration import GetConfigurationXMLRPC
 from core.models import *
 from core.api_root import api_root
 from rest_framework import generics
@@ -82,6 +83,9 @@ urlpatterns = patterns('',
     url(r'^plstackapi/users/$', UserList.as_view(), name='user-list'),
     url(r'^plstackapi/users/(?P<pk>[a-zA-Z0-9_\-]+)/$', UserDetail.as_view(), name='user-detail'),
 
+    url(r'^legacyapi/$', 'core.views.legacyapi.LegacyXMLRPC', name='xmlrpc'),
+
+
     #Adding in rest_framework urls
     url(r'^plstackapi/', include('rest_framework.urls', namespace='rest_framework')),