X-Git-Url: https://git.openstreetmap.org./dns.git/blobdiff_plain/503291e69b63d53cc039c66278cea6cee91aad75..51bc98fe8f5eab33f04cf60b456ae0e55b2246c7:/bin/mkgeo

diff --git a/bin/mkgeo b/bin/mkgeo
index c89921e..9a36ae2 100755
--- a/bin/mkgeo
+++ b/bin/mkgeo
@@ -25,22 +25,22 @@ while (my($name,$cluster) = each %$clusters)
 {
     if ($cluster->{servers})
     {
-        $cluster->{bandwidth} = 0;
+        $cluster->{requests} = 0;
 
         foreach my $server (@{$cluster->{servers}})
         {
             $server->{cluster} = $cluster;
-            $cluster->{bandwidth} = $cluster->{bandwidth} + $server->{bandwidth};
+            $cluster->{requests} = $cluster->{requests} + $server->{requests};
 
             push @servers, $server;
         }
     }
-    else
+    elsif ($cluster->{requests} > 0)
     {
         my $server = {
             cluster => $cluster,
             statuscake => $cluster->{statuscake},
-            bandwidth => $cluster->{bandwidth},
+            requests => $cluster->{requests},
             cname => $cluster->{cname},
             ipv4 => $cluster->{ipv4},
             ipv6 => $cluster->{ipv6}
@@ -50,6 +50,10 @@ while (my($name,$cluster) = each %$clusters)
 
         push @servers, $server;
     }
+    else
+    {
+        $cluster->{servers} = [];
+    }
 
     $cluster->{name} = $name;
     $cluster->{status} = "down";
@@ -62,14 +66,13 @@ foreach my $server (@servers)
 }
 
 # If statuscake support is enabled then check which servers are up
-if ($ENV{STATUSCAKE_USERNAME} && $ENV{STATUSCAKE_APIKEY})
+if ($ENV{STATUSCAKE_APIKEY})
 {
     my $ua = LWP::UserAgent->new;
     my $cache;
 
     $ua->agent("mkgeo/1.0");
-    $ua->default_header("Username", $ENV{STATUSCAKE_USERNAME});
-    $ua->default_header("API", $ENV{STATUSCAKE_APIKEY});
+    $ua->default_header("Authorization", "Bearer $ENV{STATUSCAKE_APIKEY}");
 
     if (-f "statuscake.yml")
     {
@@ -80,24 +83,33 @@ if ($ENV{STATUSCAKE_USERNAME} && $ENV{STATUSCAKE_APIKEY})
         $cache = {};
     }
 
-    my $response = $ua->get("https://app.statuscake.com/API/Tests/");
+    my $page = 1;
+    my $pages = 1;
 
-    if ($response->is_success)
+    while ($page <= $pages)
     {
-        my $tests = decode_json($response->content);
+        my $response = $ua->get("https://api.statuscake.com/v1/uptime?nouptime=true&limit=100&page=${page}");
 
-        foreach my $test (@$tests)
+        if ($response->is_success)
         {
-            my $testid = $test->{TestID};
+            my $uptime = decode_json($response->content);
 
-            if ($test->{Status} eq "Up" && !$test->{Paused})
-            {
-                $cache->{$testid} = "up";
-            }
-            else
+            foreach my $test (@{$uptime->{data}})
             {
-                $cache->{$testid} = "down";
+                my $testid = $test->{id};
+
+                if ($test->{status} eq "up" && !$test->{paused})
+                {
+                    $cache->{$testid} = "up";
+                }
+                else
+                {
+                    $cache->{$testid} = "down";
+                }
             }
+
+            $page = $page + 1;
+            $pages = $uptime->{metadata}->{page_count};
         }
     }
 
@@ -133,7 +145,7 @@ foreach my $server (@servers)
     }
     else
     {
-        $server->{cluster}->{bandwidth} = $server->{cluster}->{bandwidth} - $server->{bandwidth};
+        $server->{cluster}->{requests} = $server->{cluster}->{requests} - $server->{requests};
     }
 }
 
@@ -143,15 +155,17 @@ my $targetorigins = {};
 # Initialise cluster details
 while (my($name,$cluster) = each %$clusters)
 {
-    $cluster->{bandwidth_limit} = $cluster->{bandwidth} * 1024 * 1024;
-    $cluster->{bandwidth_used} = 0;
+    $cluster->{requests_limit} = $cluster->{requests};
+    $cluster->{requests_used} = 0;
+
+    next if $cluster->{global};
 
     $targetorigins->{$cluster->{name}} = {
         code => $cluster->{name},
         name => $cluster->{name},
         lat => $cluster->{lat},
         lon => $cluster->{lon},
-        bandwidth => 0
+        requests => 0
     };
 }
 
@@ -190,7 +204,7 @@ foreach my $origin (values %$origins)
 allocate_clusters(@mappings);
 
 # If we failed to allocate every origin then loop, increasing
-# the bandwidth for each cluster by a little and retrying until
+# the requests for each cluster by a little and retrying until
 # we manage to allocate everything
 while (grep { !exists($_->{cluster}) } values %$origins)
 {
@@ -200,17 +214,36 @@ while (grep { !exists($_->{cluster}) } values %$origins)
         delete $origin->{cluster};
     }
 
-    # Reset bandwidth usage for clusters and increase limits by 10%
+    # Reset requests usage for clusters and increase limits by 10%
     foreach my $cluster (values %$clusters)
     {
-        $cluster->{bandwidth_used} = 0;
-        $cluster->{bandwidth_limit} = $cluster->{bandwidth_limit} * 1.1;
+        $cluster->{requests_used} = 0;
+        $cluster->{requests_limit} = $cluster->{requests_limit} * 1.1;
     }
 
     # Try the allocate again
     allocate_clusters(@mappings);
 }
 
+# Report on allocation results
+foreach my $name (sort keys %$clusters)
+{
+    my $cluster = $clusters->{$name};
+    my $used = int($cluster->{requests_used} + 0.5);
+    my $limit = $cluster->{requests_limit};
+
+    if ($limit > 0)
+    {
+        my $proportion = int($used / $limit * 100 + 0.5);
+    
+        print "${name}: used ${used} of ${limit} (${proportion}%)\n";
+    }
+    else
+    {
+        print "${name}: used ${used} of ${limit}\n";
+    }
+}
+
 # Create JSON collection object
 my @json;
 
@@ -261,7 +294,9 @@ foreach my $origin (sort { $a->{name} cmp $b->{name} } values %$origins)
         };
     }
 
-    $targetorigins->{$cluster->{name}}->{bandwidth} += $origin->{bandwidth};
+    next if $cluster->{global};
+
+    $targetorigins->{$cluster->{name}}->{requests} += $origin->{requests};
 }
 
 # Skip default records if we don't need them
@@ -363,15 +398,15 @@ if (defined($gdnsname))
                 if ($server->{status} eq "up")
                 {
                     my $number = sprintf("%02d", $index + 1);
-                    my $bandwidth = $server->{bandwidth};
+                    my $requests = $server->{requests};
 
                     if (my $cname = $server->{cname})
                     {
-                        $gdnsweightedfile->print("  ${name}-${number} = [ ${cname}., ${bandwidth} ]\n");
+                        $gdnsweightedfile->print("  ${name}-${number} = [ ${cname}., ${requests} ]\n");
                     }
                     else
                     {
-                        $gdnsweightedfile->print("  ${name}-${number} = [ ${name}-${number}.${zone}.openstreetmap.org., ${bandwidth} ]\n");
+                        $gdnsweightedfile->print("  ${name}-${number} = [ ${name}-${number}.${zone}.openstreetmap.org., ${requests} ]\n");
                     }
                 }
             }
@@ -493,7 +528,7 @@ sub allocate_clusters
     my @mappings = sort { compare_mappings($a, $b) } @_;
 
     # Loop over the mappings, trying to assign each origin to the
-    # nearest cluster, but subject to the bandwidth limits
+    # nearest cluster, but subject to the request limits
     while (my $mapping = shift @mappings)
     {
         my @group;
@@ -505,16 +540,16 @@ sub allocate_clusters
             push @group, shift @mappings;
         }
 
-        for my $mapping (sort compare_bandwidth @group)
+        for my $mapping (sort compare_requests @group)
         {
             my $origin = $mapping->{origin};
             my $cluster = $mapping->{cluster};
 
             if (!exists($origin->{cluster}) &&
-                $cluster->{bandwidth_used} + $origin->{bandwidth} <= $cluster->{bandwidth_limit})
+                $cluster->{requests_used} + $origin->{requests} <= $cluster->{requests_limit})
             {
                 $origin->{cluster} = $cluster;
-                $cluster->{bandwidth_used} = $cluster->{bandwidth_used} + $origin->{bandwidth};
+                $cluster->{requests_used} = $cluster->{requests_used} + $origin->{requests};
             }
         }
     }
@@ -537,10 +572,10 @@ sub compare_mappings
 #
 # Compare two mappings to decide which to try first
 #
-sub compare_bandwidth
+sub compare_requests
 {
-    my $a_used = ( $a->{cluster}->{bandwidth_used} * 100.0 ) / ( $a->{cluster}->{bandwidth_limit} * 1.0 );
-    my $b_used = ( $b->{cluster}->{bandwidth_used} * 100.0 ) / ( $b->{cluster}->{bandwidth_limit} * 1.0 );
+    my $a_used = ( $a->{cluster}->{requests_used} * 100.0 ) / ( $a->{cluster}->{requests_limit} * 1.0 );
+    my $b_used = ( $b->{cluster}->{requests_used} * 100.0 ) / ( $b->{cluster}->{requests_limit} * 1.0 );
 
     return $a_used <=> $b_used;
 }