use YAML;
# Get arguments
-my $bandwidthfile = shift @ARGV;
+my $requestsfile = shift @ARGV;
my $originsfile = shift @ARGV;
# Initialise origins
# Parse the country database
$countries->parsefile("lib/countries.xml");
-# Load the per-country bandwidth details
-my $bandwidth = YAML::LoadFile($bandwidthfile);
+# Load the per-country requests details
+my $requests = YAML::LoadFile($requestsfile);
# Fill in country table and work out which clusters each can use
foreach my $country ($countries->look_down("_tag" => "country"))
my $code = $country->look_down("_tag" => "countryCode")->as_text;
my $name = $country->look_down("_tag" => "countryName")->as_text;
my $population = $country->look_down("_tag" => "population")->as_text;
- my $bandwidth = $bandwidth->{$code} || 0;
+ my $requests = $requests->{$code} || 0;
my $continent = $country->look_down("_tag" => "continent")->as_text;
my $west = $country->look_down("_tag" => "west")->as_text;
my $north = $country->look_down("_tag" => "north")->as_text;
$origins->{$code} = {
code => $code, name => $name,
country => $code, continent => $continent,
- bandwidth => $bandwidth, lat => $lat, lon => $lon
+ requests => $requests, lat => $lat, lon => $lon
};
}
{
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;
}
my $server = {
cluster => $cluster,
statuscake => $cluster->{statuscake},
- bandwidth => $cluster->{bandwidth},
+ requests => $cluster->{requests},
cname => $cluster->{cname},
ipv4 => $cluster->{ipv4},
ipv6 => $cluster->{ipv6}
}
else
{
- $server->{cluster}->{bandwidth} = $server->{cluster}->{bandwidth} - $server->{bandwidth};
+ $server->{cluster}->{requests} = $server->{cluster}->{requests} - $server->{requests};
}
}
# 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};
name => $cluster->{name},
lat => $cluster->{lat},
lon => $cluster->{lon},
- bandwidth => 0
+ requests => 0
};
}
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)
{
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
next if $cluster->{global};
- $targetorigins->{$cluster->{name}}->{bandwidth} += $origin->{bandwidth};
+ $targetorigins->{$cluster->{name}}->{requests} += $origin->{requests};
}
# Skip default records if we don't need them
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");
}
}
}
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;
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};
}
}
}
#
# 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;
}
projects / dns.git / commitdiff