K8s/Permissions.pm

filter: Statementstmt 96.5% 167 / 173 Branchbran 80.7% 63 / 78 Conditioncond 53.6% 37 / 69 MC/DCmcdc 29.7% 11 / 37 Subroutinesub 100% 16 / 16 Podpod 85.7% 6 / 7 totaltotal 78.9% 300 / 380 CC 84 SCAR 25.9
CC
84
Cov
83%
allowed_resources
20.9
can_read_logs
18.2
summary
16.7
CRAP 13.4
« K8s.pm ↑ Summary Kubernetes.pm »
1 package MCP::K8s::Permissions;
2 # ABSTRACT: RBAC discovery and permission checking for Kubernetes
3 12 our $VERSION = '0.004';
4 12 ▶use Moo;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 12 ▶use Carp qw( croak );
Subroutine BEGIN: called CC=1 SCAR=0.0
6 12 ▶use Scalar::Util qw( weaken );
Subroutine BEGIN: called CC=1 SCAR=0.0
7 12 ▶use namespace::clean;
Subroutine BEGIN: called CC=1 SCAR=0.0
8  
9  
10 12 has api => (
11 is => 'ro',
12 required => 1,
13 weak_ref => 1,
14 );
15  
16  
17 12 has namespaces => (
18 is => 'ro',
19 required => 1,
20 );
21  
22  
23 12 has scope_resolver => (
24 is => 'ro',
25 predicate => 1,
26 );
27  
28  
29 has _rules => (
30 is => 'rw',
31 49 ▶ default => sub { {} },
Subroutine __ANON__: called CC=1 SCAR=0.0
32 12 );
33  
34 12 has _discovered => (
35 is => 'rw',
36 default => 0,
37 );
38  
39 49 ▶sub discover {
Subroutine discover: called CC=5 SCAR=16.2
Pod documented
40 49 my ($self) = @_;
41  
42  
43 49 my %rules;
44 my %reviewed;
45  
46 49 for my $ns (@{ $self->namespaces }) {
47 61 my $ns_rules = eval { $self->_discover_namespace($ns) };
48 61 ▶ if ($@) {
Branch: 1 branch
BranchTrueFalseTotal
if ($@) 0 61 61
49 0 warn "Failed to discover permissions for namespace '$ns': $@";
50 0 next;
51 }
52 61 $reviewed{$ns} = $ns_rules;
53 61 ▶ $rules{$ns} = $ns_rules if keys %$ns_rules;
Branch: 1 branch
BranchTrueFalseTotal
if keys %$ns_rules 57 4 61
54 }
55  
56 49 my $cluster_rules = $self->_cluster_rules(\%reviewed);
57 49 ▶ $rules{''} = $cluster_rules if keys %$cluster_rules;
Branch: 1 branch
BranchTrueFalseTotal
if keys %$cluster_rules 43 6 49
58  
59 49 $self->_rules(\%rules);
60 49 $self->_discovered(1);
61 49 return $self;
62 }
63  
64 49 ▶sub _cluster_rules {
Subroutine _cluster_rules: called CC=13 SCAR=25.7
65 49 my ($self, $reviewed) = @_;
66  
67 49 my @maps = values %$reviewed;
68 49 ▶ return {} unless @maps;
Branch: 1 branch
BranchTrueFalseTotal
unless @maps 0 49 49
69  
70 # Every (resource, verb) pair any of the namespaces knows about.
71 49 my %pairs;
72 49 for my $map (@maps) {
73 61 for my $resource (keys %$map) {
74 224 $pairs{$resource}{$_} = 1 for keys %{ $map->{$resource} };
75 }
76 }
77  
78 # Of those, the ones every namespace knows about too. The wildcard rules
79 # are read the way can_do reads them, so a namespace holding "*" covers
80 # the explicit pairs the other namespaces bring.
81 49 my %cluster;
82 49 for my $resource (sort keys %pairs) {
83 201 for my $verb (sort keys %{ $pairs{$resource} }) {
84 609 my $everywhere = 1;
85 609 for my $map (@maps) {
86 754 ▶ unless ($self->_map_allows($map, $resource, $verb)) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->_map_allows($map, $resource, $verb)) 120 634 754
87 120 $everywhere = 0;
88 120 last;
89 }
90 }
91 609 ▶ next unless $everywhere;
Branch: 1 branch
BranchTrueFalseTotal
unless $everywhere 120 489 609
92  
93 # A namespaced resource is never cluster-scoped, whatever the rules
94 # say. The wildcard carries no scope of its own and stays.
95 489 ▶ if ($resource ne '*') {
Branch: 1 branch
BranchTrueFalseTotal
if ($resource ne "*") 425 64 489
96 425 my $scope = $self->_scope_of($resource);
97 425 ▶ next if defined $scope && $scope;
Branch: 1 branch
BranchTrueFalseTotal
if defined $scope and $scope 199 226 425
Condition100%3/3
defined $scope and $scope
!ll&&!rl&&r
18442199
MC/DC100%2/2
defined $scope and $scope
defined $scope $scope
Truth table100%3/3
A and B
A= defined $scopeB= $scope
ABresult
0X0
100
111
98 }
99  
100 290 $cluster{$resource}{$verb} = 1;
101 }
102 }
103  
104 49 return \%cluster;
105 }
106  
107 425 ▶sub _scope_of {
Subroutine _scope_of: called CC=3 SCAR=11.0
108 425 my ($self, $plural) = @_;
109  
110 425 ▶ my $resolver = $self->scope_resolver or return undef;
Branch: 1 branch
BranchTrueFalseTotal
my $resolver = $self->scope_resolver or return undef 400 25 425
111 400 my $scope = eval { $resolver->($plural) };
112 400 ▶ return $@ ? undef : $scope;
Branch: 1 branch
BranchTrueFalseTotal
$@ ? : 0 400 400
113 }
114  
115 61 ▶sub _discover_namespace {
Subroutine _discover_namespace: called CC=14 SCAR=26.7
116 61 my ($self, $namespace) = @_;
117  
118 61 my $review = $self->api->new_object('SelfSubjectRulesReview', {
119 spec => {
120 namespace => $namespace,
121 },
122 });
123  
124 61 my $result = $self->api->create($review);
125 61 my $status = $result->status;
126 61 ▶ return {} unless $status;
Branch: 1 branch
BranchTrueFalseTotal
unless $status 0 61 61
127  
128 61 my %ns_rules;
129 61 ▶ my $resource_rules = $status->resourceRules // [];
Condition50%1/2
$status->resourceRules // []
l!l
610
MC/DC0%0/1
$status->resourceRules // []
$status->resourceRules
Truth table50%1/2
A
A= $status->resourceRules
Aresult
11
00
130  
131 61 for my $rule (@$resource_rules) {
132 154 ▶ my @verbs = @{ $rule->verbs // [] };
Condition50%1/2
$rule->verbs // []
l!l
1540
MC/DC0%0/1
$rule->verbs // []
$rule->verbs
Truth table50%1/2
A
A= $rule->verbs
Aresult
11
00
133 154 ▶ my @resources = @{ $rule->resources // [] };
Condition50%1/2
$rule->resources // []
l!l
1540
MC/DC0%0/1
$rule->resources // []
$rule->resources
Truth table50%1/2
A
A= $rule->resources
Aresult
11
00
134  
135 154 for my $resource (@resources) {
136 # Subresources (pods/log, deployments/status, ...) are kept. RBAC treats
137 # them as resources in their own right — patch on 'deployments' does not
138 # grant patch on 'deployments/status' — so can_do has to be able to see
139 # them, or a correctly narrow Role gets a false denial. They can never
140 # collide with a base plural: a subresource name always contains '/'.
141 # Filtering happens on the presentation side instead, in
142 # L</allowed_resources>, which is what feeds the tool descriptions.
143 230 for my $verb (@verbs) {
144 564 $ns_rules{$resource}{$verb} = 1;
145 # Wildcard verb means all standard verbs
146 564 ▶ if ($verb eq '*') {
Branch: 1 branch
BranchTrueFalseTotal
if ($verb eq "*") 12 552 564
147 12 $ns_rules{$resource}{$_} = 1 for qw(get list watch create update patch delete);
148 }
149 }
150 }
151  
152 # Wildcard resource means all resources for these verbs
153 154 ▶ if (grep { $_ eq '*' } @resources) {
Branch: 1 branch
BranchTrueFalseTotal
if (grep {$_ eq "*";} @resources) 10 144 154
154 10 for my $verb (@verbs) {
155 10 $ns_rules{'*'}{$verb} = 1;
156 10 ▶ if ($verb eq '*') {
Branch: 1 branch
BranchTrueFalseTotal
if ($verb eq "*") 10 0 10
157 10 $ns_rules{'*'}{$_} = 1 for qw(get list watch create update patch delete);
158 }
159 }
160 }
161 }
162  
163 61 return \%ns_rules;
164 }
165  
166 196 ▶sub ensure_discovered {
Subroutine ensure_discovered: called CC=2 SCAR=6.9
Pod undocumented
167 196 my ($self) = @_;
168 196 ▶ return $self if $self->_discovered;
Branch: 1 branch
BranchTrueFalseTotal
if $self->_discovered 187 9 196
169 9 return $self->discover;
170 }
171  
172 113 ▶sub can_do {
Subroutine can_do: called CC=4 SCAR=13.9
Pod documented
173 113 my ($self, $verb, $resource_plural, $namespace) = @_;
174  
175  
176 113 $self->ensure_discovered;
177 113 ▶ $namespace //= '';
Condition50%1/2
$namespace //= ""
l!l
1130
MC/DC0%0/1
$namespace //= ""
$namespace
Truth table50%1/2
A
A= $namespace
Aresult
11
00
178  
179 113 my $ns_rules = $self->_rules->{$namespace};
180 113 ▶ return 0 unless $ns_rules;
Branch: 1 branch
BranchTrueFalseTotal
unless $ns_rules 12 101 113
181  
182 101 ▶ return $self->_map_allows($ns_rules, $resource_plural, $verb) ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$self->_map_allows($ns_rules, $resource_plural, $verb) ? : 78 23 101
183 }
184  
185 855 ▶sub _map_allows {
Subroutine _map_allows: called CC=9 SCAR=23.0
186 855 my ($self, $map, $resource, $verb) = @_;
187  
188 # Check explicit resource permission
189 855 ▶ return 1 if $map->{$resource} && $map->{$resource}{$verb};
Branch: 1 branch
BranchTrueFalseTotal
if $$map{$resource} and $$map{$resource}{$verb} 670 185 855
Condition100%3/3
$$map{$resource} and $$map{$resource}{$verb}
!ll&&!rl&&r
15827670
MC/DC100%2/2
$$map{$resource} and $$map{$resource}{$verb}
$$map{$resource} $$map{$resource}{$verb}
Truth table100%3/3
A and B
A= $$map{$resource}B= $$map{$resource}{$verb}
ABresult
0X0
100
111
190 # Check wildcard verb on explicit resource
191 185 ▶ return 1 if $map->{$resource} && $map->{$resource}{'*'};
Branch: 1 branch
BranchTrueFalseTotal
if $$map{$resource} and $$map{$resource}{"*"} 0 185 185
Condition66%2/3
$$map{$resource} and $$map{$resource}{"*"}
!ll&&!rl&&r
158270
MC/DC0%0/2
$$map{$resource} and $$map{$resource}{"*"}
$$map{$resource} $$map{$resource}{"*"}
Truth table66%2/3
A and B
A= $$map{$resource}B= $$map{$resource}{"*"}
ABresult
0X0
100
111
192 # Check wildcard resource
193 185 ▶ return 1 if $map->{'*'} && $map->{'*'}{$verb};
Branch: 1 branch
BranchTrueFalseTotal
if $$map{"*"} and $$map{"*"}{$verb} 42 143 185
Condition66%2/3
$$map{"*"} and $$map{"*"}{$verb}
!ll&&!rl&&r
143042
MC/DC50%1/2
$$map{"*"} and $$map{"*"}{$verb}
$$map{"*"} $$map{"*"}{$verb}
Truth table66%2/3
A and B
A= $$map{"*"}B= $$map{"*"}{$verb}
ABresult
0X0
100
111
194 143 ▶ return 1 if $map->{'*'} && $map->{'*'}{'*'};
Branch: 1 branch
BranchTrueFalseTotal
if $$map{"*"} and $$map{"*"}{"*"} 0 143 143
Condition33%1/3
$$map{"*"} and $$map{"*"}{"*"}
!ll&&!rl&&r
14300
MC/DC0%0/2
$$map{"*"} and $$map{"*"}{"*"}
$$map{"*"} $$map{"*"}{"*"}
Truth table33%1/3
A and B
A= $$map{"*"}B= $$map{"*"}{"*"}
ABresult
0X0
100
111
195  
196 143 return 0;
197 }
198  
199 22 ▶sub allowed_resources {
Subroutine allowed_resources: called CC=15 SCAR=30.4
Pod documented
200 22 my ($self, $verb, $namespace) = @_;
201  
202  
203 22 $self->ensure_discovered;
204 22 ▶ $namespace //= '';
Condition50%1/2
$namespace //= ""
l!l
220
MC/DC0%0/1
$namespace //= ""
$namespace
Truth table50%1/2
A
A= $namespace
Aresult
11
00
205  
206 22 my $ns_rules = $self->_rules->{$namespace};
207 22 ▶ return () unless $ns_rules;
Branch: 1 branch
BranchTrueFalseTotal
unless $ns_rules 0 22 22
208  
209 22 my @resources;
210 22 for my $resource (sort keys %$ns_rules) {
211 153 ▶ next if $resource eq '*';
Branch: 1 branch
BranchTrueFalseTotal
if $resource eq "*" 1 152 153
212 152 ▶ next if $resource =~ m{/}; # skip subresources
Branch: 1 branch
BranchTrueFalseTotal
if $resource =~ m[/] 21 131 152
213 131 ▶ if ($ns_rules->{$resource}{$verb}
Branch: 1 branch
BranchTrueFalseTotal
if ($$ns_rules{$resource}{$verb} or $$ns_rules{$resource}{"*"} or $$ns_rules{"*"} and $$ns_rules{"*"}{$verb} || $$ns_rules{"*"}{"*"}) 122 9 131
Condition41%5/12
$$ns_rules{$resource}{$verb} or $$ns_rules{$resource}{"*"} or $$ns_rules{"*"} and $$ns_rules{"*"}{$verb} || $$ns_rules{"*"}{"*"}
l!l&&r!l&&!r
12209
$$ns_rules{$resource}{$verb} or $$ns_rules{$resource}{"*"}
l!l&&r!l&&!r
12209
$$ns_rules{"*"} and $$ns_rules{"*"}{$verb} || $$ns_rules{"*"}{"*"}
!ll&&!rl&&r
900
$$ns_rules{"*"}{$verb} or $$ns_rules{"*"}{"*"}
l!l&&r!l&&!r
000
MC/DC20%1/5
$$ns_rules{$resource}{$verb} or $$ns_rules{$resource}{"*"} or $$ns_rules{"*"} and $$ns_rules{"*"}{$verb} || $$ns_rules{"*"}{"*"}
$$ns_rules{$resource}{$verb} $$ns_rules{$resource}{"*"} $$ns_rules{"*"} $$ns_rules{"*"}{$verb} $$ns_rules{"*"}{"*"}
Truth table33%2/6
A or B or C and D or E
A= $$ns_rules{$resource}{$verb}B= $$ns_rules{$resource}{"*"}C= $$ns_rules{"*"}D= $$ns_rules{"*"}{$verb}E= $$ns_rules{"*"}{"*"}
ABCDEresult
1XXXX1
01XXX1
0011X1
001011
000XX0
001000
214 || $ns_rules->{$resource}{'*'}
215 || ($ns_rules->{'*'} && ($ns_rules->{'*'}{$verb} || $ns_rules->{'*'}{'*'}))) {
216 122 push @resources, $resource;
217 }
218 }
219  
220 # If wildcard resource is allowed, indicate that
221 22 ▶ if ($ns_rules->{'*'} && ($ns_rules->{'*'}{$verb} || $ns_rules->{'*'}{'*'})) {
Branch: 1 branch
BranchTrueFalseTotal
if ($$ns_rules{"*"} and $$ns_rules{"*"}{$verb} || $$ns_rules{"*"}{"*"}) 1 21 22
Condition50%3/6
$$ns_rules{"*"} and $$ns_rules{"*"}{$verb} || $$ns_rules{"*"}{"*"}
!ll&&!rl&&r
2101
$$ns_rules{"*"}{$verb} or $$ns_rules{"*"}{"*"}
l!l&&r!l&&!r
100
MC/DC33%1/3
$$ns_rules{"*"} and $$ns_rules{"*"}{$verb} || $$ns_rules{"*"}{"*"}
$$ns_rules{"*"} $$ns_rules{"*"}{$verb} $$ns_rules{"*"}{"*"}
Truth table50%2/4
A and B or C
A= $$ns_rules{"*"}B= $$ns_rules{"*"}{$verb}C= $$ns_rules{"*"}{"*"}
ABCresult
0XX0
1000
11X1
1011
222 0 ▶ unshift @resources, '*' unless grep { $_ eq '*' } @resources;
Branch: 1 branch
BranchTrueFalseTotal
unless grep {$_ eq "*";} @resources 1 0 1
223 }
224  
225 22 return @resources;
226 }
227  
228 40 ▶sub allowed_namespaces {
Subroutine allowed_namespaces: called CC=1 SCAR=0.0
Pod documented
229 40 my ($self) = @_;
230  
231  
232 40 $self->ensure_discovered;
233 40 return grep { $_ ne '' } sort keys %{ $self->_rules };
234 }
235  
236 12 ▶sub can_read_logs {
Subroutine can_read_logs: called CC=12 SCAR=29.0
Pod documented
237 12 my ($self, $namespace) = @_;
238  
239  
240 12 $self->ensure_discovered;
241 12 ▶ $namespace //= '';
Condition50%1/2
$namespace //= ""
l!l
120
MC/DC0%0/1
$namespace //= ""
$namespace
Truth table50%1/2
A
A= $namespace
Aresult
11
00
242 12 my $ns_rules = $self->_rules->{$namespace};
243 12 ▶ return 0 unless $ns_rules;
Branch: 1 branch
BranchTrueFalseTotal
unless $ns_rules 3 9 12
244  
245 # Check pods/log get permission
246 9 ▶ return 1 if $ns_rules->{'pods/log'} && ($ns_rules->{'pods/log'}{'get'} || $ns_rules->{'pods/log'}{'*'});
Branch: 1 branch
BranchTrueFalseTotal
if $$ns_rules{"pods/log"} and $$ns_rules{"pods/log"}{"get"} || $$ns_rules{"pods/log"}{"*"} 7 2 9
Condition50%3/6
$$ns_rules{"pods/log"} and $$ns_rules{"pods/log"}{"get"} || $$ns_rules{"pods/log"}{"*"}
!ll&&!rl&&r
207
$$ns_rules{"pods/log"}{"get"} or $$ns_rules{"pods/log"}{"*"}
l!l&&r!l&&!r
700
MC/DC33%1/3
$$ns_rules{"pods/log"} and $$ns_rules{"pods/log"}{"get"} || $$ns_rules{"pods/log"}{"*"}
$$ns_rules{"pods/log"} $$ns_rules{"pods/log"}{"get"} $$ns_rules{"pods/log"}{"*"}
Truth table50%2/4
A and B or C
A= $$ns_rules{"pods/log"}B= $$ns_rules{"pods/log"}{"get"}C= $$ns_rules{"pods/log"}{"*"}
ABCresult
0XX0
1000
11X1
1011
247 # Wildcard resource covers subresources too
248 2 ▶ return 1 if $ns_rules->{'*'} && ($ns_rules->{'*'}{'get'} || $ns_rules->{'*'}{'*'});
Branch: 1 branch
BranchTrueFalseTotal
if $$ns_rules{"*"} and $$ns_rules{"*"}{"get"} || $$ns_rules{"*"}{"*"} 1 1 2
Condition50%3/6
$$ns_rules{"*"} and $$ns_rules{"*"}{"get"} || $$ns_rules{"*"}{"*"}
!ll&&!rl&&r
101
$$ns_rules{"*"}{"get"} or $$ns_rules{"*"}{"*"}
l!l&&r!l&&!r
100
MC/DC33%1/3
$$ns_rules{"*"} and $$ns_rules{"*"}{"get"} || $$ns_rules{"*"}{"*"}
$$ns_rules{"*"} $$ns_rules{"*"}{"get"} $$ns_rules{"*"}{"*"}
Truth table50%2/4
A and B or C
A= $$ns_rules{"*"}B= $$ns_rules{"*"}{"get"}C= $$ns_rules{"*"}{"*"}
ABCresult
0XX0
1000
11X1
1011
249 # pods wildcard often implies pods/log
250 1 ▶ return 1 if $ns_rules->{'pods'} && ($ns_rules->{'pods'}{'get'} || $ns_rules->{'pods'}{'*'});
Branch: 1 branch
BranchTrueFalseTotal
if $$ns_rules{"pods"} and $$ns_rules{"pods"}{"get"} || $$ns_rules{"pods"}{"*"} 1 0 1
Condition33%2/6
$$ns_rules{"pods"} and $$ns_rules{"pods"}{"get"} || $$ns_rules{"pods"}{"*"}
!ll&&!rl&&r
001
$$ns_rules{"pods"}{"get"} or $$ns_rules{"pods"}{"*"}
l!l&&r!l&&!r
100
MC/DC0%0/3
$$ns_rules{"pods"} and $$ns_rules{"pods"}{"get"} || $$ns_rules{"pods"}{"*"}
$$ns_rules{"pods"} $$ns_rules{"pods"}{"get"} $$ns_rules{"pods"}{"*"}
Truth table25%1/4
A and B or C
A= $$ns_rules{"pods"}B= $$ns_rules{"pods"}{"get"}C= $$ns_rules{"pods"}{"*"}
ABCresult
0XX0
1000
11X1
1011
251  
252 0 return 0;
253 }
254  
255 7 ▶sub summary {
Subroutine summary: called CC=16 SCAR=28.2
Pod documented
256 7 my ($self) = @_;
257  
258  
259 7 $self->ensure_discovered;
260 7 my @lines;
261 7 push @lines, "# Kubernetes RBAC Permissions\n";
262  
263 7 my @namespaces = $self->allowed_namespaces;
264 7 ▶ unless (@namespaces) {
Branch: 1 branch
BranchTrueFalseTotal
unless (@namespaces) 1 6 7
265 1 push @lines, "No namespace permissions discovered.";
266 1 return join("\n", @lines);
267 }
268  
269 6 for my $ns (@namespaces) {
270 8 push @lines, "## Namespace: $ns\n";
271  
272 8 my $ns_rules = $self->_rules->{$ns};
273 8 ▶ if ($ns_rules->{'*'} && $ns_rules->{'*'}{'*'}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($$ns_rules{"*"} and $$ns_rules{"*"}{"*"}) 2 6 8
Condition66%2/3
$$ns_rules{"*"} and $$ns_rules{"*"}{"*"}
!ll&&!rl&&r
602
MC/DC50%1/2
$$ns_rules{"*"} and $$ns_rules{"*"}{"*"}
$$ns_rules{"*"} $$ns_rules{"*"}{"*"}
Truth table66%2/3
A and B
A= $$ns_rules{"*"}B= $$ns_rules{"*"}{"*"}
ABresult
0X0
100
111
274 2 push @lines, "Full access (all resources, all verbs)\n";
275 2 next;
276 }
277  
278 6 my %by_verb;
279 6 for my $resource (sort keys %$ns_rules) {
280 37 ▶ next if $resource eq '*';
Branch: 1 branch
BranchTrueFalseTotal
if $resource eq "*" 0 37 37
281 37 for my $verb (sort keys %{ $ns_rules->{$resource} }) {
282 108 ▶ next if $verb eq '*';
Branch: 1 branch
BranchTrueFalseTotal
if $verb eq "*" 0 108 108
283 108 push @{ $by_verb{$verb} }, $resource;
284 }
285 37 ▶ if ($ns_rules->{$resource}{'*'}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($$ns_rules{$resource}{"*"}) 0 37 37
286 0 push @{ $by_verb{'all verbs'} }, $resource;
287 }
288 }
289  
290 6 for my $verb (sort keys %by_verb) {
291 26 my @resources = @{ $by_verb{$verb} };
292 26 push @lines, "- **$verb**: " . join(', ', @resources);
293 }
294  
295 6 push @lines, "";
296 }
297  
298 # Cluster-scoped
299 6 ▶ if (my $cluster = $self->_rules->{''}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $cluster = $self->_rules->{""}) 6 0 6
300 6 push @lines, "## Cluster-scoped\n";
301 6 ▶ if ($cluster->{'*'} && $cluster->{'*'}{'*'}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($$cluster{'*'} and $$cluster{'*'}{'*'}) { } 1 5 6
Condition66%2/3
$$cluster{"*"} and $$cluster{"*"}{"*"}
!ll&&!rl&&r
501
MC/DC50%1/2
$$cluster{"*"} and $$cluster{"*"}{"*"}
$$cluster{"*"} $$cluster{"*"}{"*"}
Truth table66%2/3
A and B
A= $$cluster{"*"}B= $$cluster{"*"}{"*"}
ABresult
0X0
100
111
302 1 push @lines, "Full cluster access (all resources, all verbs)\n";
303 } else {
304 5 for my $resource (sort keys %$cluster) {
305 17 ▶ next if $resource eq '*';
Branch: 1 branch
BranchTrueFalseTotal
if $resource eq "*" 0 17 17
306 17 my @verbs = sort keys %{ $cluster->{$resource} };
307 17 push @lines, "- **$resource**: " . join(', ', @verbs);
308 }
309 5 push @lines, "";
310 }
311 }
312  
313 6 return join("\n", @lines);
314 }
315  
316 12 1;
317  
318 __END__
« K8s.pm ↑ Summary Kubernetes.pm »