hammer Python 3; add "list of closest DCs" as an output field

Author: rpardini

generate.py

@@ -7,10 +7,11 @@
 # the License, or (at your option) any later version.
 
 import os
-from string import Template
+from io import open
 from math import *
+from string import Template
 
-MAP_MARKER="""
+MAP_MARKER = """
     var M$num = new google.maps.Marker({
       position: new google.maps.LatLng($latlon),
       map: map,
@@ -19,50 +20,63 @@
     M$num.setMap(map);
 """
 
-MAP_LINE="""
+MAP_LINE = """
     var L$num = [ new google.maps.LatLng($e_ll), new google.maps.LatLng($d_ll)];
     var P$num = new google.maps.Polyline({ path: L$num, strokeColor: "#FF8378", strokeOpacity: 1.0, strokeWeight: 2 });
     P$num.setMap(map);
 """
 
+
 def haversine(lat1, lon1, lat2, lon2):
     """calculate the great circle distance between two points on the earth"""
     lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])
     dlon = lon2 - lon1
     dlat = lat2 - lat1
-    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
+    a = sin(dlat / 2) ** 2 + cos(lat1) * cos(lat2) * sin(dlon / 2) ** 2
     c = 2 * asin(sqrt(a))
     km = 6367 * c
     return km
 
+
 class Entry:
-    def __init__(self, code, name, lat, lon, tag=None, datacenter=None):
+    def __init__(self, code, name, lat, lon, tag=None, datacenter=None, alldcs=None):
         self.code = code
         self.name = name
         self.lat = lat
         self.lon = lon
 
         self.tag = tag
         self.datacenter = datacenter
+        self.alldcs = alldcs
 
     @property
     def latlon(self):
         """convenience property used in map generation"""
         return "%s, %s" % (self.lat, self.lon)
 
+
 class Entries(dict):
     def __init__(self):
         self.datacenters = {}
 
     def _get_closest_datacenter(self, lat, lon):
-        """returns closest regional datacenter using haversine formula"""
+        """returns the closest regional datacenter using haversine formula"""
         distances = {}
         for name, datacenter in self.datacenters.items():
             distance = haversine(lat, lon, datacenter.lat, datacenter.lon)
             distances[distance] = name
 
         return distances[min(distances.keys())]
 
+    def _get_datacenters_ordered_by_closest(self, lat, lon):
+        """returns all the datacenters, ordered by closest to farthest"""
+        distances = {}
+        for name, datacenter in self.datacenters.items():
+            distance = haversine(lat, lon, datacenter.lat, datacenter.lon)
+            distances[distance] = name
+
+        return ",".join(dict(sorted(distances.items())).values())
+
     def add_datacenter(self, code, name, lat, lon):
         """add a regional datacenter"""
         self.datacenters[code] = Entry(code, name, lat, lon)
@@ -71,12 +85,13 @@ def add_entry(self, code, name, lat, lon, tag=""):
         """add an entry"""
         codetag = "-".join([code, tag])
         datacenter = self._get_closest_datacenter(lat, lon)
-        self[codetag] = Entry(code, name, lat, lon, tag, datacenter)
+        alldcs = self._get_datacenters_ordered_by_closest(lat, lon)
+        self[codetag] = Entry(code, name, lat, lon, tag, datacenter, alldcs)
 
     def override_entry(self, code, name, tag, datacenter):
         """override an entries datacenter or create a new one"""
         codetag = "-".join([code, tag])
-        if self.has_key(codetag):
+        if codetag in self:
             self[codetag].datacenter = datacenter
         else:
             self[codetag] = Entry(code, name, None, None, tag, datacenter)
@@ -87,13 +102,13 @@ def write_index(self, tag, filepath):
 
         for entry in self:
             if entry.tag == tag:
-                print >>fd, "%s;%s;%s" % (entry.code, entry.name, entry.datacenter)
+                fd.write("%s;%s;%s;%s\n" % (entry.code, entry.name, entry.datacenter, entry.alldcs))
 
         fd.close()
 
     def write_map(self, template, cables, output):
         """generate map from template (cables, markers, lines)"""
-        t = Template(file(template).read())
+        t = Template(open(template).read())
 
         # markers
         n = 0
@@ -114,22 +129,23 @@ def write_map(self, template, cables, output):
             d = self.datacenters[e.datacenter]
             lines.append(line.substitute(num=n, e_ll=e.latlon, d_ll=d.latlon))
 
-        html = t.substitute( CABLES=file(cables).read(),
-                             MARKERS="\n".join(markers),
-                             LINES="\n".join(lines) )
+        html = t.substitute(CABLES=open(cables).read(),
+                            MARKERS="\n".join(markers),
+                            LINES="\n".join(lines))
 
         fd = open(output, 'w')
         fd.write(html)
         fd.close()
 
     def __iter__(self):
         """iterate over the dictionary as it if were a sorted list"""
-        return (self[key] for key in iter(sorted(dict.iterkeys(self))))
+        return (self[key] for key in iter(sorted(dict.keys(self))))
+
 
 def main():
     entries = Entries()
 
-    for line in file("input/datacenters").readlines():
+    for line in open("input/datacenters").readlines():
         if line[0] == '#':
             continue
         code, name, lat, lon = line.rstrip().split(";")
@@ -139,15 +155,15 @@ def main():
         if line[0] == '#':
             continue
         tag = os.path.basename(filepath)
-        for line in file(filepath).readlines():
+        for line in open(filepath).readlines():
             code, name, lat, lon = line.rstrip().split(";")
             entries.add_entry(code, name, float(lat), float(lon), tag)
 
-    for line in file("input/overrides").readlines():
+    for line in open("input/overrides").readlines():
         if line[0] == '#':
             continue
         code, tag, name, datacenter = line.rstrip().split(";")
-        if entries.datacenters.has_key(code):
+        if datacenter in entries.datacenters:
             entries.override_entry(code, name, tag, datacenter)
 
     entries.write_index("usa", "output/usa.index")
@@ -157,4 +173,3 @@ def main():
 
 if __name__ == "__main__":
     main()
-