Fix generation of JSON data for tile server map
[dns.git] / bin / mkgeo
1 #!/usr/bin/perl
2
3 use v5.12;
4
5 use strict;
6 use warnings;
7
8 use IO::File;
9 use Math::Trig qw(deg2rad pip2 great_circle_distance);
10 use JSON::XS;
11 use LWP::UserAgent;
12 use YAML;
13
14 my $originfile = shift @ARGV;
15 my $clusterfile = shift @ARGV;
16 my $zone = shift @ARGV;
17 my $jszone = shift @ARGV;
18 my $targetoriginfile = shift @ARGV;
19 my $origins = YAML::LoadFile($originfile);
20 my $clusters = YAML::LoadFile($clusterfile);
21 my $gdnsname = shift @ARGV;
22 my @servers;
23
24 # Initialise cluster details
25 while (my($name,$cluster) = each %$clusters)
26 {
27     if ($cluster->{servers})
28     {
29         $cluster->{bandwidth} = 0;
30
31         foreach my $server (@{$cluster->{servers}})
32         {
33             $server->{cluster} = $cluster;
34             $cluster->{bandwidth} = $cluster->{bandwidth} + $server->{bandwidth};
35
36             push @servers, $server;
37         }
38     }
39     else
40     {
41         my $server = {
42             cluster => $cluster,
43             statuscake => $cluster->{statuscake},
44             bandwidth => $cluster->{bandwidth},
45             ipv4 => $cluster->{ipv4},
46             ipv6 => $cluster->{ipv6}
47         };
48
49         $cluster->{servers} = [ $server ];
50
51         push @servers, $server;
52     }
53
54     $cluster->{name} = $name;
55     $cluster->{status} = "down";
56 }
57
58 # Initialise server details
59 foreach my $server (@servers)
60 {
61     $server->{status} = "up";
62 }
63
64 # If statuscake support is enabled then check which servers are up
65 if ($ENV{STATUSCAKE_USERNAME} && $ENV{STATUSCAKE_APIKEY})
66 {
67     my $ua = LWP::UserAgent->new;
68     my $cache;
69
70     $ua->agent("mkgeo/1.0");
71     $ua->default_header("Username", $ENV{STATUSCAKE_USERNAME});
72     $ua->default_header("API", $ENV{STATUSCAKE_APIKEY});
73
74     if (-f "statuscake.yml")
75     {
76         $cache = YAML::LoadFile("statuscake.yml");
77     }
78     else
79     {
80         $cache = {};
81     }
82
83     my $response = $ua->get("https://app.statuscake.com/API/Tests/");
84
85     if ($response->is_success)
86     {
87         my $tests = decode_json($response->content);
88
89         foreach my $test (@$tests)
90         {
91             my $testid = $test->{TestID};
92
93             if ($test->{Status} eq "Up" && !$test->{Paused})
94             {
95                 $cache->{$testid} = "up";
96             }
97             else
98             {
99                 $cache->{$testid} = "down";
100             }
101         }
102     }
103
104     foreach my $server (@servers)
105     {
106         if (my $testids = $server->{statuscake})
107         {
108             $server->{status} = "up";
109
110             for my $testid (@$testids)
111             {
112                 my $testresult = $cache->{$testid} || "down";
113
114                 $server->{status} = "down" if $testresult eq "down";
115             }
116         }
117         else
118         {
119             $server->{status} = "down";
120         }
121     }
122
123     YAML::DumpFile("statuscake.yml", $cache);
124 }
125
126 # Mark a cluster as up if any servers are up
127 foreach my $server (@servers)
128 {
129     if ($server->{status} eq "up")
130     {
131         $server->{cluster}->{status} = "up";
132     }
133     else
134     {
135         $server->{cluster}->{bandwidth} = $server->{cluster}->{bandwidth} - $server->{bandwidth};
136     }
137 }
138
139 # Create target origins object
140 my $targetorigins = {};
141
142 # Initialise cluster details
143 while (my($name,$cluster) = each %$clusters)
144 {
145     $cluster->{bandwidth_limit} = $cluster->{bandwidth} * 1024 * 1024;
146     $cluster->{bandwidth_used} = 0;
147
148     $targetorigins->{$cluster->{name}} = {
149         code => $cluster->{name},
150         name => $cluster->{name},
151         lat => $cluster->{lat},
152         lon => $cluster->{lon},
153         bandwidth => 0
154     };
155 }
156
157 my @mappings = ();
158
159 # Scan origins and work out which clusters each can use
160 foreach my $origin (values %$origins)
161 {
162     foreach my $cluster (values %$clusters)
163     {
164         my $match = match_origin($cluster, $origin);
165
166         if ($cluster->{status} eq "up" && $match ne "denied")
167         {
168             my $priority = $match eq "preferred" ? 20 : 10;
169             my $distance = distance($origin->{lat}, $origin->{lon}, $cluster->{lat}, $cluster->{lon});
170
171             push @mappings, {
172                 origin => $origin, cluster => $cluster,
173                 priority => $priority, distance => $distance
174             };
175         }
176     }
177 }
178
179 # Allocate each country to a cluster
180 allocate_clusters(@mappings);
181
182 # If we failed to allocate every origin then loop, increasing
183 # the bandwidth for each cluster by a little and retrying until
184 # we manage to allocate everything
185 while (grep { !exists($_->{cluster}) } values %$origins)
186 {
187     # Clear any existing mappings of countries to clusters
188     foreach my $origin (values %$origins)
189     {
190         delete $origin->{cluster};
191     }
192
193     # Reset bandwidth usage for clusters and increase limits by 10%
194     foreach my $cluster (values %$clusters)
195     {
196         $cluster->{bandwidth_used} = 0;
197         $cluster->{bandwidth_limit} = $cluster->{bandwidth_limit} * 1.1;
198     }
199
200     # Try the allocate again
201     allocate_clusters(@mappings);
202 }
203
204 # Create JSON collection object
205 my @json;
206
207 # Open output files
208 my $zonefile = IO::File->new("> data/${zone}") || die "$!";
209 my $jszonefile = IO::File->new("> include/${jszone}.js") || die "$!";
210 my $jsonfile = IO::File->new("> json/${zone}.json") || die "$!";
211
212 # Output headers
213 $jszonefile->print("var \U${jszone}\E_RECORDS = [\n");
214
215 # Output details for each country
216 foreach my $origin (sort { $a->{name} cmp $b->{name} } values %$origins)
217 {
218     my $cluster = $origin->{cluster};
219     my $clon = $origin->{lon};
220     my $clat = $origin->{lat};
221     my $slon = $cluster->{lon};
222     my $slat = $cluster->{lat};
223
224     if ($clon > 0 && $slon < 0 && 360 + $slon - $clon < $clon - $slon)
225     {
226         $slon = $slon + 360;
227     }
228     elsif ($slon > 0 && $clon < 0 && 360 + $clon - $slon < $slon - $clon)
229     {
230         $clon = $clon + 360;
231     }
232
233     if (!defined($gdnsname))
234     {
235         $zonefile->print("# $origin->{name}\n");
236         $zonefile->print("C\L$origin->{code}\E.${zone}:$cluster->{name}.${zone}:600\n");
237
238         $jszonefile->print("  CNAME(\"\L$origin->{code}\E.${jszone}\", \"$cluster->{name}.${zone}.\", TTL(\"10m\")),\n");
239     }
240
241     push @json, {
242         type => "Feature",
243         geometry => {
244             type => "LineString",
245             coordinates => [ [ $clon, $clat ], [ $slon, $slat ] ]
246         },
247         properties => {
248             origin => $origin->{name},
249             server => $cluster->{name},
250             colour => $cluster->{colour}
251         }
252     };
253
254     $targetorigins->{$cluster->{name}}->{bandwidth} += $origin->{bandwidth};
255 }
256
257 # Skip default records if we don't need them
258 if (!defined($gdnsname))
259 {
260     # Header for default records
261     $zonefile->print("# Unknown origins\n");
262
263     # Output default records for IPs that can't be mapped to a country
264     foreach my $cluster (sort { $a->{name} cmp $b->{name} } values %$clusters)
265     {
266         my $name = $cluster->{name};
267
268         if (my $default = $cluster->{default})
269         {
270             output_server($zonefile, $jszonefile, "${default}.${zone}", "${default}.${jszone}", $cluster);
271         }
272         elsif (exists($cluster->{default}))
273         {
274             output_server($zonefile, $jszonefile, "${zone}", "${jszone}", $cluster);
275         }
276     }
277 }
278
279 # Header for underlying servers
280 $zonefile->print("# Servers\n");
281
282 # Output A records for each cluster
283 foreach my $cluster (sort { $a->{name} cmp $b->{name} } values %$clusters)
284 {
285     my $name = $cluster->{name};
286
287     output_server($zonefile, $jszonefile, "${name}.${zone}", "${name}.${jszone}", $cluster);
288
289     if (@{$cluster->{servers}} > 1)
290     {
291         output_server($zonefile, $jszonefile, "${name}-%02d.${zone}", "${name}-%02d.${jszone}", $cluster);
292     }
293 }
294
295 # Output the GeoJSON text
296 $jsonfile->print(encode_json(\@json));
297
298 # Output footers
299 $jszonefile->print("];\n");
300
301 # Close the output files
302 $jsonfile->close();
303 $jszonefile->close();
304 $zonefile->close();
305
306 # Output gdnsd configuration
307 if (defined($gdnsname))
308 {
309     my $gdnsmapfile = IO::File->new("> gdns/${gdnsname}.map") || die "$!";
310     my $gdnsresourcefile = IO::File->new("> gdns/${gdnsname}.resource") || die "$!";
311     my $gdnsweightedfile = IO::File->new("> gdns/${gdnsname}.weighted") || die "$!";
312     my $continent = "";
313
314     $gdnsmapfile->print("${gdnsname} => {\n");
315     $gdnsmapfile->print("  geoip2_db => /usr/share/GeoIP/GeoLite2-Country.mmdb\n");
316     $gdnsmapfile->print("  datacenters => [" . join(",", sort(keys(%$clusters))) . "]\n");
317     $gdnsmapfile->print("  map => {\n");
318     $gdnsmapfile->print("    default => [" . join(",", sort(map { $_->{name} } grep { $_->{default} } values(%$clusters))) . "]\n");
319
320     foreach my $origin (sort { $a->{continent} cmp $b->{continent} || $a->{code} cmp $b->{code} } values %$origins)
321     {
322         my $code = $origin->{code};
323         my $cluster = $origin->{cluster}->{name};
324
325         next if $code eq "XK";
326
327         if ($continent ne $origin->{continent})
328         {
329             $gdnsmapfile->print("    }\n") if $continent;
330
331             $continent = $origin->{continent};
332
333             $gdnsmapfile->print("    ${continent} => {\n");
334         }
335
336         $gdnsmapfile->print("      ${code} => [${cluster}]\n");
337     }
338
339     $gdnsmapfile->print("    }\n") if $continent;
340
341     $gdnsmapfile->print("  }\n");
342     $gdnsmapfile->print("}\n");
343
344     $gdnsresourcefile->print("${gdnsname} => {\n");
345     $gdnsresourcefile->print("  map => ${gdnsname}\n");
346     $gdnsresourcefile->print("  dcmap => {\n");
347
348     foreach my $cluster (sort { $a->{name} cmp $b->{name} } values %$clusters)
349     {
350         my $name = $cluster->{name};
351
352         if (@{$cluster->{servers}} > 1)
353         {
354             $gdnsweightedfile->print("${name} => {\n");
355
356             while (my($index,$server) = each @{$cluster->{servers}})
357             {
358                 if ($server->{status} eq "up")
359                 {
360                     my $number = sprintf("%02d", $index + 1);
361                     my $bandwidth = $server->{bandwidth};
362
363                     $gdnsweightedfile->print("  ${name}-${number} = [ ${name}-${number}.${zone}., ${bandwidth} ]\n");
364                 }
365             }
366
367             $gdnsweightedfile->print("}\n");
368
369             $gdnsresourcefile->print("    ${name} => %weighted!${name}\n");
370         }
371         else
372         {
373             $gdnsresourcefile->print("    ${name} => ${name}.${zone}.\n");
374         }
375     }
376
377     $gdnsresourcefile->print("  }\n");
378     $gdnsresourcefile->print("}\n");
379
380     $gdnsweightedfile->close();
381     $gdnsresourcefile->close();
382     $gdnsmapfile->close();
383 }
384
385 # Output the target details in origin format if required
386 YAML::DumpFile($targetoriginfile, $targetorigins) if $targetoriginfile;
387
388 exit 0;
389
390 #
391 # Match an origin against a cluster
392 #
393 sub match_origin
394 {
395     my $cluster = shift;
396     my $origin = shift;
397     my $match;
398
399     if ($cluster->{preferred} &&
400         $cluster->{preferred}->{origins} &&
401         grep { $_ eq $origin->{name} } @{$cluster->{preferred}->{origins}})
402     {
403         $match = "preferred";
404     }
405     elsif ($cluster->{allowed} &&
406            $cluster->{allowed}->{origins} &&
407            grep { $_ eq $origin->{name} } @{$cluster->{allowed}->{origins}})
408     {
409         $match = "allowed";
410     }
411     elsif ($cluster->{preferred} &&
412            $cluster->{preferred}->{countries} &&
413            grep { $_ eq $origin->{country} } @{$cluster->{preferred}->{countries}})
414     {
415         $match = "preferred";
416     }
417     elsif ($cluster->{allowed} &&
418            $cluster->{allowed}->{countries} &&
419            grep { $_ eq $origin->{country} } @{$cluster->{allowed}->{countries}})
420     {
421         $match = "allowed";
422     }
423     elsif ($cluster->{denied} &&
424            $cluster->{denied}->{countries} &&
425            grep { $_ eq $origin->{country} } @{$cluster->{denied}->{countries}})
426     {
427         $match = "denied";
428     }
429     elsif ($cluster->{preferred} &&
430            $cluster->{preferred}->{continents} &&
431            grep { $_ eq $origin->{continent} } @{$cluster->{preferred}->{continents}})
432     {
433         $match = "preferred";
434     }
435     elsif ($cluster->{allowed} &&
436            $cluster->{allowed}->{continents} &&
437            grep { $_ eq $origin->{continent} } @{$cluster->{allowed}->{continents}})
438     {
439         $match = "allowed";
440     }
441     elsif ($cluster->{denied} &&
442            $cluster->{denied}->{continents} &&
443            grep { $_ eq $origin->{continent} } @{$cluster->{denied}->{continents}})
444     {
445         $match = "denied";
446     }
447     elsif ($cluster->{allowed})
448     {
449         $match = "denied";
450     }
451     else
452     {
453         $match = "allowed";
454     }
455
456     return $match;
457 }
458
459 #
460 # Compute the great circle distance between two points
461 #
462 sub distance
463 {
464     my $lat1 = deg2rad(shift);
465     my $lon1 = deg2rad(shift);
466     my $lat2 = deg2rad(shift);
467     my $lon2 = deg2rad(shift);
468
469     return great_circle_distance($lon1, pip2 - $lat1, $lon2, pip2 - $lat2);
470 }
471
472 #
473 # Allocate each origin to a cluster
474 #
475 sub allocate_clusters
476 {
477     my @mappings = sort { compare_mappings($a, $b) } @_;
478
479     # Loop over the mappings, trying to assign each origin to the
480     # nearest cluster, but subject to the bandwidth limits
481     while (my $mapping = shift @mappings)
482     {
483         my @group;
484
485         push @group, $mapping;
486
487         while (@mappings && compare_mappings($mapping, $mappings[0]) == 0)
488         {
489             push @group, shift @mappings;
490         }
491
492         for my $mapping (sort compare_bandwidth @group)
493         {
494             my $origin = $mapping->{origin};
495             my $cluster = $mapping->{cluster};
496
497             if (!exists($origin->{cluster}) &&
498                 $cluster->{bandwidth_used} + $origin->{bandwidth} <= $cluster->{bandwidth_limit})
499             {
500                 $origin->{cluster} = $cluster;
501                 $cluster->{bandwidth_used} = $cluster->{bandwidth_used} + $origin->{bandwidth};
502             }
503         }
504     }
505
506     return;
507 }
508
509 #
510 # Compare two mappings to decide which to use
511 #
512 sub compare_mappings
513 {
514     my $a = shift;
515     my $b = shift;
516
517     return $b->{priority} <=> $a->{priority} ||
518            $a->{distance} <=> $b->{distance};
519 }
520
521 #
522 # Compare two mappings to decide which to try first
523 #
524 sub compare_bandwidth
525 {
526     my $a_used = ( $a->{cluster}->{bandwidth_used} * 100.0 ) / ( $a->{cluster}->{bandwidth_limit} * 1.0 );
527     my $b_used = ( $b->{cluster}->{bandwidth_used} * 100.0 ) / ( $b->{cluster}->{bandwidth_limit} * 1.0 );
528
529     return $a_used <=> $b_used;
530 }
531
532 #
533 # Output DNS records for a server
534 #
535 sub output_server
536 {
537     my $zonefile = shift;
538     my $jszonefile = shift;
539     my $name = shift;
540     my $jsname = shift;
541     my $cluster = shift;
542
543     while (my($index,$server) = each @{$cluster->{servers}})
544     {
545         if ($server->{status} eq "up")
546         {
547             $zonefile->printf("+${name}:$server->{ipv4}:600\n", $index + 1);
548             $jszonefile->printf("  A(\"${jsname}\", \"$server->{ipv4}\", TTL(\"10m\")),\n", $index + 1);
549
550             if ($server->{ipv6})
551             {
552                 my $ipv6 = $server->{ipv6};
553
554                 $ipv6 =~ s/([0-9a-f]{4})(?=.)/$1:/ig;
555
556                 $zonefile->printf("3${name}:$server->{ipv6}:600\n", $index + 1);
557                 $jszonefile->printf("  AAAA(\"${jsname}\", \"${ipv6}\", TTL(\"10m\")),\n", $index + 1);
558             }
559         }
560     }
561
562     return;
563 }