]> git.openstreetmap.org Git - dns.git/blob - bin/mkgeo
Shorter TTL for donate.osm.org
[dns.git] / bin / mkgeo
1 #!/usr/bin/perl
2
3 use strict;
4 use warnings;
5
6 use IO::File;
7 use Math::Trig qw(deg2rad pip2 great_circle_distance);
8 use JSON::XS;
9 use LWP::UserAgent;
10 use YAML;
11
12 my $originfile = shift @ARGV;
13 my $clusterfile = shift @ARGV;
14 my $zone = shift @ARGV;
15 my $targetoriginfile = shift @ARGV;
16 my $origins = YAML::LoadFile($originfile);
17 my $clusters = YAML::LoadFile($clusterfile);
18 my @servers;
19
20 # Initialise cluster details
21 while (my($name,$cluster) = each %$clusters)
22 {
23     if ($cluster->{servers})
24     {
25         $cluster->{bandwidth} = 0;
26
27         foreach my $server (@{$cluster->{servers}})
28         {
29             $server->{cluster} = $cluster;
30             $cluster->{bandwidth} = $cluster->{bandwidth} + $server->{bandwidth};
31
32             push @servers, $server;
33         }
34     }
35     else
36     {
37         my $server = {
38             cluster => $cluster,
39             pingdom => $cluster->{pingdom},
40             bandwidth => $cluster->{bandwidth},
41             ipv4 => $cluster->{ipv4},
42             ipv6 => $cluster->{ipv6}
43         };
44
45         $cluster->{servers} = [ $server ];
46
47         push @servers, $server;
48     }
49
50     $cluster->{name} = $name;
51     $cluster->{status} = "down";
52 }
53
54 # Initialise server details
55 foreach my $server (@servers)
56 {
57     $server->{status} = "up";
58 }
59
60 # If pingdom support is enabled then check which servers are up
61 if ($ENV{PINGDOM_USERNAME} && $ENV{PINGDOM_PASSWORD})
62 {
63     my $ua = LWP::UserAgent->new;
64     my $cache;
65
66     $ua->timeout(5);
67     $ua->default_header("App-Key", "2cohi62u5haxvqmypk3ljqqrze1jufrh");
68     $ua->credentials("api.pingdom.com:443", "Pingdom API", $ENV{PINGDOM_USERNAME}, $ENV{PINGDOM_PASSWORD});
69
70     if (-f "pingdom.yml")
71     {
72         $cache = YAML::LoadFile("pingdom.yml");
73     }
74     else
75     {
76         $cache = {};
77     }
78
79     foreach my $server (@servers)
80     {
81         if (my $checkid = $server->{pingdom})
82         {
83             my $response = $ua->get("https://api.pingdom.com/api/2.0/checks/${checkid}");
84
85             if ($response->is_success)
86             {
87                 my $check = decode_json($response->content);
88
89                 $server->{status} = $check->{check}->{status};
90                 $cache->{$server->{pingdom}} = $check->{check}->{status};
91             }
92             else
93             {
94                 $server->{status} = $cache->{$server->{pingdom}} || "down";
95             }
96         }
97         else
98         {
99             $server->{status} = "down";
100         }
101     }
102
103     YAML::DumpFile("pingdom.yml", $cache);
104 }
105
106 # Mark a cluster as up if any servers are up
107 foreach my $server (@servers)
108 {
109     if ($server->{status} eq "up")
110     {
111         $server->{cluster}->{status} = "up";
112     }
113     else
114     {
115         $server->{cluster}->{bandwidth} = $server->{cluster}->{bandwidth} - $server->{bandwidth};
116     }
117 }
118
119 # Create target origins object
120 my $targetorigins = {};
121
122 # Initialise cluster details
123 while (my($name,$cluster) = each %$clusters)
124 {
125     $cluster->{bandwidth_limit} = $cluster->{bandwidth} * 1024 * 1024;
126     $cluster->{bandwidth_used} = 0;
127
128     $targetorigins->{$cluster->{name}} = {
129         code => $cluster->{name},
130         name => $cluster->{name},
131         lat => $cluster->{lat},
132         lon => $cluster->{lon},
133         bandwidth => 0
134     };
135 }
136
137 my @mappings = ();
138
139 # Scan origins and work out which clusters each can use
140 foreach my $origin (values %$origins)
141 {
142     foreach my $cluster (values %$clusters)
143     {
144         my $match = match_origin($cluster, $origin);
145
146         if ($cluster->{status} eq "up" && $match ne "denied")
147         {
148             my $priority = $match eq "preferred" ? 20 : 10;
149             my $distance = distance($origin->{lat}, $origin->{lon}, $cluster->{lat}, $cluster->{lon});
150
151             push @mappings, {
152                 origin => $origin, cluster => $cluster,
153                 priority => $priority, distance => $distance
154             };
155         }
156     }
157 }
158
159 # Allocate each country to a cluster
160 allocate_clusters(@mappings);
161
162 # If we failed to allocate every origin then loop, increasing
163 # the bandwidth for each cluster by a little and retrying until
164 # we manage to allocate everything
165 while (grep { !exists($_->{cluster}) } values %$origins)
166 {
167     # Clear any existing mappings of countries to clusters
168     foreach my $origin (values %$origins)
169     {
170         delete $origin->{cluster};
171     }
172
173     # Reset bandwidth usage for clusters and increase limits by 10%
174     foreach my $cluster (values %$clusters)
175     {
176         $cluster->{bandwidth_used} = 0;
177         $cluster->{bandwidth_limit} = $cluster->{bandwidth_limit} * 1.1;
178     }
179
180     # Try the allocate again
181     allocate_clusters(@mappings);
182 }
183
184 # Create JSON collection object
185 my @json;
186
187 # Open output files
188 my $zonefile = IO::File->new("> data/${zone}") || die "$!";
189 my $jsonfile = IO::File->new("> json/${zone}.json") || die "$!";
190
191 # Output details for each country
192 foreach my $origin (sort { $a->{name} cmp $b->{name} } values %$origins)
193 {
194     my $cluster = $origin->{cluster};
195     my $clon = $origin->{lon};
196     my $clat = $origin->{lat};
197     my $slon = $cluster->{lon};
198     my $slat = $cluster->{lat};
199
200     if ($clon > 0 && $slon < 0 && 360 + $slon - $clon < $clon - $slon)
201     {
202         $slon = $slon + 360;
203     }
204     elsif ($slon > 0 && $clon < 0 && 360 + $clon - $slon < $slon - $clon)
205     {
206         $clon = $clon + 360;
207     }
208
209     $zonefile->print("# $origin->{name}\n");
210     $zonefile->print("C\L$origin->{code}\E.${zone}:$cluster->{name}.${zone}:600\n");
211
212     push @json, {
213         type => "Feature",
214         geometry => {
215             type => "LineString",
216             coordinates => [ [ $clon, $clat ], [ $slon, $slat ] ]
217         },
218         properties => {
219             origin => $origin->{name},
220             server => $cluster->{name},
221             colour => $cluster->{colour}
222         }
223     };
224
225     $targetorigins->{$cluster->{name}}->{bandwidth} += $origin->{bandwidth};
226 }
227
228 # Header for default records
229 $zonefile->print("# Unknown origins\n");
230
231 # Output default records for IPs that can't be mapped to a country
232 foreach my $cluster (sort { $a->{name} cmp $b->{name} } values %$clusters)
233 {
234     my $name = $cluster->{name};
235
236     if (my $default = $cluster->{default})
237     {
238         output_server($zonefile, "${default}.${zone}", $cluster);
239     }
240     elsif (exists($cluster->{default}))
241     {
242         output_server($zonefile, "${zone}", $cluster);
243     }
244 }
245
246 # Header for underlying servers
247 $zonefile->print("# Servers\n");
248
249 # Output A records for each cluster
250 foreach my $cluster (sort { $a->{name} cmp $b->{name} } values %$clusters)
251 {
252     my $name = $cluster->{name};
253
254     output_server($zonefile, "${name}.${zone}", $cluster);
255 }
256
257 # Output the GeoJSON text
258 $jsonfile->print(encode_json(\@json));
259
260 # Close the output files
261 $jsonfile->close();
262 $zonefile->close();
263
264 # Output the target details in origin format if required
265 YAML::DumpFile($targetoriginfile, $targetorigins) if $targetoriginfile;
266
267 exit 0;
268
269 #
270 # Match an origin against a cluster
271 #
272 sub match_origin
273 {
274     my $cluster = shift;
275     my $origin = shift;
276     my $match;
277
278     if ($cluster->{preferred} &&
279         $cluster->{preferred}->{countries} &&
280         grep { $_ eq $origin->{country} } @{$cluster->{preferred}->{countries}})
281     {
282         $match = "preferred";
283     }
284     elsif ($cluster->{allowed} &&
285            $cluster->{allowed}->{countries} &&
286            grep { $_ eq $origin->{country} } @{$cluster->{allowed}->{countries}})
287     {
288         $match = "allowed";
289     }
290     elsif ($cluster->{denied} &&
291            $cluster->{denied}->{countries} &&
292            grep { $_ eq $origin->{country} } @{$cluster->{denied}->{countries}})
293     {
294         $match = "denied";
295     }
296     elsif ($cluster->{preferred} &&
297            $cluster->{preferred}->{continents} &&
298            grep { $_ eq $origin->{continent} } @{$cluster->{preferred}->{continents}})
299     {
300         $match = "preferred";
301     }
302     elsif ($cluster->{allowed} &&
303            $cluster->{allowed}->{continents} &&
304            grep { $_ eq $origin->{continent} } @{$cluster->{allowed}->{continents}})
305     {
306         $match = "allowed";
307     }
308     elsif ($cluster->{denied} &&
309            $cluster->{denied}->{continents} &&
310            grep { $_ eq $origin->{continent} } @{$cluster->{denied}->{continents}})
311     {
312         $match = "denied";
313     }
314     elsif ($cluster->{allowed})
315     {
316         $match = "denied";
317     }
318     else
319     {
320         $match = "allowed";
321     }
322
323     return $match;
324 }
325
326 #
327 # Compute the great circle distance between two points
328 #
329 sub distance
330 {
331     my $lat1 = deg2rad(shift);
332     my $lon1 = deg2rad(shift);
333     my $lat2 = deg2rad(shift);
334     my $lon2 = deg2rad(shift);
335
336     return great_circle_distance($lon1, pip2 - $lat1, $lon2, pip2 - $lat2);
337 }
338
339 #
340 # Allocate each origin to a cluster
341 #
342 sub allocate_clusters
343 {
344     my @mappings = sort { compare_mappings($a, $b) } @_;
345
346     # Loop over the mappings, trying to assign each origin to the
347     # nearest cluster, but subject to the bandwidth limits
348     while (my $mapping = shift @mappings)
349     {
350         my @group;
351
352         push @group, $mapping;
353
354         while (@mappings && compare_mappings($mapping, $mappings[0]) == 0)
355         {
356             push @group, shift @mappings;
357         }
358
359         for my $mapping (sort compare_bandwidth @group)
360         {
361             my $origin = $mapping->{origin};
362             my $cluster = $mapping->{cluster};
363
364             if (!exists($origin->{cluster}) &&
365                 $cluster->{bandwidth_used} + $origin->{bandwidth} <= $cluster->{bandwidth_limit})
366             {
367                 $origin->{cluster} = $cluster;
368                 $cluster->{bandwidth_used} = $cluster->{bandwidth_used} + $origin->{bandwidth};
369             }
370         }
371     }
372
373     return;
374 }
375
376 #
377 # Compare two mappings to decide which to use
378 #
379 sub compare_mappings
380 {
381     my $a = shift;
382     my $b = shift;
383
384     return $b->{priority} <=> $a->{priority} ||
385            $a->{distance} <=> $b->{distance};
386 }
387
388 #
389 # Compare two mappings to decide which to try first
390 #
391 sub compare_bandwidth
392 {
393     my $a_used = ( $a->{cluster}->{bandwidth_used} * 100.0 ) / ( $a->{cluster}->{bandwidth_limit} * 1.0 );
394     my $b_used = ( $b->{cluster}->{bandwidth_used} * 100.0 ) / ( $b->{cluster}->{bandwidth_limit} * 1.0 );
395
396     return $a_used <=> $b_used;
397 }
398
399 #
400 # Output DNS records for a server
401 #
402 sub output_server
403 {
404     my $zonefile = shift;
405     my $name = shift;
406     my $cluster = shift;
407
408     foreach my $server (@{$cluster->{servers}})
409     {
410         if ($server->{status} eq "up")
411         {
412             $zonefile->print("+${name}:$server->{ipv4}:600\n");
413
414             if ($server->{ipv6})
415             {
416 #                $zonefile->print("3${name}:$server->{ipv6}:600\n");
417             }
418         }
419     }
420
421     return;
422 }