planetstack/tests/GetConfiguration.py

   1 import os
   2 import json
   3 import socket
   4 import sys
   5 import time
   6
   7 sys.path.append("/opt/planetstack")
   8
   9 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "planetstack.settings")
  10 from openstack.manager import OpenStackManager
  11 from core.models import Slice, Sliver, ServiceClass, Reservation, Tag, Network, User, Node, Image, Deployment, Site, NetworkTemplate, NetworkSlice
  12
  13 def ps_id_to_pl_id(x):
  14     # Since we don't want the PlanetStack object IDs to conflict with existing
  15     # PlanetLab object IDs in the CMI, just add 100000 to the PlanetStack object
  16     # IDs.
  17     return 100000 + x
  18
  19 def pl_id_to_ps_id(x):
  20     return x - 100000
  21
  22 def filter_fields(src, fields):
  23     dest = {}
  24     for (key,value) in src.items():
  25         if (not fields) or (key in fields):
  26             dest[key] = value
  27     return dest
  28
  29 def GetSlices(filter={}):
  30     ps_slices = Slice.objects.filter(**filter)
  31     slices = []
  32     for ps_slice in ps_slices:
  33         node_ids=[]
  34         for ps_sliver in ps_slice.slivers.all():
  35             node_ids.append(ps_id_to_pl_id(ps_sliver.node.id))
  36
  37         slice = {"instantiation": "plc-instantiated",
  38                  "description": "planetstack slice",
  39                  "slice_id": ps_id_to_pl_id(ps_slice.id),
  40                  "node_ids": node_ids,
  41                  "url": "planetstack",
  42                  "max_nodes": 1000,
  43                  "peer_slice_id": None,
  44                  "slice_tag_ids": [],
  45                  "peer_id": None,
  46                  "site_id": ps_id_to_pl_id(ps_slice.site_id),
  47                  "name": ps_slice.name}
  48
  49                  # creator_person_id, person_ids, expires, created
  50
  51         slices.append(slice)
  52     return slices
  53
  54 def GetNodes(node_ids, fields=None):
  55     ps_nodes = Node.objects.filter(id__in=[pl_id_to_ps_id(nid) for nid in node_ids])
  56     nodes = []
  57     for ps_node in ps_nodes:
  58         slice_ids=[]
  59         for ps_sliver in ps_node.slivers.all():
  60             slice_ids.append(ps_id_to_pl_id(ps_sliver.slice.id))
  61
  62         node = {"node_id": ps_id_to_pl_id(ps_node.id),
  63                 "site_id": ps_id_to_pl_id(ps_node.site_id),
  64                 "node_type": "regular",
  65                 "peer_node_id": None,
  66                 "hostname": ps_node.name,
  67                 "conf_file_ids": [],
  68                 "slice_ids": slice_ids,
  69                 "model": "planetstack",
  70                 "peer_id": None,
  71                 "node_tag_ids": []}
  72
  73                 # last_updated, key, boot_state, pcu_ids, node_type, session, last_boot,
  74                 # interface_ids, slice_ids_whitelist, run_level, ssh_rsa_key, last_pcu_reboot,
  75                 # nodegroup_ids, verified, last_contact, boot_nonce, version,
  76                 # last_pcu_configuration, last_download, date_created, ports
  77
  78         nodes.append(node)
  79
  80     nodes = [filter_fields(node, fields) for node in nodes]
  81
  82     return nodes
  83
  84 def GetTags(slicename,node_id):
  85     return {}
  86
  87 def GetSites():
  88     ps_sites = Site.objects.all()
  89     sites = []
  90     for ps_site in ps_sites:
  91         slice_ids=[]
  92         for ps_slice in ps_site.slices.all():
  93             slice_ids.append(ps_id_to_pl_id(ps_slice.id))
  94
  95         node_ids=[]
  96         for ps_node in ps_site.nodes.all():
  97             node_ids.append(ps_id_to_pl_id(ps_node.id))
  98
  99
 100         site = {"site_id": ps_id_to_pl_id(ps_site.id),
 101                 "node_ids": node_ids,
 102                 "pcu_ids": [],
 103                 "max_slices": 100,
 104                 "max_slivers": 1000,
 105                 "is_public": False,
 106                 "peer_site_id": None,
 107                 "abbrebiated_name": ps_site.abbreviated_name,
 108                 "address_ids": [],
 109                 "name": ps_site.name,
 110                 "url": None,
 111                 "site_tag_ids": [],
 112                 "enabled": True,
 113                 "longitude": float(ps_site.location.longitude),
 114                 "latitude": float(ps_site.location.latitude),
 115                 "slice_ids": slice_ids,
 116                 "login_base": ps_site.login_base,
 117                 "peer_id": None}
 118
 119                 # last_updated, ext_consortium_id, person_ids, date_created
 120
 121         sites.append(site)
 122
 123     return sites
 124
 125 def GetInterfaces(slicename, node_ids):
 126     interfaces = []
 127     ps_slices = Slice.objects.filter(name=slicename)
 128     for ps_slice in ps_slices:
 129         for ps_sliver in ps_slice.slivers.all():
 130             node_id = ps_id_to_pl_id(ps_sliver.node_id)
 131             if node_id in node_ids:
 132                 ps_node = ps_sliver.node
 133                 interface = {"node_id": node_id,
 134                              "ip": socket.gethostbyname(ps_node.name),
 135                              "broadcast": None,
 136                              "mac": "11:22:33:44:55:66",
 137                              "bwlimit": None,
 138                              "network": None,
 139                              "is_primary": True,
 140                              "dns1": None,
 141                              "hostname": None,
 142                              "netmask": None,
 143                              "interface_tag_ids": [],
 144                              "interface_id": node_id,     # assume each node has only one interface
 145                              "gateway": None,
 146                              "dns2": None,
 147                              "type": "ipv4",
 148                              "method": "dhcp"}
 149                 interfaces.append(interface)
 150     return interfaces
 151
 152 def GetConfiguration(name):
 153     slicename = name["name"]
 154     if "node_id" in name:
 155         node_id = name["node_id"]
 156     else:
 157         node_id = 0
 158
 159     node_sliver_tags = GetTags(slicename, node_id)
 160
 161     slices = GetSlices({"name": slicename})
 162     perhost = {}
 163     allinterfaces = {}
 164     hostipmap = {}
 165     nodes = []
 166     if len(slices)==1:
 167         slice = slices[0]
 168         node_ids = slice['node_ids']
 169         nodes = GetNodes(node_ids, ['hostname', 'node_id', 'site_id'])
 170         nodemap = {}
 171         for node in nodes:
 172             nodemap[node['node_id']]=node['hostname']
 173
 174         interfaces = GetInterfaces(slicename, node_ids)
 175         hostipmap = {}
 176         for interface in interfaces:
 177             if nodemap[interface['node_id']] not in allinterfaces:
 178                 allinterfaces[nodemap[interface['node_id']]] = []
 179             interface['interface_tags'] = []
 180             allinterfaces[nodemap[interface['node_id']]].append(interface)
 181             if interface['is_primary']:
 182                 hostipmap[nodemap[interface['node_id']]] = interface['ip']
 183
 184         for nid in node_ids:
 185             sliver_tags = GetTags(slicename,nid)
 186             perhost[nodemap[nid]] = sliver_tags
 187
 188     slivers = GetSlices()
 189     if node_id != 0:
 190         slivers = [slice for slice in slivers if (node_id in slice.node_ids)]
 191
 192     sites = GetSites()
 193     for site in sites:
 194         site["site_tags"] = []
 195
 196     timestamp = int(time.time())
 197     return {'version': 3,
 198             'timestamp': timestamp,
 199             'configuration': node_sliver_tags,
 200             'allconfigurations':perhost,
 201             'hostipmap':hostipmap,
 202             'slivers': slivers,
 203             'interfaces': allinterfaces,
 204             'sites': sites,
 205             'nodes': nodes}
 206
 207 if __name__ == '__main__':
 208     print GetConfiguration({"name": "smbaker-coblitz"})
 209
 210
 211