1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
#!/usr/bin/env raku
use v6.d;
subset Nat of Int where * >= 0;
subset Cat of Str where * eq any <host os os-major uname>;
subset SubCat of Str where * eq any <boots uptime downtime lifespan meta-score>;
subset HostOnlyCat of Cat where * eq 'host';
subset BasicSubCat of SubCat where * ne any <downtime lifespan>;
class Epoch {
our Nat constant DAY = 1 * 24 * 3600;
our Nat constant MONTH = 30 * DAY;
has Nat $.value is required;
submethod new (Nat $value) { self.bless(:$value) }
method duration returns Str {
my DateTime \dt .= new(Instant.from-posix: $!value);
"{dt.year-1970} years, {dt.month} months, {dt.day} days";
}
method date returns Str {
DateTime.new(Instant.from-posix: $!value).yyyy-mm-dd;
}
method newer-than(Nat:D \limit) returns Bool {
(DateTime.now - DateTime.new(Instant.from-posix: $!value)) < limit * DAY;
}
}
class Aggregate {
has Str $.name is required;
has Nat $.uptime;
has Nat $.first-boot;
has Nat $.last-seen;
has Nat $.boots;
method add-record(Str:D :$uptime is readonly, Str:D :$boot-time is readonly) {
my Int $last-seen = $uptime + $boot-time;
$!uptime += $uptime;
$!boots++;
$!first-boot = +$boot-time if not defined $!first-boot or $!first-boot > $boot-time;
$!last-seen = $last-seen if not defined $!last-seen or $!last-seen < $last-seen;
}
method meta-score returns Nat {
Nat((($!uptime * 2) + ($!boots * Epoch.DAY) + (self.is-active ?? Epoch.MONTH !! 0))/1000000)
}
method is-active(Nat:D \limit = 90) returns Bool {
Epoch.new($!last-seen).newer-than: limit;
}
}
class HostAggregate is Aggregate {
method lifespan returns Nat { $.last-seen - $.first-boot }
method downtime returns Nat { self.lifespan - $.uptime }
method meta-score returns Nat { self.downtime + callsame }
}
class Aggregator {
has Hash %.aggregates = { host => {}, os => {}, uname => {}, os-major => {} }
method add-file(IO::Path:D $file is readonly) {
my Str $host = $file.IO.basename.split('.').first;
die "Record file for {$host} already processed - duplicate inputs?"
if %!aggregates<host>{$host}:exists;
%!aggregates<host>{$host} = HostAggregate.new: :name($host);
for $file.IO.lines -> Str $line { self!add-line(:$line, :$host) }
}
method !add-line(Str:D :$line is readonly, Str:D :$host is readonly) {
my Str ($uptime, $boot-time, $os) = $line.trim.split(':');
my Str $uname = $os.split(' ').first;
my Str $os-major = "$uname {$os.split(' ')[1].split('.').first}...";
%!aggregates<os>{$os} //= Aggregate.new: :name($os);
%!aggregates<uname>{$uname} //= Aggregate.new: :name($uname);
%!aggregates<os-major>{$os-major} //= Aggregate.new: :name($os-major);
for %!aggregates<host>{$host}, %!aggregates<os>{$os},
%!aggregates<uname>{$uname}, %!aggregates<os-major>{$os-major} {
.add-record(:$uptime, :$boot-time);
}
}
}
class Reporter {
has Cat $.cat is required;
has SubCat $.sub-cat is required;
has Hash %.aggregates;
method report {
for self.sort-by($!sub-cat) -> $what {
$what.raku.say;
$what.is-active.say;
}
}
multi method sort-by('uptime') { self.sort-by: *.uptime }
multi method sort-by('boots') { self.sort-by: *.boots }
multi method sort-by('meta-score') { self.sort-by: *.meta-score }
multi method sort-by(Code:D $sort-by) {
%!aggregates{$!cat}.values.sort(&$sort-by).reverse;
}
}
class HostReporter is Reporter {
multi method sort-by('downtime') { self.sort-by: *.downtime }
multi method sort-by('lifespan') { self.sort-by: *.lifespan }
}
sub do-it(Str:D \stats-dir, Reporter:D \reporter) {
my Aggregator \aggregator .= new;
aggregator.add-file($_) for dir(stats-dir, test => { /.records$/ });
reporter.aggregates = aggregator.aggregates;
reporter.report;
}
multi MAIN(
Str :$stats-dir is required, #= The uptimed raw record input dir.
HostOnlyCat :$cat = 'host', #= Category, one of host, os os-major and uname.
SubCat :$sub-cat = 'uptime', #= Sort by one of boots uptime downtime and lifespan.
) {
do-it($stats-dir, HostReporter.new(:$cat, :$sub-cat));
}
multi MAIN(
Str :$stats-dir is required,
Cat :$cat,
BasicSubCat :$sub-cat = 'uptime',
) {
do-it($stats-dir, Reporter.new(:$cat, :$sub-cat));
}
|
