lib/Kubernetes/REST.pm

filter: Statementstmt 98.5% 1023 / 1038 Branchbran 85.8% 481 / 560 Conditioncond 66.1% 231 / 349 MC/DCmcdc 42.4% 82 / 193 Subroutinesub 100% 130 / 130 Podpod 66.6% 32 / 48 totaltotal 85.3% 1979 / 2318 CC 446 SCAR 24.7
CC
446
Cov
89%
_build_path
31.7
exec
26.2
schema_for
19.4
CRAP 11.9
« lib/Kubernetes/REST/V0Group.pm ↑ Summary lib/Kubernetes/REST/CLI/Minikube.pm »
1 package Kubernetes::REST;
2 91 our $VERSION = '1.110';
3 # ABSTRACT: A Perl REST Client for the Kubernetes API
4 91 ▶use Moo;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 91 ▶use Carp qw(croak carp);
Subroutine BEGIN: called CC=1 SCAR=0.0
6 91 ▶use Scalar::Util qw(blessed);
Subroutine BEGIN: called CC=1 SCAR=0.0
7 91 ▶use Module::Runtime qw(require_module);
Subroutine BEGIN: called CC=1 SCAR=0.0
8 91 ▶use JSON::MaybeXS ();
Subroutine BEGIN: called CC=1 SCAR=0.0
9 91 ▶use Encode ();
Subroutine BEGIN: called CC=1 SCAR=0.0
10 91 ▶use Kubernetes::REST::Server;
Subroutine BEGIN: called CC=1 SCAR=0.0
11 91 ▶use Kubernetes::REST::AuthToken;
Subroutine BEGIN: called CC=1 SCAR=0.0
12 91 ▶use Kubernetes::REST::LWPIO;
Subroutine BEGIN: called CC=1 SCAR=0.0
13 91 ▶use Kubernetes::REST::HTTPRequest;
Subroutine BEGIN: called CC=1 SCAR=0.0
14 91 ▶use IO::K8s;
Subroutine BEGIN: called CC=1 SCAR=0.0
15 91 ▶use IO::K8s::List;
Subroutine BEGIN: called CC=1 SCAR=0.0
16 91 ▶use IO::K8s::CRD;
Subroutine BEGIN: called CC=1 SCAR=0.0
17 91 ▶use IO::K8s::Unstructured ();
Subroutine BEGIN: called CC=1 SCAR=0.0
18 91 ▶use Time::HiRes ();
Subroutine BEGIN: called CC=1 SCAR=0.0
19 91 ▶use Kubernetes::REST::WatchEvent;
Subroutine BEGIN: called CC=1 SCAR=0.0
20 91 ▶use Kubernetes::REST::LogEvent;
Subroutine BEGIN: called CC=1 SCAR=0.0
21 91 ▶use Kubernetes::REST::APIError;
Subroutine BEGIN: called CC=1 SCAR=0.0
22 91 ▶use namespace::clean;
Subroutine BEGIN: called CC=1 SCAR=0.0
23  
24 has server => (
25 is => 'ro',
26 required => 1,
27 486 ▶ coerce => sub {
Subroutine __ANON__: called CC=3 SCAR=11.0
28 486 my $val = $_[0];
29 486 ▶ return $val if blessed($val) && $val->isa('Kubernetes::REST::Server');
Branch: 1 branch
BranchTrueFalseTotal
if builtin::blessed($val) and $val->isa("Kubernetes::REST::Server") 316 170 486
Condition66%2/3
builtin::blessed($val) and $val->isa("Kubernetes::REST::Server")
!ll&&!rl&&r
1700316
MC/DC50%1/2
builtin::blessed($val) and $val->isa("Kubernetes::REST::Server")
builtin::blessed($val) $val->isa("Kubernetes::REST::Server")
Truth table66%2/3
A and B
A= builtin::blessed($val)B= $val->isa("Kubernetes::REST::Server")
ABresult
0X0
100
111
30 170 Kubernetes::REST::Server->new($val);
31 },
32 91 );
33  
34  
35 has credentials => (
36 is => 'ro',
37 required => 1,
38 486 ▶ coerce => sub {
Subroutine __ANON__: called CC=4 SCAR=14.6
39 486 my $val = $_[0];
40 486 ▶ return $val if blessed($val) && $val->can('token');
Branch: 1 branch
BranchTrueFalseTotal
if builtin::blessed($val) and $val->can("token") 316 170 486
Condition66%2/3
builtin::blessed($val) and $val->can("token")
!ll&&!rl&&r
1700316
MC/DC50%1/2
builtin::blessed($val) and $val->can("token")
builtin::blessed($val) $val->can("token")
Truth table66%2/3
A and B
A= builtin::blessed($val)B= $val->can("token")
ABresult
0X0
100
111
41 170 ▶ return Kubernetes::REST::AuthToken->new($val) if ref($val) eq 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
if ref $val eq "HASH" 170 0 170
42 0 return $val;
43 }
44 91 );
45  
46  
47 has io => (
48 is => 'ro',
49 lazy => 1,
50 1 ▶ default => sub {
Subroutine __ANON__: called CC=7 SCAR=23.2
51 1 my $self = shift;
52 1 my $s = $self->server;
53 1 ▶ Kubernetes::REST::LWPIO->new(
Branch: 6 branches
BranchTrueFalseTotal
defined $s->ssl_cert_pem ? : 0 1 1
defined $s->ssl_cert_file ? : 0 1 1
defined $s->ssl_key_pem ? : 0 1 1
defined $s->ssl_key_file ? : 0 1 1
defined $s->ssl_ca_pem ? : 0 1 1
defined $s->ssl_ca_file ? : 0 1 1
54 ssl_verify_server => $s->ssl_verify_server,
55 (defined $s->ssl_cert_pem ? (ssl_cert_pem => $s->ssl_cert_pem) : ()),
56 (defined $s->ssl_cert_file ? (ssl_cert_file => $s->ssl_cert_file) : ()),
57 (defined $s->ssl_key_pem ? (ssl_key_pem => $s->ssl_key_pem) : ()),
58 (defined $s->ssl_key_file ? (ssl_key_file => $s->ssl_key_file) : ()),
59 (defined $s->ssl_ca_pem ? (ssl_ca_pem => $s->ssl_ca_pem) : ()),
60 (defined $s->ssl_ca_file ? (ssl_ca_file => $s->ssl_ca_file) : ()),
61 );
62 },
63 91 );
64  
65  
66 # utf8 => 1 makes encode() return UTF-8 bytes and decode() expect them, which is
67 # what HTTP::Request->content requires and what IO::K8s already assumes. See the
68 # ENCODING section below.
69 has _json => (
70 is => 'ro',
71 486 ▶ default => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
72 486 JSON::MaybeXS->new(utf8 => 1, canonical => 1, convert_blessed => 1);
73 },
74 91 );
75  
76 # External IO::K8s resource-map providers, mirrored onto the inner instance.
77 has with => (
78 is => 'ro',
79 479 ▶ default => sub { [] },
Subroutine __ANON__: called CC=1 SCAR=0.0
80 91 );
81  
82  
83 # IO::K8s instance - configured with same resource_map
84 has k8s => (
85 is => 'ro',
86 lazy => 1,
87 predicate => '_has_k8s',
88 clearer => '_clear_k8s',
89 250 ▶ default => sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
90 250 my $self = shift;
91 return IO::K8s->new(
92 resource_map => $self->resource_map,
93 250 ▶ with => [ @{ $self->with } ],
Branch: 1 branch
BranchTrueFalseTotal
$self->_has_openapi_spec ? : 13 237 250
94 # openapi_spec is an eager hashref on IO::K8s: handing it over here
95 # only once it has actually been fetched keeps constructing/using
96 # the inner instance from forcing the /openapi/v2 download (D12).
97 # Until then it is absent; _fetch_openapi_spec rebuilds this
98 # instance once the spec exists.
99 ($self->_has_openapi_spec ? (openapi_spec => $self->_openapi_spec) : ()),
100 );
101 },
102 91 handles => [qw(
103 new_object
104 inflate
105 json_to_object
106 struct_to_object
107 object_to_json
108 object_to_struct
109 load
110 load_yaml
111 )],
112 );
113  
114  
115 # Set to 0 to use IO::K8s defaults instead of loading from cluster
116 170 ▶has resource_map_from_cluster => (is => 'ro', default => sub { 1 });
Subroutine __ANON__: called CC=1 SCAR=0.0
117  
118  
119 # Cluster version - fetched once per instance
120 has cluster_version => (
121 is => 'ro',
122 lazy => 1,
123 2 ▶ default => sub {
Subroutine __ANON__: called CC=3 SCAR=11.0
124 2 my $self = shift;
125 2 my $response = $self->_request('GET', '/version');
126 2 ▶ return 'unknown' if $response->status >= 400;
Branch: 1 branch
BranchTrueFalseTotal
if $response->status >= 400 1 1 2
127 1 my $info = $self->_json->decode($response->content);
128 1 ▶ return $info->{gitVersion} // 'unknown';
Condition50%1/2
$info->{"gitVersion"} // "unknown"
l!l
10
MC/DC0%0/1
$info->{"gitVersion"} // "unknown"
$info->{"gitVersion"}
Truth table50%1/2
A
A= $info->{"gitVersion"}
Aresult
11
00
129 },
130 91 );
131  
132  
133 # Resource map - loads from cluster by default, cached per instance (lazy)
134 # The predicate is true once the map exists: passed in by the caller, or
135 # built (fetched) on first use. expand_class() keys its cheap path off it.
136 has resource_map => (
137 is => 'ro',
138 lazy => 1,
139 predicate => '_has_resource_map',
140 clearer => '_clear_resource_map',
141 # Always a hash of our own: the inner IO::K8s merges the `with` providers
142 # into this hashref in place (IO::K8s::add). A map passed to the
143 # constructor is the caller's, and the fallback of a failed cluster fetch
144 # is IO::K8s's process-wide built-in map - neither may grow by the
145 # provider Kinds (karr k57). Moo coerces the default's value too.
146 254 ▶ coerce => sub { ref $_[0] eq 'HASH' ? { %{ $_[0] } } : $_[0] },
Subroutine __ANON__: called CC=2 SCAR=7.2
Branch: 1 branch
BranchTrueFalseTotal
ref $_[0] eq 'HASH' ? : 254 0 254
147 216 ▶ default => sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
148 216 my $self = shift;
149 # Built here, not passed in: absorb_discovery may rebuild it.
150 216 $self->_resource_map_built(1);
151 # A private copy, never IO::K8s's shared global map: the inner IO::K8s
152 # is handed this hashref and merges any `with` providers into it with
153 # add(), which mutates it in place. Returning the global ref would leak
154 # provider Kinds into IO::K8s->default_resource_map process-wide.
155 216 ▶ return { %{ IO::K8s->default_resource_map } } unless $self->resource_map_from_cluster;
Branch: 1 branch
BranchTrueFalseTotal
unless $self->resource_map_from_cluster 170 46 216
156 46 return $self->_load_resource_map_from_cluster;
157 },
158 91 );
159  
160  
161 # Whether the resource map in place was built by the default above rather
162 # than passed to the constructor. absorb_discovery rebuilds a built map from
163 # the catalog it takes; a map the caller passed is theirs and stays (karr k51).
164 91 has _resource_map_built => (is => 'rw', init_arg => undef);
165  
166 # Deliberately NOT delegated to the k8s attribute like the other IO::K8s
167 # methods: building that instance forces the lazy resource_map, which on the
168 # default resource_map_from_cluster => 1 is a full GET /openapi/v2 - paid for
169 # resolving a name like 'Pod' whose answer already sits in the built-in map
170 # (karr #15).
171 396 ▶sub expand_class {
Subroutine expand_class: called CC=12 SCAR=24.9
Pod documented
172 396 my ($self, @args) = @_;
173  
174  
175 396 ▶ if ($self->resource_map_from_cluster && !$self->_has_resource_map
Branch: 1 branch
BranchTrueFalseTotal
if ($self->resource_map_from_cluster and not $self->_has_resource_map and defined $args[0] and not ref $args[0]) 44 352 396
Condition77%7/9
$self->resource_map_from_cluster and not $self->_has_resource_map and defined $args[0] and not ref $args[0]
!ll&&!rl&&r
352044
$self->resource_map_from_cluster and not $self->_has_resource_map and defined $args[0]
!ll&&!rl&&r
352044
$self->resource_map_from_cluster and not $self->_has_resource_map
!ll&&!rl&&r
3064644
MC/DC50%2/4
$self->resource_map_from_cluster and not $self->_has_resource_map and defined $args[0] and not ref $args[0]
$self->resource_map_from_cluster not $self->_has_resource_map defined $args[0] not ref $args[0]
Truth table60%3/5
A and not(B) and C and not(D)
A= $self->resource_map_from_clusterB= not $self->_has_resource_mapC= defined $args[0]D= not ref $args[0]
ABCDresult
0XXX0
10XX0
110X0
11100
11111
176 && defined $args[0] && !ref $args[0]) {
177 # '+Full::Class::Name' names an exact class - no map consulted either
178 # way, and by contract it is returned without being loaded.
179 44 ▶ return substr($args[0], 1) if $args[0] =~ /^\+/;
Branch: 1 branch
BranchTrueFalseTotal
if $args[0] =~ /^\+/ 2 42 44
180 # As a class method, IO::K8s->expand_class resolves against the
181 # built-in map. Its fallback for an unknown Kind is the *name*
182 # 'IO::K8s::<Kind>' whether or not such a class exists, so a cheap
183 # answer only counts when it names a class that actually loads.
184 # Anything else falls through to the cluster-backed instance below,
185 # which fetches the cluster map exactly as it always did.
186 42 my $class = IO::K8s->expand_class(@args);
187 return $class if defined $class
188 42 ▶ && ($class->can('new') || eval { require_module($class); 1 });
Branch: 1 branch
BranchTrueFalseTotal
if defined $class and $class->can("new") || eval { do { &require_module($class); 1 } } 9 33 42
Condition100%6/6
defined $class and $class->can("new") || eval { do { &require_module($class); 1 } }
!ll&&!rl&&r
7269
$class->can("new") or eval { do { &require_module($class); 1 } }
l!l&&r!l&&!r
8126
MC/DC100%3/3
defined $class and $class->can("new") || eval { do { &require_module($class); 1 } }
defined $class $class->can("new") eval { do { &require_module($class); 1 } }
Truth table100%4/4
A and B or C
A= defined $classB= $class->can("new")C= eval { do { &require_module($class); 1 } }
ABCresult
0XX0
1000
11X1
1011
189 }
190  
191 # Fall through to the cluster-backed inner IO::K8s, which owns the
192 # resolution order (design D13, extending the 2026-08-10 exact-GVK
193 # contract):
194 # rung 1 an explicit '+Full::Class' in the caller's resource_map
195 # rung 2 provider classes merged from `with`
196 # rung 3 AutoGen from openapi_spec, once the spec has been fetched
197 # rung 5 the existing fail-closed GVK error
198 # The discovery-built map (see _resource_map_from_catalog) no longer
199 # short-circuits this order with invented IO::K8s::Api::<Group> names for
200 # groups this distribution does not ship (D12): a foreign Kind with no
201 # provider and no loaded spec now reaches rung 4/5 instead of resolving to
202 # a bogus class.
203 385 my $class = $self->k8s->expand_class(@args);
204  
205 # How IO::K8s signals "nothing resolved this Kind" depends on the argument
206 # shape, and only that exact signal may be diverted to rung 4 -- every real
207 # resolution (rungs 1-3: a '+Full::Class', a provider from `with`, a builtin
208 # or an AutoGen class) must be returned untouched, including a '+'-class
209 # that names a class not yet loaded (returned by contract without loading,
210 # so a load probe would wrongly reject it -- karr t/36 subtest 3).
211 #
212 # For a bare Kind IO::K8s fails *open*: it fabricates the name
213 # 'IO::K8s::<Kind>' whether or not such a class exists, and the fail-closed
214 # error only surfaces later when require_module() cannot load it. For an
215 # exact-GVK or domain-qualified request it fails *closed*, returning undef.
216 # Both -- and nothing else -- mean unresolved (_is_unresolved).
217 385 my ($kind, $api_version) = $self->_kind_from_expand_args(@args);
218 385 ▶ return $class unless defined $kind && $self->_is_unresolved($class, $kind);
Branch: 1 branch
BranchTrueFalseTotal
unless defined $kind and $self->_is_unresolved($class, $kind) 282 103 385
Condition100%3/3
defined $kind and $self->_is_unresolved($class, $kind)
!ll&&!rl&&r
54228103
MC/DC100%2/2
defined $kind and $self->_is_unresolved($class, $kind)
defined $kind $self->_is_unresolved($class, $kind)
Truth table100%3/3
A and B
A= defined $kindB= $self->_is_unresolved($class, $kind)
ABresult
0X0
100
111
219  
220 # Rung 4 (D16): the Kind resolved to nothing that ships. If the cluster
221 # confirms this GVK through aggregated discovery, resolve to
222 # IO::K8s::Unstructured -- its plural and scope come from the discovery
223 # catalog at path-build time (_build_path), since Unstructured carries no
224 # api_version()/resource_plural()/Namespaced role of its own. On by default
225 # (no opt-in here, unlike bare IO::K8s): D16 gates it on discovery
226 # confirmation instead. _discovery_path_meta is a no-op (undef) unless
227 # resource_map_from_cluster is set, and by the time control reaches here the
228 # catalog was already fetched building the cluster map, so this consults a
229 # cache and never adds a round-trip. A Kind discovery does not serve stays
230 # fail-closed (rung 5): the fabricated name (or undef) is returned so the
231 # load error still names the Kind. A qualified name, or a Kind plus
232 # apiVersion, is confirmed only in exactly its group/version: another
233 # group or version serving the Kind leaves it at rung 5 too (karr k43).
234 # A discovery *failure* (cluster unreachable, expired token) is
235 # deliberately treated the same as "not served" here -- rung 5,
236 # fail-closed -- with the reason kept in
237 # _discovery_error; on the CRUD path the carp from
238 # _load_resource_map_from_cluster has already named it while building the
239 # cluster map.
240 103 ▶ return 'IO::K8s::Unstructured'
Branch: 1 branch
BranchTrueFalseTotal
if $self->_discovery_path_meta($kind, $api_version) 37 66 103
241 if $self->_discovery_path_meta($kind, $api_version);
242  
243 66 return $class;
244 }
245  
246 # Whether $class, what expand_class() made of a name whose Kind is $kind (from
247 # _kind_from_expand_args), is the signal that nothing resolved it: undef, or
248 # the 'IO::K8s::<Kind>' IO::K8s fabricates for a bare Kind when that class does
249 # not load (see expand_class). Every real resolution is resolved, including a
250 # '+'-class that is not loaded yet.
251 615 ▶sub _is_unresolved {
Subroutine _is_unresolved: called CC=5 SCAR=16.8
252 615 my ($self, $class, $kind) = @_;
253 615 ▶ return 1 unless defined $class;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $class 73 542 615
254 return defined $kind
255 && $class eq "IO::K8s::$kind"
256 0 ▶ && !($class->can('new') || eval { require_module($class); 1 });
Condition66%6/9
defined $kind && $class eq "IO::K8s::$kind" && !($class->can('new') || eval { do { &require_module($class); 1 } })
!ll&&!rl&&r
463079
defined $kind and $class eq "IO::K8s::$kind"
!ll&&!rl&&r
5241179
$class->can('new') || eval { do { &require_module($class); 1 } }
l!l&&r!l&&!r
0079
MC/DC50%2/4
defined $kind && $class eq "IO::K8s::$kind" && !($class->can('new') || eval { do { &require_module($class); 1 } })
defined $kind $class eq "IO::K8s::$kind" $class->can('new') eval { do { &require_module($class); 1 } }
Truth table60%3/5
A and B && not(C || D)
A= defined $kindB= $class eq "IO::K8s::$kind"C= $class->can('new')D= eval { do { &require_module($class); 1 } }
ABCDresult
0XXX0
10XX0
111X0
11010
11001
257 }
258  
259 # expand_class() for the methods that take a resource name and build a request
260 # path from its class (list, get, patch, patch_status, delete, watch, log,
261 # port_forward, exec, attach) or load it (compare_schema). A name nothing
262 # resolves croaks here, naming it the way Net::Async::Kubernetes does, before
263 # any request (karr k46) - instead of in _build_path, where require_module saw
264 # only expand_class's answer: undef for a qualified name ("argument is not a
265 # module name"), or a bare Kind's fabricated class ("Can't locate
266 # IO/K8s/<Kind>.pm", naming a module that does not exist). A discovery
267 # failure is named with it: an unreachable cluster could not confirm the name,
268 # which is not the same as a cluster that does not serve it (karr k28). Only
269 # for a name with a Kind - expand_class consulted discovery for exactly that
270 # one, so the recorded failure is this call's. expand_class itself keeps
271 # returning undef or the fabricated name: that is its public contract, and
272 # _manifest_to_object reads the undef.
273 284 ▶sub _expand_class_or_croak {
Subroutine _expand_class_or_croak: called CC=6 SCAR=18.0
274 284 my ($self, $name) = @_;
275 284 my $class = $self->expand_class($name);
276 284 my ($kind) = $self->_kind_from_expand_args($name);
277 284 ▶ return $class unless $self->_is_unresolved($class, $kind);
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_is_unresolved($class, $kind) 235 49 284
278 49 ▶ my $discovery_error = defined $kind ? $self->_discovery_error : undef;
Branch: 1 branch
BranchTrueFalseTotal
defined $kind ? : 49 0 49
279 49 ▶ $discovery_error = $self->_error_reason($discovery_error) if defined $discovery_error;
Branch: 1 branch
BranchTrueFalseTotal
if defined $discovery_error 3 46 49
280 49 ▶ croak "unknown resource '" . ($name // '(undef)') . "': no IO::K8s class"
Branch: 1 branch
BranchTrueFalseTotal
defined $discovery_error ? : 3 46 49
Condition50%1/2
$name // "(undef)"
l!l
490
MC/DC0%0/1
$name // "(undef)"
$name
Truth table50%1/2
A
A= $name
Aresult
11
00
281 . " for this apiVersion/kind (add it to resource_map if it is a CRD)"
282 . (defined $discovery_error
283 ? "; discovery failed, so the cluster could not confirm it: $discovery_error"
284 : '');
285 }
286  
287 # A caught error - a croak's string, or an APIError - as the reason another
288 # message embeds: its text without the location it ends with. That location
289 # names a line in here, or whatever frame a lazy builder left; the message it
290 # goes into names the caller's line itself (karr k59). Once a file handle has
291 # been read, Carp's location ends ', <$fh> line N.' (or 'chunk N').
292 42 ▶sub _error_reason {
Subroutine _error_reason: called CC=1 SCAR=0.0
293 42 my ($self, $error) = @_;
294 42 my $reason = "$error";
295 42 $reason =~ s/(?: at \S+ line \d+(?:, <[^>]*> (?:line|chunk) \d+)?\.)?\s*\z//;
296 42 return $reason;
297 }
298  
299 # carp, for a warning raised while a lazy attribute is built - the discovery
300 # catalog, the resource map built from it. Carp skips the frames of Moo's
301 # generated accessors (Moo marks them internal), but not the frame where this
302 # package calls into one, so a plain carp named the line in here that first
303 # asked for the attribute (karr k63, k64). Trusting the generated accessors
304 # for this one warning lets it name the caller's line, as a warning from a
305 # plain method does. Not package-wide: that would move every other croak.
306 15 ▶sub _carp_past_builders {
Subroutine _carp_past_builders: called CC=1 SCAR=0.0
307 15 my ($self, $message) = @_;
308 15 local our @CARP_NOT = ('Method::Generate::Accessor::_Generated');
309 15 carp $message;
310 15 return;
311 }
312  
313 # Extract the Kubernetes Kind (and any explicitly supplied apiVersion) from an
314 # expand_class() argument list, for the D16 rung-4 discovery-confirmation
315 # check. Only bare short names ('Widget') and domain-qualified strings
316 # ('example.com/v1/Widget') name a Kind that Unstructured should stand in for;
317 # a '+Full::Class', an 'IO::K8s::...' name or any multi-segment package name is
318 # an explicit class request and must never be diverted to Unstructured.
319 679 ▶sub _kind_from_expand_args {
Subroutine _kind_from_expand_args: called CC=7 SCAR=19.6
320 679 my ($self, $name, $api_version) = @_;
321 679 ▶ return () unless defined $name && !ref $name;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $name and not ref $name 0 679 679
Condition33%1/3
defined $name and not ref $name
!ll&&!rl&&r
00679
MC/DC0%0/2
defined $name and not ref $name
defined $name not ref $name
Truth table33%1/3
A and not(B)
A= defined $nameB= not ref $name
ABresult
0X0
100
111
322 679 ▶ return () if $name =~ /^\+/;
Branch: 1 branch
BranchTrueFalseTotal
if $name =~ /^\+/ 5 674 679
323 674 ▶ return () if $name =~ /^IO::K8s::/;
Branch: 1 branch
BranchTrueFalseTotal
if $name =~ /^IO::K8s::/ 100 574 674
324 574 ▶ if ($name =~ m{/}) { # 'group/version/Kind' -> ('Kind', 'group/version')
Branch: 1 branch
BranchTrueFalseTotal
if ($name =~ m[/]) 86 488 574
325 86 my ($av, $kind) = $name =~ m{\A(.*)/([^/]+)\z};
326 86 return ($kind, $av);
327 }
328 488 ▶ return () if $name =~ /::/; # a multi-segment class name, not a Kind
Branch: 1 branch
BranchTrueFalseTotal
if $name =~ /::/ 1 487 488
329 487 return ($name, $api_version);
330 }
331  
332 # Path metadata (apiVersion, resource plural, namespaced) for a Kind, read from
333 # the cached discovery catalog. This is how a Kind resolved to
334 # IO::K8s::Unstructured (D16 rung 4) gets what _build_path needs: Unstructured
335 # has apiVersion/kind on the *instance* but no api_version()/resource_plural()
336 # class method and no Namespaced role, so plural and scope cannot come from the
337 # class the way a typed resource's do -- they come from here.
338 #
339 # Returns undef (fail-closed) unless resource_map_from_cluster is set: with no
340 # cluster there is no discovery to confirm a GVK, and this must never trigger a
341 # fetch on the fetch-free path. When it does run, the catalog is already cached
342 # (building the cluster resource map fetched it), so the lookup is free.
343 #
344 # A fetch that fails outright (cluster unreachable, expired token) returns the
345 # same undef as a healthy catalog that lacks the Kind -- deliberately
346 # fail-closed (D16: an unreachable cluster must not let anything pass as
347 # confirmed) -- but the reason is kept in _discovery_error so _build_path can
348 # name it instead of claiming a missing entry.
349 #
350 # $want_api_version, when given (a qualified name's group/version, or an
351 # Unstructured object's own apiVersion), pins the group/version, and nothing
352 # else will do; without it the group's discovery-preferred version wins,
353 # matching _resource_map_from_catalog and D17.
354 140 ▶sub _discovery_path_meta {
Subroutine _discovery_path_meta: called CC=15 SCAR=27.8
355 140 my ($self, $kind, $want_api_version) = @_;
356 140 ▶ return unless $self->resource_map_from_cluster;
Branch: 1 branch
BranchTrueFalseTotal
unless $self->resource_map_from_cluster 36 104 140
357 104 my $catalog = eval { $self->_discovery };
358 104 ▶ if (my $error = $@) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $error = $@) 7 97 104
359 7 $self->_discovery_error($error);
360 7 return;
361 }
362 97 $self->_clear_discovery_error;
363 97 ▶ return unless $catalog && $catalog->{groups};
Branch: 1 branch
BranchTrueFalseTotal
unless $catalog and $catalog->{"groups"} 0 97 97
Condition33%1/3
$catalog and $catalog->{"groups"}
!ll&&!rl&&r
0097
MC/DC0%0/2
$catalog and $catalog->{"groups"}
$catalog $catalog->{"groups"}
Truth table33%1/3
A and B
A= $catalogB= $catalog->{"groups"}
ABresult
0X0
100
111
364  
365 63 ▶ my $meta_for = sub {
Subroutine __ANON__: called CC=4 SCAR=14.3
366 63 my ($group, $version, $res) = @_;
367 return {
368 api_version => ($group eq '' ? $version : "$group/$version"),
369 resource => $res->{resource},
370 63 ▶ namespaced => ($res->{scope} && $res->{scope} eq 'Namespaced' ? 1 : 0),
Branch: 2 branches
BranchTrueFalseTotal
$group eq '' ? : 0 63 63
$res->{'scope'} && $res->{'scope'} eq 'Namespaced' ? : 61 2 63
Condition66%2/3
$res->{"scope"} and $res->{"scope"} eq "Namespaced"
!ll&&!rl&&r
0261
MC/DC50%1/2
$res->{"scope"} and $res->{"scope"} eq "Namespaced"
$res->{"scope"} $res->{"scope"} eq "Namespaced"
Truth table66%2/3
A and B
A= $res->{"scope"}B= $res->{"scope"} eq "Namespaced"
ABresult
0X0
100
111
371 };
372 97 };
373  
374 # An explicit apiVersion pins the exact group/version, and only that one.
375 # It names one GVK, and a cluster that does not serve that GVK has not
376 # confirmed it (D16) - not even when another group, or another version of
377 # the same group, serves a Kind of that name. Falling back there would
378 # address that other resource: list, delete and ensure_only's prune would
379 # land in it (karr k43). The same rule as IO::K8s's exact-GVK resolution,
380 # where an explicit version never falls back to the bare Kind's.
381 97 ▶ if (defined $want_api_version && length $want_api_version) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $want_api_version and length $want_api_version) 48 49 97
Condition66%2/3
defined $want_api_version and length $want_api_version
!ll&&!rl&&r
49048
MC/DC50%1/2
defined $want_api_version and length $want_api_version
defined $want_api_version length $want_api_version
Truth table66%2/3
A and B
A= defined $want_api_versionB= length $want_api_version
ABresult
0X0
100
111
382 48 ▶ my ($g, $v) = $want_api_version =~ m{/}
Branch: 1 branch
BranchTrueFalseTotal
$want_api_version =~ m[/] ? : 48 0 48
383 ? split(m{/}, $want_api_version, 2)
384 : ('', $want_api_version);
385 48 my $res = $catalog->{groups}{$g}{versions}{$v}{kinds}{$kind};
386 48 ▶ return unless $res;
Branch: 1 branch
BranchTrueFalseTotal
unless $res 24 24 48
387 24 return $meta_for->($g, $v, $res);
388 }
389  
390 # A bare Kind: the preferred version of whichever group serves it (D17).
391 49 for my $group (sort keys %{$catalog->{groups}}) {
392 104 my $gdata = $catalog->{groups}{$group};
393 104 ▶ my @order = @{$gdata->{version_order} // []};
Condition50%1/2
$gdata->{"version_order"} // []
l!l
1040
MC/DC0%0/1
$gdata->{"version_order"} // []
$gdata->{"version_order"}
Truth table50%1/2
A
A= $gdata->{"version_order"}
Aresult
11
00
394 104 my $pref = $gdata->{preferred};
395 105 @order = ($pref, grep { $_ ne $pref } @order)
396 104 ▶ if defined $pref && grep { $_ eq $pref } @order;
Branch: 1 branch
BranchTrueFalseTotal
if defined $pref and grep {$_ eq $pref;} @order 104 0 104
Condition33%1/3
defined $pref and grep {$_ eq $pref;} @order
!ll&&!rl&&r
00104
MC/DC0%0/2
defined $pref and grep {$_ eq $pref;} @order
defined $pref grep {$_ eq $pref;} @order
Truth table33%1/3
A and B
A= defined $prefB= grep {$_ eq $pref;} @order
ABresult
0X0
100
111
397 104 for my $version (@order) {
398 104 my $res = $gdata->{versions}{$version}{kinds}{$kind};
399 104 ▶ return $meta_for->($group, $version, $res) if $res;
Branch: 1 branch
BranchTrueFalseTotal
if $res 39 65 104
400 }
401 }
402 10 return;
403 }
404  
405 # The extra _build_path arguments an IO::K8s::Unstructured resolution needs,
406 # derived from whatever identifier expand_class was given: an IO::K8s object
407 # (its kind/apiVersion accessors) or a name string. A string is split the way
408 # expand_class split it to confirm the GVK, so a qualified
409 # 'example.org/v1/Widget' keeps its group/version and does not land in
410 # whichever other group serving a Widget discovery lists first. Empty for
411 # every typed class, so typed path building is completely unchanged.
412 372 ▶sub _unstructured_hint {
Subroutine _unstructured_hint: called CC=7 SCAR=19.7
413 372 my ($self, $class, $ident) = @_;
414 372 ▶ return () unless defined $class && $class eq 'IO::K8s::Unstructured';
Branch: 1 branch
BranchTrueFalseTotal
unless defined $class and $class eq "IO::K8s::Unstructured" 348 24 372
Condition66%2/3
defined $class and $class eq "IO::K8s::Unstructured"
!ll&&!rl&&r
034824
MC/DC50%1/2
defined $class and $class eq "IO::K8s::Unstructured"
defined $class $class eq "IO::K8s::Unstructured"
Truth table66%2/3
A and B
A= defined $classB= $class eq "IO::K8s::Unstructured"
ABresult
0X0
100
111
415 24 ▶ if (blessed($ident)) {
Branch: 1 branch
BranchTrueFalseTotal
if (builtin::blessed($ident)) 15 9 24
416 return (
417 15 ▶ kind => $ident->kind,
Branch: 1 branch
BranchTrueFalseTotal
defined $ident->apiVersion ? : 15 0 15
418 (defined $ident->apiVersion ? (api_version => $ident->apiVersion) : ()),
419 );
420 }
421 9 my ($kind, $api_version) = $self->_kind_from_expand_args($ident);
422 return (
423 9 ▶ (defined $kind ? (kind => $kind) : ()),
Branch: 2 branches
BranchTrueFalseTotal
defined $kind ? : 9 0 9
defined $api_version ? : 3 6 9
424 (defined $api_version ? (api_version => $api_version) : ()),
425 );
426 }
427  
428 # Kubernetes groups whose IO::K8s classes do NOT live under IO::K8s::Api::.
429 # Their namespace follows the upstream Go staging repository the types are
430 # generated from (apiextensions-apiserver, kube-aggregator), not the API group
431 # name, so it cannot be derived - it has to be listed here.
432 #
433 # Keyed on the full group name, because that is the only globally unique
434 # identifier: a cluster is free to serve a CRD group called
435 # apiextensions.example.com, and that group is an ordinary one.
436 91 my %NON_API_NAMESPACE = (
437 'apiextensions.k8s.io' => 'ApiextensionsApiserver::Pkg::Apis::Apiextensions',
438 'apiregistration.k8s.io' => 'KubeAggregator::Pkg::Apis::Apiregistration',
439 );
440  
441 # The same table, indexed by the IO::K8s group directory instead - the trailing
442 # segment of each namespace above is exactly that directory name. Derived, so
443 # there is still only one place to add a group.
444 my %NON_API_NAMESPACE_BY_GROUP_PATH =
445 91 map { ((split /::/)[-1] => $_) } values %NON_API_NAMESPACE;
446  
447 # Namespace below IO::K8s:: for a Kubernetes API group name as the cluster's
448 # OpenAPI spec reports it: '' for core, 'apps', 'apiextensions.k8s.io',
449 # 'cert-manager.io', ... The exception table is matched exactly on the full
450 # name - a CRD group that merely starts with 'apiextensions' is an ordinary
451 # group and must keep landing under Api::.
452 178 ▶sub _io_k8s_namespace_for_group {
Subroutine _io_k8s_namespace_for_group: called CC=3 SCAR=11.0
453 178 my ($self, $group) = @_;
454 178 ▶ return $NON_API_NAMESPACE{$group} if exists $NON_API_NAMESPACE{$group};
Branch: 1 branch
BranchTrueFalseTotal
if exists $NON_API_NAMESPACE{$group} 15 163 178
455 163 ▶ return 'Api::' . ($group eq '' ? 'Core' : ucfirst(lc((split /\./, $group)[0])));
Branch: 1 branch
BranchTrueFalseTotal
$group eq '' ? : 65 98 163
456 }
457  
458 # Namespace below IO::K8s:: for an IO::K8s group directory name - 'Core',
459 # 'Apps', 'Apiextensions'. That is the form the v0 compatibility layer carries,
460 # and it is a closed set of names this distribution ships, so unlike a group
461 # name off the wire it needs no exact-match guard.
462 80 ▶sub _io_k8s_namespace_for_group_path {
Subroutine _io_k8s_namespace_for_group_path: called CC=2 SCAR=6.9
463 80 my ($self, $group_path) = @_;
464 80 ▶ return $NON_API_NAMESPACE_BY_GROUP_PATH{$group_path} // "Api::${group_path}";
Condition100%2/2
$NON_API_NAMESPACE_BY_GROUP_PATH{$group_path} // "Api::$group_path"
l!l
971
MC/DC100%1/1
$NON_API_NAMESPACE_BY_GROUP_PATH{$group_path} // "Api::$group_path"
$NON_API_NAMESPACE_BY_GROUP_PATH{$group_path}
Truth table100%2/2
A
A= $NON_API_NAMESPACE_BY_GROUP_PATH{$group_path}
Aresult
11
00
465 }
466  
467 # Public method to build the resource map from the cluster's discovery catalog
468 70 ▶sub fetch_resource_map {
Subroutine fetch_resource_map: called CC=2 SCAR=6.9
Pod documented
469 70 my ($self) = @_;
470  
471  
472 # The cluster resource map is built from aggregated discovery, not from the
473 # multi-MB /openapi/v2 spec (design D11): a small GET /api + GET /apis gives
474 # every group, version, plural, Kind and scope. The catalog is cached in the
475 # _discovery attribute and shared by later rebuilds; /openapi/v2 stays lazy
476 # for schema_for/compare_schema only. The failure keeps this method's
477 # documented wording; the underlying error rides along.
478 70 my $catalog = eval { $self->_discovery };
479 70 ▶ croak 'Could not load resource map from cluster: ' . $self->_error_reason($@)
Branch: 1 branch
BranchTrueFalseTotal
unless $catalog 16 54 70
480 unless $catalog;
481  
482 54 return $self->_resource_map_from_catalog($catalog);
483 }
484  
485 # Turn the cached discovery catalog into the short-name -> IO::K8s class map.
486 # The namespace comes from _io_k8s_namespace_for_group (exception tables
487 # included) and List kinds are skipped. Two rules shape which entries land:
488 #
489 # D17 preferred version: among the versions a group serves a Kind in, the
490 # version the cluster marks preferred wins the bare short name (not "stable
491 # beats alpha/beta" -- that heuristic is gone). A Kind served only outside
492 # the preferred version still maps, to its first served version, so nothing
493 # the cluster serves is dropped.
494 #
495 # D12/D13 stop inventing: an entry is recorded only when the candidate
496 # IO::K8s class actually ships. A foreign group (cilium.io, cert-manager.io)
497 # has no IO::K8s::Api::<Group> class, so its Kinds are omitted here and left
498 # to resolve through the inner IO::K8s pipeline (provider from `with` ->
499 # AutoGen from openapi_spec -> D16 Unstructured -> fail-closed) rather than
500 # short-circuiting to a bogus name. Core-API groups and the two exception
501 # groups (apiextensions/apiregistration) do ship, so their Kinds map exactly
502 # as before.
503 54 ▶sub _resource_map_from_catalog {
Subroutine _resource_map_from_catalog: called CC=11 SCAR=24.0
504 54 my ($self, $catalog) = @_;
505  
506 54 my %map;
507 54 ▶ for my $group (keys %{$catalog->{groups} // {}}) {
Condition50%1/2
$catalog->{"groups"} // {}
l!l
540
MC/DC0%0/1
$catalog->{"groups"} // {}
$catalog->{"groups"}
Truth table50%1/2
A
A= $catalog->{"groups"}
Aresult
11
00
508 140 my $gdata = $catalog->{groups}{$group};
509  
510 # D17: try the cluster's preferred version first, then the rest in
511 # discovery order; the first version to yield a shipping class for a
512 # Kind keeps the short name. Where the preferred version's class does
513 # not ship but another served version's does, the Kind still maps to
514 # that other version rather than vanishing.
515 140 ▶ my @order = @{$gdata->{version_order} // []};
Condition100%2/2
$gdata->{"version_order"} // []
l!l
1391
MC/DC100%1/1
$gdata->{"version_order"} // []
$gdata->{"version_order"}
Truth table100%2/2
A
A= $gdata->{"version_order"}
Aresult
11
00
516 140 my $pref = $gdata->{preferred};
517 152 @order = ($pref, grep { $_ ne $pref } @order)
518 140 ▶ if defined $pref && grep { $_ eq $pref } @order;
Branch: 1 branch
BranchTrueFalseTotal
if defined $pref and grep {$_ eq $pref;} @order 139 1 140
Condition66%2/3
defined $pref and grep {$_ eq $pref;} @order
!ll&&!rl&&r
10139
MC/DC50%1/2
defined $pref and grep {$_ eq $pref;} @order
defined $pref grep {$_ eq $pref;} @order
Truth table66%2/3
A and B
A= defined $prefB= grep {$_ eq $pref;} @order
ABresult
0X0
100
111
519  
520 140 for my $version (@order) {
521 152 my $kinds = $gdata->{versions}{$version}{kinds};
522 152 for my $kind (keys %$kinds) {
523 180 ▶ next if $kind =~ /List$/;
Branch: 1 branch
BranchTrueFalseTotal
if $kind =~ /List$/ 1 179 180
524 179 ▶ next if exists $map{$kind}; # a preferred/earlier version won it
Branch: 1 branch
BranchTrueFalseTotal
if exists $map{$kind} 8 171 179
525  
526 171 my $version_path = ucfirst($version);
527 171 my $new_path = $self->_io_k8s_namespace_for_group($group)
528 . "::${version_path}::${kind}";
529  
530 # D12/D13: only record a class name this distribution ships.
531 171 ▶ next unless $self->_io_k8s_class_ships($new_path);
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_io_k8s_class_ships($new_path) 71 100 171
532  
533 100 $map{$kind} = $new_path;
534 }
535 }
536 }
537  
538 54 return \%map;
539 }
540  
541 # Process-wide cache for the D12/D13 "stop inventing" loadability probe: a
542 # relative class path is either shipped (a real IO::K8s class that loads) or it
543 # is not, and that never changes within a run. Keyed by the relative path, so
544 # it is shared across instances.
545 91 my %_CLASS_SHIPS;
546  
547 # True when 'IO::K8s::<rel_path>' is a real, loadable class. The discovery map
548 # is built from group/version/Kind triples off the wire; without this probe
549 # every foreign CRD group would map to an IO::K8s::Api::<Group>::... name that
550 # has no class behind it (design D12). require the candidate once -- already
551 # loaded classes short-circuit on ->can('new') -- and remember the answer.
552 171 ▶sub _io_k8s_class_ships {
Subroutine _io_k8s_class_ships: called CC=4 SCAR=13.9
553 171 my ($self, $rel_path) = @_;
554 171 ▶ return $_CLASS_SHIPS{$rel_path} //= do {
Condition66%2/3
$_CLASS_SHIPS{$rel_path} //= do { my $full = "IO::K8s::$rel_path"; $full->can("new") || eval { do { &require_module($full); 1 } } ? 1 : 0 }
l!l&&r!l&&!r
121500
MC/DC0%0/2
$_CLASS_SHIPS{$rel_path} //= do { my $full = "IO::K8s::$rel_path"; $full->can("new") || eval { do { &require_module($full); 1 } } ? 1 : 0 }
$_CLASS_SHIPS{$rel_path} do { my $full = "IO::K8s::$rel_path"; $full->can("new") || eval { do { &require_module($full); 1 } } ? 1 : 0 }
Truth table66%2/3
A //= B
A= $_CLASS_SHIPS{$rel_path}B= do { my $full = "IO::K8s::$rel_path"; $full->can("new") || eval { do { &require_module($full); 1 } } ? 1 : 0 }
ABresult
1X1
011
000
555 50 my $full = "IO::K8s::$rel_path";
556 50 ▶ ($full->can('new') || eval { require_module($full); 1 }) ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$full->can('new') || eval { do { &require_module($full); 1 } } ? : 31 19 50
Condition100%3/3
$full->can("new") or eval { do { &require_module($full); 1 } }
l!l&&r!l&&!r
62519
MC/DC100%2/2
$full->can("new") or eval { do { &require_module($full); 1 } }
$full->can("new") eval { do { &require_module($full); 1 } }
Truth table100%3/3
A or B
A= $full->can("new")B= eval { do { &require_module($full); 1 } }
ABresult
1X1
011
000
557 };
558 }
559  
560 # Per-instance discovery catalog, keyed by group. Shape:
561 # { groups => { <group> => {
562 # preferred => <version>, # first version the cluster serves
563 # version_order => [ <version>, ... ], # discovery order, preferred first
564 # versions => { <version> => { kinds => {
565 # <Kind> => { resource => <plural>, scope => 'Namespaced'|'Cluster' },
566 # } } },
567 # } } }
568 # Built lazily on first use - or handed over by absorb_discovery - and
569 # invalidated by invalidate_discovery.
570 has _discovery => (
571 is => 'lazy',
572 predicate => '_has_discovery',
573 clearer => '_clear_discovery',
574 writer => '_set_discovery', # absorb_discovery
575 58 ▶ builder => sub { $_[0]->_fetch_discovery },
Subroutine _build__discovery: called CC=1 SCAR=0.0
Subroutine __ANON__: called CC=1 SCAR=0.0
576 91 );
577  
578 # The reason the last discovery fetch attempted from _discovery_path_meta
579 # failed - its $@, for an HTTP error status an APIError (karr k59), rendered
580 # with _error_reason - kept so the croak in _build_path can name it: a
581 # failed fetch and a healthy catalog without the Kind both come back from
582 # _discovery_path_meta as undef (fail-closed, D16), and only this tells them
583 # apart. Cleared by the next successful fetch and by invalidate_discovery.
584 91 has _discovery_error => (
585 is => 'rw',
586 clearer => '_clear_discovery_error',
587 );
588  
589 # Aggregated discovery v2 (Kubernetes >= 1.27): GET /api and GET /apis with an
590 # Accept header selecting APIGroupDiscoveryList answer every group, version,
591 # resource plural, Kind and scope in one small response each. A server that does
592 # not understand the header ignores the as= parameter and returns the legacy
593 # document (APIVersions / APIGroupList) - detected by the kind - and the
594 # per-group APIResourceList fallback fills the catalog instead.
595 91 my $DISCOVERY_ACCEPT =
596 'application/json;g=apidiscovery.k8s.io;v=v2;as=APIGroupDiscoveryList';
597  
598 # The two discovery documents, in the order they are read.
599 91 my @DISCOVERY_ROOTS = ('/api', '/apis');
600  
601 76 ▶sub _fetch_discovery {
Subroutine _fetch_discovery: called CC=4 SCAR=13.9
602 76 my ($self) = @_;
603  
604 76 my $catalog = { groups => {} };
605  
606 76 for my $root (@DISCOVERY_ROOTS) {
607 129 my ($body, $aggregated) = $self->_discovery_document($root,
608 $self->io->call($self->_discovery_request($root)));
609  
610 106 ▶ if ($aggregated) {
Branch: 2 branches
BranchTrueFalseTotal
if ($aggregated) { } 98 8 106
elsif ($root eq '/api') { } 4 4 8
611 98 $self->_absorb_discovery_list($catalog, $body);
612 } elsif ($root eq '/api') {
613 4 $self->_fetch_discovery_legacy_core($catalog, $body);
614 } else {
615 4 $self->_fetch_discovery_legacy_groups($catalog, $body);
616 }
617 }
618  
619 53 return $catalog;
620 }
621  
622 # The request for one discovery root: what _fetch_discovery sends, and what
623 # prepare_discovery_requests hands an async client to send.
624 131 ▶sub _discovery_request {
Subroutine _discovery_request: called CC=1 SCAR=0.0
625 131 my ($self, $root) = @_;
626 131 return $self->_prepare_request('GET', $root,
627 headers => { Accept => $DISCOVERY_ACCEPT });
628 }
629  
630 # One discovery root's response, checked and decoded - for the synchronous
631 # fetch and absorb_discovery alike. An HTTP error dies as an APIError like
632 # any other checked response, carrying the body that says why (karr k59);
633 # the second value says whether the document is aggregated discovery
634 # (APIGroupDiscoveryList) rather than the legacy one.
635 147 ▶sub _discovery_document {
Subroutine _discovery_document: called CC=3 SCAR=11.3
636 147 my ($self, $root, $response) = @_;
637 147 $self->_check_response($response, "discovery GET $root");
638 121 my $body = $self->_json->decode($response->content);
639 121 ▶ my $kind = ref $body eq 'HASH' ? ($body->{kind} // '') : '';
Branch: 1 branch
BranchTrueFalseTotal
ref $body eq 'HASH' ? : 121 0 121
Condition50%1/2
$body->{"kind"} // ""
l!l
1210
MC/DC0%0/1
$body->{"kind"} // ""
$body->{"kind"}
Truth table50%1/2
A
A= $body->{"kind"}
Aresult
11
00
640 121 return ($body, $kind eq 'APIGroupDiscoveryList');
641 }
642  
643 # APIGroupDiscoveryList (aggregated discovery v2). Each item is one group; the
644 # order of its versions is the cluster's preference, so the first is preferred.
645 106 ▶sub _absorb_discovery_list {
Subroutine _absorb_discovery_list: called CC=15 SCAR=29.5
646 106 my ($self, $catalog, $body) = @_;
647  
648 106 ▶ for my $group_item (@{$body->{items} // []}) {
Condition50%1/2
$body->{"items"} // []
l!l
1060
MC/DC0%0/1
$body->{"items"} // []
$body->{"items"}
Truth table50%1/2
A
A= $body->{"items"}
Aresult
11
00
649 138 ▶ my $group = $group_item->{metadata}{name} // '';
Condition50%1/2
$group_item->{"metadata"}{"name"} // ""
l!l
1380
MC/DC0%0/1
$group_item->{"metadata"}{"name"} // ""
$group_item->{"metadata"}{"name"}
Truth table50%1/2
A
A= $group_item->{"metadata"}{"name"}
Aresult
11
00
650 138 ▶ my @versions = @{$group_item->{versions} // []};
Condition50%1/2
$group_item->{"versions"} // []
l!l
1380
MC/DC0%0/1
$group_item->{"versions"} // []
$group_item->{"versions"}
Truth table50%1/2
A
A= $group_item->{"versions"}
Aresult
11
00
651 138 for my $i (0 .. $#versions) {
652 150 my $vd = $versions[$i];
653 150 my $version = $vd->{version};
654 150 ▶ next unless defined $version && length $version;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $version and length $version 0 150 150
Condition33%1/3
defined $version and length $version
!ll&&!rl&&r
00150
MC/DC0%0/2
defined $version and length $version
defined $version length $version
Truth table33%1/3
A and B
A= defined $versionB= length $version
ABresult
0X0
100
111
655 150 ▶ for my $res (@{$vd->{resources} // []}) {
Condition50%1/2
$vd->{"resources"} // []
l!l
1500
MC/DC0%0/1
$vd->{"resources"} // []
$vd->{"resources"}
Truth table50%1/2
A
A= $vd->{"resources"}
Aresult
11
00
656 178 my $plural = $res->{resource};
657 178 my $rkind = $res->{responseKind}{kind};
658 178 ▶ next unless defined $plural && defined $rkind;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $plural and defined $rkind 0 178 178
Condition33%1/3
defined $plural and defined $rkind
!ll&&!rl&&r
00178
MC/DC0%0/2
defined $plural and defined $rkind
defined $plural defined $rkind
Truth table33%1/3
A and B
A= defined $pluralB= defined $rkind
ABresult
0X0
100
111
659 $self->_catalog_add($catalog, $group, $version, $rkind,
660 178 ▶ $plural, $res->{scope} // '');
Condition50%1/2
$res->{"scope"} // ""
l!l
1780
MC/DC0%0/1
$res->{"scope"} // ""
$res->{"scope"}
Truth table50%1/2
A
A= $res->{"scope"}
Aresult
11
00
661 }
662 # First version served = preferred version for the group.
663 $catalog->{groups}{$group}{preferred} = $version
664 150 ▶ if $i == 0 && exists $catalog->{groups}{$group};
Branch: 1 branch
BranchTrueFalseTotal
if $i == 0 and exists $catalog->{"groups"}{$group} 137 13 150
Condition100%3/3
$i == 0 and exists $catalog->{"groups"}{$group}
!ll&&!rl&&r
121137
MC/DC100%2/2
$i == 0 and exists $catalog->{"groups"}{$group}
$i == 0 exists $catalog->{"groups"}{$group}
Truth table100%3/3
A and B
A= $i == 0B= exists $catalog->{"groups"}{$group}
ABresult
0X0
100
111
665 }
666 }
667 }
668  
669 # Legacy fallback for GET /api: an APIVersions document. Each version's
670 # APIResourceList is fetched from /api/<version>.
671 4 ▶sub _fetch_discovery_legacy_core {
Subroutine _fetch_discovery_legacy_core: called CC=6 SCAR=18.0
672 4 my ($self, $catalog, $body) = @_;
673  
674 4 ▶ my @versions = @{$body->{versions} // []};
Condition50%1/2
$body->{"versions"} // []
l!l
40
MC/DC0%0/1
$body->{"versions"} // []
$body->{"versions"}
Truth table50%1/2
A
A= $body->{"versions"}
Aresult
11
00
675 4 for my $version (@versions) {
676 4 my $path = "/api/$version";
677 4 my $response = $self->_request('GET', $path);
678 4 ▶ next unless $self->_legacy_resource_list_ok($response, $version, $path);
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_legacy_resource_list_ok($response, $version, $path) 1 3 4
679 3 my $list = $self->_json->decode($response->content);
680 3 $self->_absorb_api_resource_list($catalog, '', $version, $list);
681 }
682 $catalog->{groups}{''}{preferred} = $versions[0]
683 4 ▶ if @versions && exists $catalog->{groups}{''};
Branch: 1 branch
BranchTrueFalseTotal
if @versions and exists $catalog->{"groups"}{""} 3 1 4
Condition66%2/3
@versions and exists $catalog->{"groups"}{""}
!ll&&!rl&&r
013
MC/DC50%1/2
@versions and exists $catalog->{"groups"}{""}
@versions exists $catalog->{"groups"}{""}
Truth table66%2/3
A and B
A= @versionsB= exists $catalog->{"groups"}{""}
ABresult
0X0
100
111
684 }
685  
686 # Legacy fallback for GET /apis: an APIGroupList document. Each group/version's
687 # APIResourceList is fetched from /apis/<group>/<version>.
688 4 ▶sub _fetch_discovery_legacy_groups {
Subroutine _fetch_discovery_legacy_groups: called CC=12 SCAR=26.4
689 4 my ($self, $catalog, $body) = @_;
690  
691 4 ▶ for my $group (@{$body->{groups} // []}) {
Condition50%1/2
$body->{"groups"} // []
l!l
40
MC/DC0%0/1
$body->{"groups"} // []
$body->{"groups"}
Truth table50%1/2
A
A= $body->{"groups"}
Aresult
11
00
692 10 my $gname = $group->{name};
693 10 ▶ next unless defined $gname && length $gname;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $gname and length $gname 0 10 10
Condition33%1/3
defined $gname and length $gname
!ll&&!rl&&r
0010
MC/DC0%0/2
defined $gname and length $gname
defined $gname length $gname
Truth table33%1/3
A and B
A= defined $gnameB= length $gname
ABresult
0X0
100
111
694 10 ▶ for my $v (@{$group->{versions} // []}) {
Condition50%1/2
$group->{"versions"} // []
l!l
100
MC/DC0%0/1
$group->{"versions"} // []
$group->{"versions"}
Truth table50%1/2
A
A= $group->{"versions"}
Aresult
11
00
695 10 my $version = $v->{version};
696 10 ▶ next unless defined $version && length $version;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $version and length $version 0 10 10
Condition33%1/3
defined $version and length $version
!ll&&!rl&&r
0010
MC/DC0%0/2
defined $version and length $version
defined $version length $version
Truth table33%1/3
A and B
A= defined $versionB= length $version
ABresult
0X0
100
111
697 10 my $path = "/apis/$gname/$version";
698 10 my $response = $self->_request('GET', $path);
699 10 ▶ next unless $self->_legacy_resource_list_ok($response, "$gname/$version", $path);
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_legacy_resource_list_ok($response, "$gname/$version", $path) 6 4 10
700 4 my $list = $self->_json->decode($response->content);
701 4 $self->_absorb_api_resource_list($catalog, $gname, $version, $list);
702 }
703 10 my $pref = $group->{preferredVersion}{version};
704 $catalog->{groups}{$gname}{preferred} = $pref
705 10 ▶ if defined $pref && exists $catalog->{groups}{$gname};
Branch: 1 branch
BranchTrueFalseTotal
if defined $pref and exists $catalog->{"groups"}{$gname} 4 6 10
Condition66%2/3
defined $pref and exists $catalog->{"groups"}{$gname}
!ll&&!rl&&r
064
MC/DC50%1/2
defined $pref and exists $catalog->{"groups"}{$gname}
defined $pref exists $catalog->{"groups"}{$gname}
Truth table66%2/3
A and B
A= defined $prefB= exists $catalog->{"groups"}{$gname}
ABresult
0X0
100
111
706 }
707 }
708  
709 # Whether the legacy APIResourceList response for one group/version
710 # ($api_version, fetched from $path) can be read into the catalog. An error
711 # status leaves that group/version's Kinds out of the catalog, and so out of
712 # the resource map: any other status than 404 warns, naming it and the reason
713 # the APIError gives, and the other groups are read on (karr k63). A 404 is
714 # silent - the group/version went away between the group list and this
715 # request.
716 14 ▶sub _legacy_resource_list_ok {
Subroutine _legacy_resource_list_ok: called CC=3 SCAR=11.0
717 14 my ($self, $response, $api_version, $path) = @_;
718 14 ▶ return 1 if $response->status < 400;
Branch: 1 branch
BranchTrueFalseTotal
if $response->status < 400 7 7 14
719 7 ▶ return 0 if $response->status == 404;
Branch: 1 branch
BranchTrueFalseTotal
if $response->status == 404 4 3 7
720 3 eval { $self->_check_response($response, "discovery GET $path") };
721 3 $self->_carp_past_builders("discovery: cannot read apiVersion '$api_version',"
722 . ' its Kinds are missing from the resource map: ' . $self->_error_reason($@));
723 3 return 0;
724 }
725  
726 # APIResourceList (legacy per-group discovery). Subresource entries carry a
727 # slash in their name (pods/status) and are skipped; scope comes from the
728 # namespaced boolean.
729 7 ▶sub _absorb_api_resource_list {
Subroutine _absorb_api_resource_list: called CC=8 SCAR=21.6
730 7 my ($self, $catalog, $group, $version, $list) = @_;
731  
732 7 ▶ for my $res (@{$list->{resources} // []}) {
Condition50%1/2
$list->{"resources"} // []
l!l
70
MC/DC0%0/1
$list->{"resources"} // []
$list->{"resources"}
Truth table50%1/2
A
A= $list->{"resources"}
Aresult
11
00
733 9 my $name = $res->{name};
734 9 ▶ next unless defined $name && length $name;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $name and length $name 0 9 9
Condition33%1/3
defined $name and length $name
!ll&&!rl&&r
009
MC/DC0%0/2
defined $name and length $name
defined $name length $name
Truth table33%1/3
A and B
A= defined $nameB= length $name
ABresult
0X0
100
111
735 9 ▶ next if $name =~ m{/};
Branch: 1 branch
BranchTrueFalseTotal
if $name =~ m[/] 1 8 9
736 8 my $kind = $res->{kind};
737 8 ▶ next unless defined $kind;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $kind 0 8 8
738 8 ▶ my $scope = $res->{namespaced} ? 'Namespaced' : 'Cluster';
Branch: 1 branch
BranchTrueFalseTotal
$res->{'namespaced'} ? : 7 1 8
739 8 $self->_catalog_add($catalog, $group, $version, $kind, $name, $scope);
740 }
741 }
742  
743 # Register one Kind (plural, scope) under a group/version in the catalog,
744 # tracking version discovery order.
745 186 ▶sub _catalog_add {
Subroutine _catalog_add: called CC=3 SCAR=11.0
746 186 my ($self, $catalog, $group, $version, $kind, $plural, $scope) = @_;
747  
748 186 ▶ my $gdata = $catalog->{groups}{$group} ||= {
Condition100%2/2
$catalog->{"groups"}{$group} ||= {"preferred", undef, "version_order", [], "versions", {}}
l!l
42144
MC/DC100%1/1
$catalog->{"groups"}{$group} ||= {"preferred", undef, "version_order", [], "versions", {}}
$catalog->{"groups"}{$group}
Truth table100%2/2
A
A= $catalog->{"groups"}{$group}
Aresult
11
00
749 preferred => undef, version_order => [], versions => {},
750 };
751 186 ▶ unless (exists $gdata->{versions}{$version}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $gdata->{"versions"}{$version}) 156 30 186
752 156 $gdata->{versions}{$version} = { kinds => {} };
753 156 push @{$gdata->{version_order}}, $version;
754 }
755 186 $gdata->{versions}{$version}{kinds}{$kind} = {
756 resource => $plural,
757 scope => $scope,
758 };
759 }
760  
761 8 ▶sub invalidate_discovery {
Subroutine invalidate_discovery: called CC=4 SCAR=13.9
Pod documented
762 8 my ($self) = @_;
763  
764  
765 8 $self->_clear_discovery;
766 8 $self->_clear_discovery_error;
767 # Only a map built from the catalog goes, and with it the inner IO::K8s
768 # that captured it at build time, so both are rebuilt on next use. A map
769 # passed to the constructor is the caller's: rebuilding it would drop
770 # their '+My::Class' entries (karr k52), as absorb_discovery knows too.
771 8 ▶ if ($self->_has_resource_map && $self->_resource_map_built) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_has_resource_map and $self->_resource_map_built) 3 5 8
Condition100%3/3
$self->_has_resource_map and $self->_resource_map_built
!ll&&!rl&&r
143
MC/DC100%2/2
$self->_has_resource_map and $self->_resource_map_built
$self->_has_resource_map $self->_resource_map_built
Truth table100%3/3
A and B
A= $self->_has_resource_mapB= $self->_resource_map_built
ABresult
0X0
100
111
772 3 $self->_clear_resource_map;
773 3 ▶ $self->_clear_k8s if $self->_has_k8s;
Branch: 1 branch
BranchTrueFalseTotal
if $self->_has_k8s 2 1 3
774 }
775 8 return 1;
776 }
777  
778 1 ▶sub prepare_discovery_requests {
Subroutine prepare_discovery_requests: called CC=1 SCAR=0.0
Pod documented
779 1 my ($self) = @_;
780  
781  
782 1 return map { ($_ => $self->_discovery_request($_)) } @DISCOVERY_ROOTS;
783 }
784  
785 11 ▶sub absorb_discovery {
Subroutine absorb_discovery: called CC=9 SCAR=22.0
Pod documented
786 11 my ($self, %responses) = @_;
787  
788  
789 11 $self->_croak_unknown_args('absorb_discovery', \%responses, @DISCOVERY_ROOTS);
790 10 my @lists;
791 10 for my $root (@DISCOVERY_ROOTS) {
792 19 ▶ my $response = $responses{$root}
Branch: 1 branch
BranchTrueFalseTotal
my $response = $responses{$root} or croak("absorb_discovery requires the response for $root") 18 1 19
793 or croak "absorb_discovery requires the response for $root";
794 18 my ($body, $aggregated) = $self->_discovery_document($root, $response);
795 15 ▶ push @lists, $aggregated ? $body : undef;
Branch: 1 branch
BranchTrueFalseTotal
$aggregated ? : 13 2 15
796 }
797 # Legacy discovery needs a request per group/version on top, which only
798 # the synchronous path makes: nothing is cached, and the caller falls
799 # back to that path.
800 6 ▶ return if grep { !defined } @lists;
Branch: 1 branch
BranchTrueFalseTotal
if grep {not defined $_;} @lists 2 4 6
801  
802 4 my $catalog = { groups => {} };
803 4 $self->_absorb_discovery_list($catalog, $_) for @lists;
804  
805 # What an earlier catalog built goes, so this one counts: a resource map
806 # built from it, and the inner IO::K8s holding that map. A map passed to
807 # the constructor stays - a caller's '+My::Class' entries must survive.
808 4 ▶ if ($self->_has_resource_map && $self->_resource_map_built) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_has_resource_map and $self->_resource_map_built) 1 3 4
Condition100%3/3
$self->_has_resource_map and $self->_resource_map_built
!ll&&!rl&&r
211
MC/DC100%2/2
$self->_has_resource_map and $self->_resource_map_built
$self->_has_resource_map $self->_resource_map_built
Truth table100%3/3
A and B
A= $self->_has_resource_mapB= $self->_resource_map_built
ABresult
0X0
100
111
809 1 $self->_clear_resource_map;
810 1 ▶ $self->_clear_k8s if $self->_has_k8s;
Branch: 1 branch
BranchTrueFalseTotal
if $self->_has_k8s 1 0 1
811 }
812 4 $self->_clear_discovery_error;
813 4 $self->_set_discovery($catalog);
814 4 return 1;
815 }
816  
817 # The full OpenAPI spec from the cluster, once _fetch_openapi_spec has fetched
818 # it (cached). The only /openapi/v2 download in the client, paid for by
819 # schema_for/compare_schema and (once resolution needs it) AutoGen, never by
820 # construction.
821 91 has _openapi_spec => (
822 is => 'ro',
823 predicate => '_has_openapi_spec',
824 writer => '_set_openapi_spec',
825 );
826  
827 # Fetch /openapi/v2 and keep it. Not a lazy builder: an error status dies as
828 # an APIError like any other checked response, naming the caller's line (karr
829 # k55) - and a Moo-generated accessor between the caller and the check breaks
830 # Carp's trust chain, so from a builder it named a line in here. A failed
831 # fetch keeps nothing, and the next use fetches again.
832 20 ▶sub _fetch_openapi_spec {
Subroutine _fetch_openapi_spec: called CC=2 SCAR=6.9
833 20 my ($self) = @_;
834 20 my $response = $self->_request('GET', '/openapi/v2');
835 20 $self->_check_response($response, 'fetch OpenAPI spec');
836 16 my $spec = $self->_json->decode($response->content);
837 16 $self->_set_openapi_spec($spec);
838 # D12: the inner IO::K8s was built without a spec (so building it never
839 # forced this fetch). Now that the spec exists, drop the cached instance
840 # so its next build passes it through as openapi_spec for AutoGen -- the
841 # same rebuild-on-next-use pattern invalidate_discovery uses.
842 16 ▶ $self->_clear_k8s if $self->_has_k8s;
Branch: 1 branch
BranchTrueFalseTotal
if $self->_has_k8s 3 13 16
843 16 return $spec;
844 }
845  
846 # Get schema definition for a specific type
847 # $kind can be: 'Pod', 'IO::K8s::Api::Core::V1::Pod', or OpenAPI name like 'io.k8s.api.core.v1.Pod'
848 30 ▶sub schema_for {
Subroutine schema_for: called CC=19 SCAR=29.7
Pod documented
849 30 my ($self, $kind) = @_;
850  
851  
852 30 ▶ my $spec = $self->_has_openapi_spec ? $self->_openapi_spec : $self->_fetch_openapi_spec;
Branch: 1 branch
BranchTrueFalseTotal
$self->_has_openapi_spec ? : 10 20 30
853 26 ▶ my $defs = $spec->{definitions} // {};
Condition50%1/2
$spec->{"definitions"} // {}
l!l
260
MC/DC0%0/1
$spec->{"definitions"} // {}
$spec->{"definitions"}
Truth table50%1/2
A
A= $spec->{"definitions"}
Aresult
11
00
854  
855 # If it's already an OpenAPI definition name
856 26 ▶ if (exists $defs->{$kind}) {
Branch: 1 branch
BranchTrueFalseTotal
if (exists $defs->{$kind}) 7 19 26
857 7 return $defs->{$kind};
858 }
859  
860 # Convert class name to OpenAPI definition name. A name nothing resolves
861 # (expand_class answers undef for a qualified one) has no definition to
862 # look up: the same undef a missing definition gets, without turning undef
863 # into a definition name first (karr k47).
864 19 my $class = $self->expand_class($kind);
865 19 ▶ return unless defined $class;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $class 2 17 19
866 # IO::K8s::Api::Core::V1::Pod -> io.k8s.api.core.v1.Pod
867 17 my $def_name = $class;
868 17 $def_name =~ s/^IO::K8s:://;
869 17 $def_name =~ s/::/./g;
870 17 $def_name = 'io.k8s.' . $def_name;
871 # Lowercase all path components except the final type name
872 17 my @parts = split /\./, $def_name;
873 17 $parts[$_] = lc($parts[$_]) for 0 .. $#parts - 1;
874 17 $def_name = join '.', @parts;
875 17 ▶ return $defs->{$def_name} if exists $defs->{$def_name};
Branch: 1 branch
BranchTrueFalseTotal
if exists $defs->{$def_name} 4 13 17
876  
877 # That holds for the IO::K8s::Api:: classes only. Upstream names
878 # apiextensions and apiregistration after their staging repositories
879 # (io.k8s.apiextensions-apiserver..., io.k8s.kube-aggregator...), a CRD's
880 # definition after its group (com.example.v1.Widget), and Unstructured or
881 # a '+My::Class' map onto nothing. Every Kind's definition carries
882 # x-kubernetes-group-version-kind, so the class's GVK finds it; no match
883 # stays undef (karr k54).
884 13 my ($api_version, $gvk_kind) = $self->_schema_gvk($class, $kind);
885 13 ▶ return unless defined $api_version;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $api_version 3 10 13
886 10 ▶ my ($group, $version) = $api_version =~ m{/}
Branch: 1 branch
BranchTrueFalseTotal
$api_version =~ m[/] ? : 10 0 10
887 ? split(m{/}, $api_version, 2)
888 : ('', $api_version);
889 10 for my $name (sort keys %$defs) {
890 my $gvks = ref $defs->{$name} eq 'HASH'
891 46 ▶ ? $defs->{$name}{'x-kubernetes-group-version-kind'} : undef;
Branch: 1 branch
BranchTrueFalseTotal
ref $defs->{$name} eq 'HASH' ? : 46 0 46
892 46 ▶ next unless ref $gvks eq 'ARRAY';
Branch: 1 branch
BranchTrueFalseTotal
unless ref $gvks eq "ARRAY" 4 42 46
893 42 for my $gvk (grep { ref $_ eq 'HASH' } @$gvks) {
894 return $defs->{$name}
895 if ($gvk->{group} // '') eq $group
896 && ($gvk->{version} // '') eq $version
897 42 ▶ && ($gvk->{kind} // '') eq $gvk_kind;
Branch: 1 branch
BranchTrueFalseTotal
if ($gvk->{"group"} // "") eq $group and ($gvk->{"version"} // "") eq $version and ($gvk->{"kind"} // "") eq $gvk_kind 9 33 42
Condition75%9/12
($gvk->{"group"} // "") eq $group and ($gvk->{"version"} // "") eq $version and ($gvk->{"kind"} // "") eq $gvk_kind
!ll&&!rl&&r
2859
($gvk->{"group"} // "") eq $group and ($gvk->{"version"} // "") eq $version
!ll&&!rl&&r
23514
$gvk->{"group"} // ""
l!l
420
$gvk->{"version"} // ""
l!l
190
$gvk->{"kind"} // ""
l!l
140
MC/DC0%0/3
($gvk->{"group"} // "") eq $group and ($gvk->{"version"} // "") eq $version and ($gvk->{"kind"} // "") eq $gvk_kind
$gvk->{"group"} $gvk->{"version"} $gvk->{"kind"}
Truth table25%1/4
A and B and C
A= $gvk->{"group"}B= $gvk->{"version"}C= $gvk->{"kind"}
ABCresult
0XX0
10X0
1100
1111
898 }
899 }
900 1 return;
901 }
902  
903 # The apiVersion and Kind schema_for looks a definition up by, for $class as
904 # expand_class resolved $name: the class's own api_version() and kind(), or -
905 # for IO::K8s::Unstructured, whose class has neither - the Kind of the name
906 # and the apiVersion discovery confirmed for it, exactly as expand_class and
907 # _build_path read it (_discovery_path_meta). Empty when there is none.
908 13 ▶sub _schema_gvk {
Subroutine _schema_gvk: called CC=11 SCAR=25.7
909 13 my ($self, $class, $name) = @_;
910 13 ▶ if ($class eq 'IO::K8s::Unstructured') {
Branch: 1 branch
BranchTrueFalseTotal
if ($class eq "IO::K8s::Unstructured") 1 12 13
911 1 my ($kind, $api_version) = $self->_kind_from_expand_args($name);
912 1 ▶ return unless defined $kind;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $kind 0 1 1
913 1 ▶ my $meta = $self->_discovery_path_meta($kind, $api_version) or return;
Branch: 1 branch
BranchTrueFalseTotal
my $meta = $self->_discovery_path_meta($kind, $api_version) or return 1 0 1
914 1 return ($meta->{api_version}, $kind);
915 }
916 12 ▶ return unless eval { require_module($class); 1 } && $class->can('api_version');
Branch: 1 branch
BranchTrueFalseTotal
unless eval { do { &require_module($class); 1 } } and $class->can("api_version") 3 9 12
Condition66%2/3
eval { do { &require_module($class); 1 } } and $class->can("api_version")
!ll&&!rl&&r
309
MC/DC50%1/2
eval { do { &require_module($class); 1 } } and $class->can("api_version")
eval { do { &require_module($class); 1 } } $class->can("api_version")
Truth table66%2/3
A and B
A= eval { do { &require_module($class); 1 } }B= $class->can("api_version")
ABresult
0X0
100
111
917 # Asked as class methods, and only an answer without error counts - a
918 # class of your own may have them as instance attributes.
919 9 my $api_version = eval { $class->api_version };
920 9 ▶ return unless defined $api_version && length $api_version;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $api_version and length $api_version 0 9 9
Condition33%1/3
defined $api_version and length $api_version
!ll&&!rl&&r
009
MC/DC0%0/2
defined $api_version and length $api_version
defined $api_version length $api_version
Truth table33%1/3
A and B
A= defined $api_versionB= length $api_version
ABresult
0X0
100
111
921 9 ▶ my $kind = $class->can('kind') ? eval { $class->kind } : undef;
Branch: 1 branch
BranchTrueFalseTotal
$class->can('kind') ? : 9 0 9
922 9 ▶ ($kind = $class) =~ s/.*::// unless defined $kind && length $kind;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $kind and length $kind 0 9 9
Condition33%1/3
defined $kind and length $kind
!ll&&!rl&&r
009
MC/DC0%0/2
defined $kind and length $kind
defined $kind length $kind
Truth table33%1/3
A and B
A= defined $kindB= length $kind
ABresult
0X0
100
111
923 9 return ($api_version, $kind);
924 }
925  
926 # Compare local class against cluster schema
927 # Returns comparison result from IO::K8s::Role::Resource->compare_to_schema
928 7 ▶sub compare_schema {
Subroutine compare_schema: called CC=3 SCAR=11.0
Pod documented
929 7 my ($self, $kind) = @_;
930  
931  
932 7 my $class = $self->_expand_class_or_croak($kind);
933 # Unstructured declares only the envelope; held against a definition it
934 # would report every other field as missing locally, which says nothing
935 # about skew (karr k60). Before the /openapi/v2 download, which it would
936 # waste.
937 5 ▶ croak "compare_schema: '$kind' resolves to IO::K8s::Unstructured, which has"
Branch: 1 branch
BranchTrueFalseTotal
if $class eq "IO::K8s::Unstructured" 3 2 5
938 . " no local schema to compare (add a typed class for it to resource_map"
939 . " or with)"
940 if $class eq 'IO::K8s::Unstructured';
941 2 require_module($class);
942  
943 2 my $schema = $self->schema_for($kind);
944 1 ▶ croak "Schema not found for $kind" unless $schema;
Branch: 1 branch
BranchTrueFalseTotal
unless $schema 0 1 1
945  
946 1 return $class->compare_to_schema($schema);
947 }
948  
949 # Internal wrapper with fallback for lazy loading. It runs in the
950 # resource_map builder, most often reached through the k8s one: the warning
951 # goes through _carp_past_builders to name the caller's line, not the line of
952 # the k8s builder that asked for the map (karr k64).
953 47 ▶sub _load_resource_map_from_cluster {
Subroutine _load_resource_map_from_cluster: called CC=2 SCAR=6.9
954 47 my ($self) = @_;
955 47 my $map = eval { $self->fetch_resource_map };
956 47 ▶ if ($@) {
Branch: 1 branch
BranchTrueFalseTotal
if ($@) 12 35 47
957 12 $self->_carp_past_builders('Falling back to the built-in resource map: '
958 . $self->_error_reason($@));
959 12 return IO::K8s->default_resource_map;
960 }
961 35 return $map;
962 }
963  
964 # V0 API compatibility - returns group wrapper objects
965 #
966 # Called as a plain function, not a method: each accessor below shares its name
967 # with the group module it wraps, so once this package is loaded Perl resolves
968 # a bareword like Kubernetes::REST::Core->new(...) against the sub instead of
969 # the class and calls it as Kubernetes::REST::Core()->new(...) - with no
970 # invocant. Returning the class name in that case puts the ->new(...) back on
971 # the class the caller was aiming at.
972 107 ▶sub _v0_group {
Subroutine _v0_group: called CC=2 SCAR=6.9
973 107 my ($group, $self) = @_;
974 107 my $class = "Kubernetes::REST::$group";
975 107 require_module($class);
976 107 ▶ return $class unless defined $self;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $self 17 90 107
977 90 return $class->new(api => $self);
978 }
979  
980 39 ▶sub Core { _v0_group('Core', @_) }
Subroutine Core: called CC=1 SCAR=0.0
Pod undocumented
981 6 ▶sub Apps { _v0_group('Apps', @_) }
Subroutine Apps: called CC=1 SCAR=0.0
Pod undocumented
982 4 ▶sub Batch { _v0_group('Batch', @_) }
Subroutine Batch: called CC=1 SCAR=0.0
Pod undocumented
983 4 ▶sub Networking { _v0_group('Networking', @_) }
Subroutine Networking: called CC=1 SCAR=0.0
Pod undocumented
984 4 ▶sub Storage { _v0_group('Storage', @_) }
Subroutine Storage: called CC=1 SCAR=0.0
Pod undocumented
985 4 ▶sub Policy { _v0_group('Policy', @_) }
Subroutine Policy: called CC=1 SCAR=0.0
Pod undocumented
986 4 ▶sub Autoscaling { _v0_group('Autoscaling', @_) }
Subroutine Autoscaling: called CC=1 SCAR=0.0
Pod undocumented
987 4 ▶sub RbacAuthorization { _v0_group('RbacAuthorization', @_) }
Subroutine RbacAuthorization: called CC=1 SCAR=0.0
Pod undocumented
988 4 ▶sub Certificates { _v0_group('Certificates', @_) }
Subroutine Certificates: called CC=1 SCAR=0.0
Pod undocumented
989 4 ▶sub Coordination { _v0_group('Coordination', @_) }
Subroutine Coordination: called CC=1 SCAR=0.0
Pod undocumented
990 4 ▶sub Events { _v0_group('Events', @_) }
Subroutine Events: called CC=1 SCAR=0.0
Pod undocumented
991 4 ▶sub Scheduling { _v0_group('Scheduling', @_) }
Subroutine Scheduling: called CC=1 SCAR=0.0
Pod undocumented
992 4 ▶sub Authentication { _v0_group('Authentication', @_) }
Subroutine Authentication: called CC=1 SCAR=0.0
Pod documented
993 4 ▶sub Authorization { _v0_group('Authorization', @_) }
Subroutine Authorization: called CC=1 SCAR=0.0
Pod undocumented
994 4 ▶sub Admissionregistration { _v0_group('Admissionregistration', @_) }
Subroutine Admissionregistration: called CC=1 SCAR=0.0
Pod undocumented
995 5 ▶sub Apiextensions { _v0_group('Apiextensions', @_) }
Subroutine Apiextensions: called CC=1 SCAR=0.0
Pod undocumented
996 5 ▶sub Apiregistration { _v0_group('Apiregistration', @_) }
Subroutine Apiregistration: called CC=1 SCAR=0.0
Pod undocumented
997  
998 # Build URL path from class metadata
999 419 ▶sub _build_path {
Subroutine _build_path: called CC=26 SCAR=34.6
1000 419 my ($self, $class, %args) = @_;
1001  
1002 419 require_module($class);
1003  
1004 # An Unstructured resolution (D16 rung 4) carries no api_version()/
1005 # resource_plural()/Namespaced role -- its Kind is data on the instance,
1006 # not a class identity -- so the path metadata comes from the discovery
1007 # catalog instead of the class. The caller (a CRUD method, or a seam
1008 # consumer) passes the Kind (and an object's own apiVersion) via
1009 # _unstructured_hint; api_version/resource/namespaced overrides are honoured
1010 # directly when given, which keeps build_path usable by async wrappers.
1011 419 my ($api_version, $resource, $is_namespaced);
1012 419 my ($kind_hint, $av_hint) = (delete $args{kind}, delete $args{api_version});
1013 419 my $override_resource = delete $args{resource};
1014 419 my $override_namespaced = delete $args{namespaced};
1015 419 ▶ if ($class eq 'IO::K8s::Unstructured') {
Branch: 1 branch
BranchTrueFalseTotal
if ($class eq 'IO::K8s::Unstructured') { } 44 375 419
1016 44 ▶ if (defined $override_resource && defined $override_namespaced
Branch: 1 branch
BranchTrueFalseTotal
if (defined $override_resource and defined $override_namespaced and defined $av_hint) { } 6 38 44
Condition83%5/6
defined $override_resource and defined $override_namespaced and defined $av_hint
!ll&&!rl&&r
3806
defined $override_resource and defined $override_namespaced
!ll&&!rl&&r
3716
MC/DC66%2/3
defined $override_resource and defined $override_namespaced and defined $av_hint
defined $override_resource defined $override_namespaced defined $av_hint
Truth table75%3/4
A and B and C
A= defined $override_resourceB= defined $override_namespacedC= defined $av_hint
ABCresult
0XX0
10X0
1100
1111
1017 && defined $av_hint) {
1018 6 ($api_version, $resource, $is_namespaced) =
1019 ($av_hint, $override_resource, $override_namespaced);
1020 } else {
1021 38 ▶ defined $kind_hint
Branch: 1 branch
BranchTrueFalseTotal
defined $kind_hint or croak("IO::K8s::Unstructured needs a Kind to build a path (pass kind => 'Kind')") 36 2 38
1022 or croak "IO::K8s::Unstructured needs a Kind to build a path"
1023 . " (pass kind => 'Kind')";
1024 36 my $meta = $self->_discovery_path_meta($kind_hint, $av_hint);
1025 36 ▶ unless ($meta) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($meta) 11 25 36
1026 # A failed fetch and a catalog without the Kind both come back
1027 # undef (fail-closed, see _discovery_path_meta); only the
1028 # recorded reason tells them apart, and a catalog that was
1029 # never read must not be reported as one lacking an entry. A
1030 # pinned apiVersion is named: the Kind may well be served in
1031 # another group or version, just not in this one (karr k43).
1032 11 my $reason = $self->_discovery_error;
1033 11 ▶ $reason = $self->_error_reason($reason) if defined $reason;
Branch: 1 branch
BranchTrueFalseTotal
if defined $reason 3 8 11
1034 11 ▶ my $gvk = "Kind '$kind_hint'"
Branch: 1 branch
BranchTrueFalseTotal
defined $av_hint && length $av_hint ? : 5 6 11
Condition66%2/3
defined $av_hint and length $av_hint
!ll&&!rl&&r
605
MC/DC50%1/2
defined $av_hint and length $av_hint
defined $av_hint length $av_hint
Truth table66%2/3
A and B
A= defined $av_hintB= length $av_hint
ABresult
0X0
100
111
1035 . (defined $av_hint && length $av_hint
1036 ? " in apiVersion '$av_hint'" : '');
1037 11 ▶ croak defined $reason
Branch: 1 branch
BranchTrueFalseTotal
defined $reason ? : 3 8 11
1038 ? "discovery failed, so $gvk is unconfirmed"
1039 . " - cannot build a path for IO::K8s::Unstructured:"
1040 . " $reason"
1041 : "no discovery entry for $gvk - cannot"
1042 . " build a path for IO::K8s::Unstructured";
1043 }
1044 ($api_version, $resource, $is_namespaced) =
1045 25 @{$meta}{qw(api_version resource namespaced)};
1046 }
1047 } else {
1048 # Get metadata from class
1049 375 ▶ $api_version = $class->can('api_version') ? $class->api_version : undef;
Branch: 1 branch
BranchTrueFalseTotal
$class->can('api_version') ? : 375 0 375
1050 375 ▶ croak "Cannot determine api_version for $class - override api_version() in your CRD class"
Branch: 1 branch
BranchTrueFalseTotal
unless defined $api_version 0 375 375
1051 unless defined $api_version;
1052 375 ▶ my $kind = $class->can('kind') ? $class->kind : (split('::', $class))[-1];
Branch: 1 branch
BranchTrueFalseTotal
$class->can('kind') ? : 375 0 375
1053 375 $is_namespaced = $class->does('IO::K8s::Role::Namespaced');
1054  
1055 # Use explicit resource_plural if available, otherwise auto-pluralize
1056 375 ▶ if ($class->can('resource_plural') && $class->resource_plural) {
Branch: 1 branch
BranchTrueFalseTotal
if ($class->can('resource_plural') and $class->resource_plural) { } 375 0 375
Condition33%1/3
$class->can("resource_plural") and $class->resource_plural
!ll&&!rl&&r
00375
MC/DC0%0/2
$class->can("resource_plural") and $class->resource_plural
$class->can("resource_plural") $class->resource_plural
Truth table33%1/3
A and B
A= $class->can("resource_plural")B= $class->resource_plural
ABresult
0X0
100
111
1057 375 $resource = $class->resource_plural;
1058 } else {
1059 0 $resource = lc($kind);
1060 0 ▶ if ($resource =~ /(?:ss|sh|ch|x|z)$/) {
Branch: 3 branches
BranchTrueFalseTotal
if ($resource =~ /(?:ss|sh|ch|x|z)$/) { } 0 0 0
elsif ($resource =~ /[^aeiou]y$/) { } 0 0 0
elsif (not $resource =~ /s$/) { } 0 0 0
1061 0 $resource .= 'es'; # class -> classes, ingress -> ingresses
1062 } elsif ($resource =~ /[^aeiou]y$/) {
1063 0 $resource =~ s/y$/ies/; # policy -> policies
1064 } elsif ($resource !~ /s$/) {
1065 0 $resource .= 's'; # pod -> pods
1066 }
1067 }
1068 }
1069  
1070 # Build path based on API group
1071 406 my $path;
1072 406 ▶ if ($api_version =~ m{/}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($api_version =~ m[/]) { } 170 236 406
1073 # Has group: apps/v1 -> /apis/apps/v1/...
1074 170 $path = "/apis/$api_version";
1075 } else {
1076 # Core: v1 -> /api/v1/...
1077 236 $path = "/api/$api_version";
1078 }
1079  
1080 406 ▶ if ($is_namespaced && $args{namespace}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($is_namespaced and $args{"namespace"}) 328 78 406
Condition100%3/3
$is_namespaced and $args{"namespace"}
!ll&&!rl&&r
726328
MC/DC100%2/2
$is_namespaced and $args{"namespace"}
$is_namespaced $args{"namespace"}
Truth table100%3/3
A and B
A= $is_namespacedB= $args{"namespace"}
ABresult
0X0
100
111
1081 328 $path .= "/namespaces/$args{namespace}";
1082 }
1083  
1084 406 $path .= "/$resource";
1085  
1086 406 ▶ if ($args{name}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($args{"name"}) 236 170 406
1087 236 $path .= "/$args{name}";
1088 }
1089  
1090 # Subresource suffix: /status, /log, /exec, /attach, /portforward.
1091 # Every subresource addresses one named resource - without a name the
1092 # suffix would silently land on the collection endpoint instead.
1093 406 ▶ if (defined $args{subresource} && length $args{subresource}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $args{"subresource"} and length $args{"subresource"}) 64 342 406
Condition66%2/3
defined $args{"subresource"} and length $args{"subresource"}
!ll&&!rl&&r
342064
MC/DC50%1/2
defined $args{"subresource"} and length $args{"subresource"}
defined $args{"subresource"} length $args{"subresource"}
Truth table66%2/3
A and B
A= defined $args{"subresource"}B= length $args{"subresource"}
ABresult
0X0
100
111
1094 croak "subresource '$args{subresource}' requires a name for $class"
1095 64 ▶ unless $args{name};
Branch: 1 branch
BranchTrueFalseTotal
unless $args{"name"} 1 63 64
1096 63 $path .= "/$args{subresource}";
1097 }
1098  
1099 405 return $path;
1100 }
1101  
1102 # ============================================================================
1103 # REQUEST / RESPONSE PIPELINE
1104 #
1105 # The API methods (list, get, create, etc.) are built on a 3-step pipeline:
1106 #
1107 # 1. _prepare_request - builds an HTTPRequest (method, url, headers, body)
1108 # 2. io->call - executes the request (pluggable: HTTP::Tiny, async, mock)
1109 # 3. _check_response / _inflate_object / _inflate_list - processes the response
1110 #
1111 # This separation allows different IO backends (sync, async, mock) to slot in
1112 # at step 2 without touching request preparation or response processing.
1113 # ============================================================================
1114  
1115 627 ▶sub _prepare_request {
Subroutine _prepare_request: called CC=15 SCAR=27.3
1116 627 my ($self, $method, $path, %opts) = @_;
1117  
1118 627 my $url = $self->server->endpoint . $path;
1119 627 ▶ my $content_type = $opts{content_type} // 'application/json';
Condition100%2/2
$opts{"content_type"} // "application/json"
l!l
30597
MC/DC100%1/1
$opts{"content_type"} // "application/json"
$opts{"content_type"}
Truth table100%2/2
A
A= $opts{"content_type"}
Aresult
11
00
1120 627 my $body = $opts{body};
1121 627 my $parameters = $opts{parameters};
1122 627 ▶ my $extra_headers = $opts{headers} // {};
Condition100%2/2
$opts{"headers"} // {}
l!l
143484
MC/DC100%1/1
$opts{"headers"} // {}
$opts{"headers"}
Truth table100%2/2
A
A= $opts{"headers"}
Aresult
11
00
1123  
1124 # Append query parameters to URL, keys and values through _query_escape
1125 627 ▶ if ($parameters && %$parameters) {
Branch: 1 branch
BranchTrueFalseTotal
if ($parameters and %$parameters) 158 469 627
Condition100%3/3
$parameters and %$parameters
!ll&&!rl&&r
4672158
MC/DC100%2/2
$parameters and %$parameters
$parameters %$parameters
Truth table100%3/3
A and B
A= $parametersB= %$parameters
ABresult
0X0
100
111
1126 158 my @pairs;
1127 158 for my $key (sort keys %$parameters) {
1128 323 my $val = $parameters->{$key};
1129 323 ▶ next unless defined $val;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $val 0 323 323
1130 323 my $k = $self->_query_escape($key);
1131 323 ▶ if (ref($val) eq 'ARRAY') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $val eq 'ARRAY') { } 10 313 323
1132 10 push @pairs, map { "$k=" . $self->_query_escape($_) } grep { defined } @$val;
1133 } else {
1134 313 push @pairs, "$k=" . $self->_query_escape($val);
1135 }
1136 }
1137 158 ▶ if (@pairs) {
Branch: 1 branch
BranchTrueFalseTotal
if (@pairs) 158 0 158
1138 158 ▶ $url .= ($url =~ /\?/ ? '&' : '?') . join('&', @pairs);
Branch: 1 branch
BranchTrueFalseTotal
$url =~ /\?/ ? : 1 157 158
1139 }
1140 }
1141  
1142 627 my %headers = (
1143 'Content-Type' => $content_type,
1144 'Accept' => 'application/json',
1145 );
1146  
1147 # Only add Authorization header when a token is available
1148 # (client-certificate auth doesn't need a Bearer token)
1149 627 my $token = $self->credentials->token;
1150 627 ▶ if (defined $token && length $token) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $token and length $token) 626 1 627
Condition66%2/3
defined $token and length $token
!ll&&!rl&&r
01626
MC/DC50%1/2
defined $token and length $token
defined $token length $token
Truth table66%2/3
A and B
A= defined $tokenB= length $token
ABresult
0X0
100
111
1151 626 $headers{'Authorization'} = 'Bearer ' . $token;
1152 }
1153 627 ▶ if ($extra_headers && ref($extra_headers) eq 'HASH') {
Branch: 1 branch
BranchTrueFalseTotal
if ($extra_headers and ref $extra_headers eq "HASH") 627 0 627
Condition33%1/3
$extra_headers and ref $extra_headers eq "HASH"
!ll&&!rl&&r
00627
MC/DC0%0/2
$extra_headers and ref $extra_headers eq "HASH"
$extra_headers ref $extra_headers eq "HASH"
Truth table33%1/3
A and B
A= $extra_headersB= ref $extra_headers eq "HASH"
ABresult
0X0
100
111
1154 627 @headers{keys %$extra_headers} = values %$extra_headers;
1155 }
1156  
1157 627 ▶ return Kubernetes::REST::HTTPRequest->new(
Branch: 1 branch
BranchTrueFalseTotal
$body ? : 112 515 627
1158 method => $method,
1159 url => $url,
1160 headers => \%headers,
1161 ($body ? (content => $self->_json->encode($body)) : ()),
1162 );
1163 }
1164  
1165 # Percent-encode a query key or value - but only what would otherwise change
1166 # what the API server reads (karr k35). The server splits a query with Go's
1167 # net/url ParseQuery: into pairs at '&', dropping a pair that holds a ';'
1168 # whole, then key from value at the FIRST '=', reading '+' as a space and
1169 # '%XX' as a byte, and dropping a pair with a malformed '%'. A '#' ends the
1170 # URL before it is sent (URI and HTTP::Tiny take the rest for a fragment), and
1171 # a space, a control character or a non-ASCII byte has no place in a request
1172 # target. Those are encoded - characters as their UTF-8 bytes, the contract
1173 # the JSON body follows too. Everything else stays as it is, above all '=',
1174 # ',', '!', '/', '(', ')' and ':': the server reads them the same either way
1175 # (a value's '=' is past the first one), a selector stays readable in the URL,
1176 # and whoever compares the rendered query - this distribution's mock harness,
1177 # Net::Async::Kubernetes's - sees the string it always did. Keys go the same
1178 # way; they are the API's parameter names, none of which holds an '='.
1179 654 ▶sub _query_escape {
Subroutine _query_escape: called CC=1 SCAR=0.0
1180 654 my ($self, $string) = @_;
1181 654 my $bytes = Encode::encode('UTF-8', "$string");
1182 654 $bytes =~ s/([\x00-\x20\x7F-\xFF%&+#;])/sprintf('%%%02X', ord $1)/ge;
1183 654 return $bytes;
1184 }
1185  
1186 506 ▶sub _check_response {
Subroutine _check_response: called CC=3 SCAR=11.0
1187 506 my ($self, $response, $context) = @_;
1188 506 ▶ if ($response->status >= 400) {
Branch: 1 branch
BranchTrueFalseTotal
if ($response->status >= 400) 74 432 506
1189 # Response bodies are bytes; the error message is read by humans, so
1190 # decode it (leniently - a truncated or non-UTF-8 body must not turn a
1191 # useful API error into an encoding croak).
1192 74 ▶ my $body = Encode::decode('UTF-8', $response->content // '', Encode::FB_DEFAULT);
Condition50%1/2
$response->content // ""
l!l
740
MC/DC0%0/1
$response->content // ""
$response->content
Truth table50%1/2
A
A= $response->content
Aresult
11
00
1193 # An object, so a caller can branch on the status instead of parsing
1194 # the text; it stringifies to the message this croaked with before,
1195 # at the same caller line (karr k50).
1196 74 Kubernetes::REST::APIError->throw(
1197 code => 0 + $response->status,
1198 body => $body,
1199 context => $context,
1200 response => $response,
1201 );
1202 }
1203 432 return $response;
1204 }
1205  
1206 # The name to hand IO::K8s's json_to_object()/struct_to_object() for $class.
1207 # Both resolve a name again, and a single-segment class of your own - '+Gizmo'
1208 # in the resource_map, which expand_class returns as 'Gizmo' - reads to them
1209 # as a Kind: IO::K8s::Gizmo, or whatever class the map gives the Kind Gizmo
1210 # (karr k42). A name that already is a loaded IO::K8s class, which is what
1211 # expand_class resolved and _build_path loaded, therefore goes over as
1212 # '+Class', which IO::K8s takes exactly. Any other name - a short or qualified
1213 # one a seam caller passed - is left for IO::K8s to resolve. The role check
1214 # keeps an unrelated package that merely shares a Kind's name from being
1215 # taken for the class.
1216 260 ▶sub _exact_class {
Subroutine _exact_class: called CC=7 SCAR=23.2
1217 260 my ($self, $class) = @_;
1218 260 ▶ return "+$class"
Branch: 1 branch
BranchTrueFalseTotal
if defined $class and not ref $class and length $class and not $class =~ /\A\+/ and $class->can("does") and $class->does("IO::K8s::Role::Resource") 255 5 260
Condition46%7/15
defined $class and not ref $class and length $class and not $class =~ /\A\+/ and $class->can("does") and $class->does("IO::K8s::Role::Resource")
!ll&&!rl&&r
50255
defined $class and not ref $class and length $class and not $class =~ /\A\+/ and $class->can("does")
!ll&&!rl&&r
05255
defined $class and not ref $class and length $class and not $class =~ /\A\+/
!ll&&!rl&&r
00260
defined $class and not ref $class and length $class
!ll&&!rl&&r
00260
defined $class and not ref $class
!ll&&!rl&&r
00260
MC/DC16%1/6
defined $class and not ref $class and length $class and not $class =~ /\A\+/ and $class->can("does") and $class->does("IO::K8s::Role::Resource")
defined $class not ref $class length $class not $class =~ /\A\+/ $class->can("does") $class->does("IO::K8s::Role::Resource")
Truth table28%2/7
A and not(B) and C and not(D) and E and F
A= defined $classB= not ref $classC= length $classD= not $class =~ /\A\+/E= $class->can("does")F= $class->does("IO::K8s::Role::Resource")
ABCDEFresult
0XXXXX0
10XXXX0
110XXX0
1110XX0
11110X0
1111100
1111111
1219 if defined $class && !ref $class && length $class && $class !~ /\A\+/
1220 && $class->can('does') && $class->does('IO::K8s::Role::Resource');
1221 5 return $class;
1222 }
1223  
1224 156 ▶sub _inflate_object {
Subroutine _inflate_object: called CC=1 SCAR=0.0
1225 156 my ($self, $class, $response) = @_;
1226 156 return $self->k8s->json_to_object($self->_exact_class($class), $response->content);
1227 }
1228  
1229 72 ▶sub _inflate_list {
Subroutine _inflate_list: called CC=11 SCAR=24.3
1230 72 my ($self, $class, $response) = @_;
1231 72 my $struct = $self->_json->decode($response->content);
1232 72 ▶ my $items = $struct->{items} // [];
Condition50%1/2
$struct->{"items"} // []
l!l
720
MC/DC0%0/1
$struct->{"items"} // []
$struct->{"items"}
Truth table50%1/2
A
A= $struct->{"items"}
Aresult
11
00
1233 72 my $exact_class = $self->_exact_class($class);
1234 72 my (@objects, @dropped);
1235 72 for my $i (0 .. $#$items) {
1236 85 my $item = $items->[$i];
1237 85 my $obj = eval { $self->k8s->struct_to_object($exact_class, $item) };
1238 85 ▶ if (defined $obj) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $obj) 81 4 85
1239 81 push @objects, $obj;
1240 81 next;
1241 }
1242 # An item the object model rejects must not disappear without a
1243 # trace: the caller would read a cluster with N unreadable Pods as a
1244 # cluster with N fewer Pods (karr #16). Say which items were dropped
1245 # and why - typically the installed IO::K8s not knowing a field the
1246 # cluster version serves.
1247 4 ▶ my $err = $@ || 'inflated to undef';
Condition50%1/2
$@ || 'inflated to undef'
l!l
40
MC/DC0%0/1
$@ || 'inflated to undef'
$@
Truth table50%1/2
A
A= $@
Aresult
11
00
1248 4 $err =~ s/\s+\z//;
1249 my $name = ref $item eq 'HASH' && ref $item->{metadata} eq 'HASH'
1250 ? $item->{metadata}{name}
1251 4 ▶ : undef;
Branch: 1 branch
BranchTrueFalseTotal
ref $item eq 'HASH' && ref $item->{'metadata'} eq 'HASH' ? : 4 0 4
Condition33%1/3
ref $item eq "HASH" and ref $item->{"metadata"} eq "HASH"
!ll&&!rl&&r
004
MC/DC0%0/2
ref $item eq "HASH" and ref $item->{"metadata"} eq "HASH"
ref $item eq "HASH" ref $item->{"metadata"} eq "HASH"
Truth table33%1/3
A and B
A= ref $item eq "HASH"B= ref $item->{"metadata"} eq "HASH"
ABresult
0X0
100
111
1252 4 ▶ push @dropped,
Branch: 1 branch
BranchTrueFalseTotal
defined $name ? : 4 0 4
1253 "item $i" . (defined $name ? " (name '$name')" : '') . ": $err";
1254 }
1255 72 ▶ if (@dropped) {
Branch: 1 branch
BranchTrueFalseTotal
if (@dropped) 3 69 72
1256 3 carp sprintf
1257 "inflate_list: dropped %d of %d %s items - the returned list is"
1258 . " INCOMPLETE (often IO::K8s version drift against the cluster):\n %s",
1259 scalar @dropped, scalar @$items, $class, join("\n ", @dropped);
1260 }
1261 71 my $meta = $struct->{metadata};
1262 71 ▶ my $metadata = ref $meta eq 'HASH'
Branch: 1 branch
BranchTrueFalseTotal
ref $meta eq 'HASH' ? : 10 61 71
1263 ? $self->k8s->struct_to_object(
1264 'IO::K8s::Apimachinery::Pkg::Apis::Meta::V1::ListMeta', $meta)
1265 : undef;
1266 71 ▶ return IO::K8s::List->new(
Branch: 1 branch
BranchTrueFalseTotal
defined $metadata ? : 10 61 71
1267 items => \@objects, item_class => $class,
1268 (defined $metadata ? (metadata => $metadata) : ()),
1269 );
1270 }
1271  
1272 32 ▶sub _process_watch_chunk {
Subroutine _process_watch_chunk: called CC=13 SCAR=26.0
1273 32 my ($self, $class, $buffer_ref, $chunk) = @_;
1274 32 $$buffer_ref .= $chunk;
1275  
1276 32 my $exact_class = $self->_exact_class($class);
1277 32 my @events;
1278 32 ▶ while ($$buffer_ref =~ s/^([^\n]*)\n//) {
Branch: 1 branch
BranchTrueFalseTotal
if ($$buffer_ref =~ s/^([^\n]*)\n//) 32 32 64
1279 32 my $line = $1;
1280 32 ▶ next unless length $line;
Branch: 1 branch
BranchTrueFalseTotal
unless length $line 0 32 32
1281  
1282 32 my $data = eval { $self->_json->decode($line) };
1283 32 ▶ next unless $data;
Branch: 1 branch
BranchTrueFalseTotal
unless $data 0 32 32
1284  
1285 32 ▶ my $type = $data->{type} // '';
Condition50%1/2
$data->{"type"} // ""
l!l
320
MC/DC0%0/1
$data->{"type"} // ""
$data->{"type"}
Truth table50%1/2
A
A= $data->{"type"}
Aresult
11
00
1286 32 ▶ my $raw_object = $data->{object} // {};
Condition50%1/2
$data->{"object"} // {}
l!l
320
MC/DC0%0/1
$data->{"object"} // {}
$data->{"object"}
Truth table50%1/2
A
A= $data->{"object"}
Aresult
11
00
1287  
1288 # Track resourceVersion for resumability
1289 32 my $rv;
1290 32 ▶ if ($raw_object->{metadata} && $raw_object->{metadata}{resourceVersion}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($raw_object->{"metadata"} and $raw_object->{"metadata"}{"resourceVersion"}) 28 4 32
Condition100%3/3
$raw_object->{"metadata"} and $raw_object->{"metadata"}{"resourceVersion"}
!ll&&!rl&&r
1328
MC/DC100%2/2
$raw_object->{"metadata"} and $raw_object->{"metadata"}{"resourceVersion"}
$raw_object->{"metadata"} $raw_object->{"metadata"}{"resourceVersion"}
Truth table100%3/3
A and B
A= $raw_object->{"metadata"}B= $raw_object->{"metadata"}{"resourceVersion"}
ABresult
0X0
100
111
1291 28 $rv = $raw_object->{metadata}{resourceVersion};
1292 }
1293  
1294 # Inflate the object (ERROR events stay as hashrefs)
1295 32 my $object;
1296 32 ▶ if ($type eq 'ERROR') {
Branch: 1 branch
BranchTrueFalseTotal
if ($type eq 'ERROR') { } 1 31 32
1297 1 $object = $raw_object;
1298 } else {
1299 31 ▶ $object = eval { $self->k8s->struct_to_object($exact_class, $raw_object) }
Condition33%1/3
eval { do { $self->k8s->struct_to_object($exact_class, $raw_object) } } // $raw_object
l!l&&r!l&&!r
3100
MC/DC0%0/2
eval { do { $self->k8s->struct_to_object($exact_class, $raw_object) } } // $raw_object
eval { do { $self->k8s->struct_to_object($exact_class, $raw_object) } } $raw_object
Truth table33%1/3
A // B
A= eval { do { $self->k8s->struct_to_object($exact_class, $raw_object) } }B= $raw_object
ABresult
1X1
011
000
1300 // $raw_object;
1301 }
1302  
1303 push @events, {
1304 event => Kubernetes::REST::WatchEvent->new(
1305 type => $type,
1306 object => $object,
1307 raw => $raw_object,
1308 ),
1309 resourceVersion => $rv,
1310 is_error => ($type eq 'ERROR' ? 1 : 0),
1311 32 ▶ error_code => ($type eq 'ERROR' ? ($raw_object->{code} // 0) : 0),
Branch: 2 branches
BranchTrueFalseTotal
$type eq 'ERROR' ? : 1 31 32
$type eq 'ERROR' ? : 1 31 32
Condition50%1/2
$raw_object->{"code"} // 0
l!l
10
MC/DC0%0/1
$raw_object->{"code"} // 0
$raw_object->{"code"}
Truth table50%1/2
A
A= $raw_object->{"code"}
Aresult
11
00
1312 };
1313 }
1314  
1315 32 return @events;
1316 }
1317  
1318 11 ▶sub _process_log_chunk {
Subroutine _process_log_chunk: called CC=2 SCAR=6.9
1319 11 my ($self, $buffer_ref, $chunk) = @_;
1320 11 $$buffer_ref .= $chunk;
1321  
1322 11 my @events;
1323 11 ▶ while ($$buffer_ref =~ s/^([^\n]*)\n//) {
Branch: 1 branch
BranchTrueFalseTotal
if ($$buffer_ref =~ s/^([^\n]*)\n//) 14 11 25
1324 14 my $line = $1;
1325 14 push @events, Kubernetes::REST::LogEvent->new(line => $line);
1326 }
1327  
1328 11 return @events;
1329 }
1330  
1331 # ============================================================================
1332 # PUBLIC BUILDING BLOCKS FOR ASYNC WRAPPERS
1333 #
1334 # These methods expose the internal request/response pipeline as a stable API
1335 # for async wrappers (e.g. Net::Async::Kubernetes) that need to build requests,
1336 # process responses, and handle streaming without going through the sync
1337 # convenience methods (list, get, watch, log, port_forward, exec, attach, etc.).
1338 # ============================================================================
1339  
1340 26 ▶sub build_path {
Subroutine build_path: called CC=1 SCAR=0.0
Pod documented
1341 26 my ($self, @args) = @_;
1342  
1343  
1344 26 return $self->_build_path(@args);
1345 }
1346  
1347 75 ▶sub prepare_request {
Subroutine prepare_request: called CC=1 SCAR=0.0
Pod documented
1348 75 my ($self, @args) = @_;
1349  
1350  
1351 75 return $self->_prepare_request(@args);
1352 }
1353  
1354 5 ▶sub check_response {
Subroutine check_response: called CC=1 SCAR=0.0
Pod documented
1355 5 my ($self, @args) = @_;
1356  
1357  
1358 5 return $self->_check_response(@args);
1359 }
1360  
1361 5 ▶sub inflate_object {
Subroutine inflate_object: called CC=1 SCAR=0.0
Pod documented
1362 5 my ($self, @args) = @_;
1363  
1364  
1365 5 return $self->_inflate_object(@args);
1366 }
1367  
1368 4 ▶sub inflate_list {
Subroutine inflate_list: called CC=1 SCAR=0.0
Pod documented
1369 4 my ($self, @args) = @_;
1370  
1371  
1372 4 return $self->_inflate_list(@args);
1373 }
1374  
1375 2 ▶sub process_watch_chunk {
Subroutine process_watch_chunk: called CC=1 SCAR=0.0
Pod documented
1376 2 my ($self, @args) = @_;
1377  
1378  
1379 2 return $self->_process_watch_chunk(@args);
1380 }
1381  
1382 6 ▶sub process_log_chunk {
Subroutine process_log_chunk: called CC=1 SCAR=0.0
Pod documented
1383 6 my ($self, @args) = @_;
1384  
1385  
1386 6 return $self->_process_log_chunk(@args);
1387 }
1388  
1389 # Convenience: prepare + call in one step (used by sync CRUD methods)
1390 376 ▶sub _request {
Subroutine _request: called CC=1 SCAR=0.0
1391 376 my ($self, $method, $path, $body, %opts) = @_;
1392 376 my $req = $self->_prepare_request($method, $path,
1393 body => $body,
1394 %opts,
1395 );
1396 376 return $self->io->call($req);
1397 }
1398  
1399 74 ▶sub list {
Subroutine list: called CC=1 SCAR=0.0
Pod documented
1400 74 my ($self, $short_class, %args) = @_;
1401  
1402  
1403 # A misspelt option is not ignored (karr k58): label_selector listed
1404 # unfiltered, namespce across the cluster. name and subresource are out
1405 # too: they made the request a GET of one object, read as an empty list.
1406 74 $self->_croak_unknown_args('list', \%args, qw(namespace labelSelector fieldSelector limit continue resourceVersion));
1407 65 my ($class, $response) = $self->_list_request($short_class, %args);
1408 56 $self->_check_response($response, "list $short_class");
1409  
1410 53 return $self->_inflate_list($class, $response);
1411 }
1412  
1413 # list() up to the response, unchecked: returns the resolved class and the raw
1414 # response. ensure_only() needs the status itself - a 404 there means the Kind
1415 # is not served, not a failure - and must not read it back out of the text
1416 # _check_response croaks with.
1417 88 ▶sub _list_request {
Subroutine _list_request: called CC=6 SCAR=17.9
1418 88 my ($self, $short_class, %args) = @_;
1419  
1420 # Extract query parameters before building path
1421 88 my $label_selector = delete $args{labelSelector};
1422 88 my $field_selector = delete $args{fieldSelector};
1423 88 my %paging = map { $_ => delete $args{$_} } qw(limit continue resourceVersion);
1424  
1425 88 my $class = $self->_expand_class_or_croak($short_class);
1426 75 my $path = $self->_build_path($class, %args,
1427 $self->_unstructured_hint($class, $short_class));
1428  
1429 75 my %params;
1430 75 ▶ $params{labelSelector} = $label_selector if defined $label_selector;
Branch: 1 branch
BranchTrueFalseTotal
if defined $label_selector 21 54 75
1431 75 ▶ $params{fieldSelector} = $field_selector if defined $field_selector;
Branch: 1 branch
BranchTrueFalseTotal
if defined $field_selector 2 73 75
1432 75 ▶ defined $paging{$_} and $params{$_} = $paging{$_} for sort keys %paging;
Branch: 1 branch
BranchTrueFalseTotal
defined $paging{$_} and $params{$_} = $paging{$_} 8 217 225
1433  
1434 75 ▶ my $response = %params
Branch: 1 branch
BranchTrueFalseTotal
%params ? : 26 49 75
1435 ? $self->_request('GET', $path, undef, parameters => \%params)
1436 : $self->_request('GET', $path);
1437 75 return ($class, $response);
1438 }
1439  
1440 57 ▶sub get {
Subroutine get: called CC=6 SCAR=17.9
Pod documented
1441 57 my ($self, $short_class, @rest) = @_;
1442  
1443  
1444 # Support: get('Kind', 'name'), get('Kind', 'name', namespace => 'ns'),
1445 # get('Kind', name => 'name'), get('Kind', name => 'name', namespace => 'ns'),
1446 # each with subresource => ... as well
1447 57 my %args;
1448 57 ▶ if (@rest == 1) {
Branch: 3 branches
BranchTrueFalseTotal
if (@rest == 1) { } 3 54 57
elsif (@rest >= 2 and not $rest[0] =~ /^(name|namespace|subresource)$/) { } 35 19 54
elsif (@rest % 2 == 0) { } 19 0 19
1449 3 $args{name} = $rest[0];
1450 ▶ } elsif (@rest >= 2 && $rest[0] !~ /^(name|namespace|subresource)$/) {
Condition100%3/3
@rest >= 2 and not $rest[0] =~ /^(name|namespace|subresource)$/
!ll&&!rl&&r
21735
MC/DC100%2/2
@rest >= 2 and not $rest[0] =~ /^(name|namespace|subresource)$/
@rest >= 2 not $rest[0] =~ /^(name|namespace|subresource)$/
Truth table100%3/3
A and not(B)
A= @rest >= 2B= not $rest[0] =~ /^(name|namespace|subresource)$/
ABresult
0X0
100
111
1451 # First arg is name, rest are key=value pairs
1452 35 $args{name} = shift @rest;
1453 35 %args = (%args, @rest);
1454 } elsif (@rest % 2 == 0) {
1455 19 %args = @rest;
1456 } else {
1457 0 croak "Invalid arguments to get()";
1458 }
1459 # A misspelt option is not ignored (karr k58). subresource is build_path's
1460 # and works: status answers with the object.
1461 57 $self->_croak_unknown_args('get', \%args, qw(name namespace subresource));
1462  
1463 53 my $class = $self->_expand_class_or_croak($short_class);
1464 44 ▶ croak "name required for get" unless $args{name};
Branch: 1 branch
BranchTrueFalseTotal
unless $args{"name"} 2 42 44
1465  
1466 42 my $path = $self->_build_path($class, %args,
1467 $self->_unstructured_hint($class, $short_class));
1468 42 my $response = $self->_request('GET', $path);
1469 42 $self->_check_response($response, "get $short_class");
1470  
1471 32 return $self->_inflate_object($class, $response);
1472 }
1473  
1474 29 ▶sub create {
Subroutine create: called CC=1 SCAR=0.0
Pod documented
1475 29 my ($self, $object) = @_;
1476  
1477  
1478 29 my ($class, $response) = $self->_create_request($object);
1479 28 $self->_check_response($response, "create $class");
1480  
1481 25 return $self->_inflate_object($class, $response);
1482 }
1483  
1484 # create() up to the response, unchecked, for the same reason as
1485 # _list_request: ensure() takes a 409 as its cue that the object appeared
1486 # since its GET, and must read that off the status, not out of the text
1487 # _check_response croaks with (karr k44).
1488 57 ▶sub _create_request {
Subroutine _create_request: called CC=3 SCAR=11.8
1489 57 my ($self, $object) = @_;
1490  
1491 57 my $class = ref($object);
1492 57 ▶ my $namespace = $object->can('metadata') && $object->metadata
Branch: 1 branch
BranchTrueFalseTotal
$object->can('metadata') && $object->metadata ? : 57 0 57
Condition33%1/3
$object->can("metadata") and $object->metadata
!ll&&!rl&&r
0057
MC/DC0%0/2
$object->can("metadata") and $object->metadata
$object->can("metadata") $object->metadata
Truth table33%1/3
A and B
A= $object->can("metadata")B= $object->metadata
ABresult
0X0
100
111
1493 ? $object->metadata->namespace
1494 : undef;
1495  
1496 57 my $path = $self->_build_path($class, namespace => $namespace,
1497 $self->_unstructured_hint($class, $object));
1498 56 return ($class, $self->_request('POST', $path, $object->TO_JSON));
1499 }
1500  
1501 8 ▶sub update {
Subroutine update: called CC=1 SCAR=0.0
Pod documented
1502 8 my ($self, $object) = @_;
1503  
1504  
1505 8 my ($class, $response) = $self->_update_request($object);
1506 7 $self->_check_response($response, "update $class");
1507  
1508 5 return $self->_inflate_object($class, $response);
1509 }
1510  
1511 # update() up to the response, unchecked, like _create_request: ensure()
1512 # re-fetches and retries on a 409 Conflict and must tell it apart by status.
1513 20 ▶sub _update_request {
Subroutine _update_request: called CC=3 SCAR=11.2
1514 20 my ($self, $object) = @_;
1515  
1516 20 my $class = ref($object);
1517 20 ▶ my $metadata = $object->metadata or croak "object must have metadata";
Branch: 1 branch
BranchTrueFalseTotal
my $metadata = $object->metadata or croak("object must have metadata") 20 0 20
1518 20 ▶ my $name = $metadata->name or croak "object must have metadata.name";
Branch: 1 branch
BranchTrueFalseTotal
my $name = $metadata->name or croak("object must have metadata.name") 20 0 20
1519 20 my $namespace = $metadata->namespace;
1520  
1521 20 my $path = $self->_build_path($class, name => $name, namespace => $namespace,
1522 $self->_unstructured_hint($class, $object));
1523 19 return ($class, $self->_request('PUT', $path, $object->TO_JSON));
1524 }
1525  
1526 91 my %PATCH_TYPES = (
1527 strategic => 'application/strategic-merge-patch+json',
1528 merge => 'application/merge-patch+json',
1529 json => 'application/json-patch+json',
1530 );
1531  
1532 # Shared argument unpacking for patch() and patch_status(): accepts either a
1533 # blessed object or a class plus name, in both the shorthand
1534 # (patch('Pod', 'name', ...)) and the fully keyed (patch('Pod', name => ...))
1535 # call form. $label only appears in croak messages, $default_type is the patch
1536 # strategy used when the caller does not pass one.
1537 #
1538 # Any argument it does not read croaks before anything is sent (karr k61): a
1539 # misspelt namespce patched the object of that name at cluster scope, a
1540 # patch_type => 'merge' went out as a strategic merge patch. An object names
1541 # itself, so with one only the patch and its type are taken.
1542 62 ▶sub _unpack_patch_args {
Subroutine _unpack_patch_args: called CC=15 SCAR=27.6
1543 62 my ($self, $label, $default_type, $class_or_object, @rest) = @_;
1544  
1545 62 my ($class, $name, $namespace, $patch, $patch_type);
1546  
1547 62 ▶ if (ref($class_or_object) && blessed($class_or_object)) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $class_or_object and builtin::blessed($class_or_object)) { } 12 50 62
Condition66%2/3
ref $class_or_object and builtin::blessed($class_or_object)
!ll&&!rl&&r
50012
MC/DC50%1/2
ref $class_or_object and builtin::blessed($class_or_object)
ref $class_or_object builtin::blessed($class_or_object)
Truth table66%2/3
A and B
A= ref $class_or_objectB= builtin::blessed($class_or_object)
ABresult
0X0
100
111
1548 # Object passed: patch($object, patch => {...})
1549 12 my $object = $class_or_object;
1550 12 my %args = @rest;
1551 12 $self->_croak_unknown_args($label, \%args, qw(patch type));
1552 4 $class = ref($object);
1553 4 ▶ my $metadata = $object->metadata or croak "object must have metadata";
Branch: 1 branch
BranchTrueFalseTotal
my $metadata = $object->metadata or croak("object must have metadata") 4 0 4
1554 4 ▶ $name = $metadata->name or croak "object must have metadata.name";
Branch: 1 branch
BranchTrueFalseTotal
$name = $metadata->name or croak("object must have metadata.name") 4 0 4
1555 4 $namespace = $metadata->namespace;
1556 4 ▶ $patch = $args{patch} // croak "$label requires 'patch' parameter";
Condition50%1/2
$args{"patch"} // croak("$label requires 'patch' parameter")
l!l
40
MC/DC0%0/1
$args{"patch"} // croak("$label requires 'patch' parameter")
$args{"patch"}
Truth table50%1/2
A
A= $args{"patch"}
Aresult
11
00
1557 4 ▶ $patch_type = $args{type} // $default_type;
Condition66%2/3
$args{"type"} // $default_type
l!l&&r!l&&!r
130
MC/DC0%0/2
$args{"type"} // $default_type
$args{"type"} $default_type
Truth table66%2/3
A // B
A= $args{"type"}B= $default_type
ABresult
1X1
011
000
1558 } else {
1559 # Class + name: patch('Pod', 'name', namespace => 'ns', patch => {...})
1560 50 my %args;
1561 50 ▶ if (@rest >= 1 && !ref($rest[0]) && $rest[0] !~ /^(name|namespace|patch|type)$/) {
Branch: 2 branches
BranchTrueFalseTotal
if (@rest >= 1 and not ref $rest[0] and not $rest[0] =~ /^(name|namespace|patch|type)$/) { } 31 19 50
elsif (@rest % 2 == 0) { } 17 2 19
Condition50%3/6
@rest >= 1 and not ref $rest[0] and not $rest[0] =~ /^(name|namespace|patch|type)$/
!ll&&!rl&&r
01931
@rest >= 1 and not ref $rest[0]
!ll&&!rl&&r
0050
MC/DC33%1/3
@rest >= 1 and not ref $rest[0] and not $rest[0] =~ /^(name|namespace|patch|type)$/
@rest >= 1 not ref $rest[0] not $rest[0] =~ /^(name|namespace|patch|type)$/
Truth table50%2/4
A and not(B) and not(C)
A= @rest >= 1B= not ref $rest[0]C= not $rest[0] =~ /^(name|namespace|patch|type)$/
ABCresult
0XX0
10X0
1100
1111
1562 31 $args{name} = shift @rest;
1563 31 %args = (%args, @rest);
1564 } elsif (@rest % 2 == 0) {
1565 17 %args = @rest;
1566 } else {
1567 2 croak "Invalid arguments to $label()";
1568 }
1569 48 $self->_croak_unknown_args($label, \%args, qw(name namespace patch type));
1570  
1571 38 $class = $self->_expand_class_or_croak($class_or_object);
1572 34 ▶ $name = $args{name} or croak "name required for $label";
Branch: 1 branch
BranchTrueFalseTotal
$name = $args{"name"} or croak("name required for $label") 31 3 34
1573 31 $namespace = $args{namespace};
1574 31 ▶ $patch = $args{patch} // croak "$label requires 'patch' parameter";
Condition100%2/2
$args{"patch"} // croak("$label requires 'patch' parameter")
l!l
283
MC/DC100%1/1
$args{"patch"} // croak("$label requires 'patch' parameter")
$args{"patch"}
Truth table100%2/2
A
A= $args{"patch"}
Aresult
11
00
1575 28 ▶ $patch_type = $args{type} // $default_type;
Condition66%2/3
$args{"type"} // $default_type
l!l&&r!l&&!r
16120
MC/DC0%0/2
$args{"type"} // $default_type
$args{"type"} $default_type
Truth table66%2/3
A // B
A= $args{"type"}B= $default_type
ABresult
1X1
011
000
1576 }
1577  
1578 32 ▶ my $content_type = $PATCH_TYPES{$patch_type}
Condition100%2/2
$PATCH_TYPES{$patch_type} // croak("Unknown patch type '${patch_type}' (use: strategic, merge, json)")
l!l
302
MC/DC100%1/1
$PATCH_TYPES{$patch_type} // croak("Unknown patch type '${patch_type}' (use: strategic, merge, json)")
$PATCH_TYPES{$patch_type}
Truth table100%2/2
A
A= $PATCH_TYPES{$patch_type}
Aresult
11
00
1579 // croak "Unknown patch type '$patch_type' (use: strategic, merge, json)";
1580  
1581 30 return ($class, $name, $namespace, $patch, $content_type);
1582 }
1583  
1584 32 ▶sub patch {
Subroutine patch: called CC=1 SCAR=0.0
Pod documented
1585 32 my ($self, $class_or_object, @rest) = @_;
1586  
1587  
1588 32 my ($class, $name, $namespace, $patch, $content_type)
1589 = $self->_unpack_patch_args('patch', 'strategic', $class_or_object, @rest);
1590  
1591 15 my $path = $self->_build_path($class, name => $name, namespace => $namespace,
1592 $self->_unstructured_hint($class, $class_or_object));
1593 15 my $response = $self->_request('PATCH', $path, $patch,
1594 content_type => $content_type);
1595 15 $self->_check_response($response, "patch $class");
1596  
1597 14 return $self->_inflate_object($class, $response);
1598 }
1599  
1600 30 ▶sub patch_status {
Subroutine patch_status: called CC=1 SCAR=0.0
Pod documented
1601 30 my ($self, $class_or_object, @rest) = @_;
1602  
1603  
1604 30 my ($class, $name, $namespace, $patch, $content_type)
1605 = $self->_unpack_patch_args('patch_status', 'merge', $class_or_object, @rest);
1606  
1607 15 my $path = $self->_build_path($class,
1608 name => $name,
1609 namespace => $namespace,
1610 subresource => 'status',
1611 $self->_unstructured_hint($class, $class_or_object),
1612 );
1613 15 my $response = $self->_request('PATCH', $path, $patch,
1614 content_type => $content_type);
1615 15 $self->_check_response($response, "patch_status $class");
1616  
1617 14 return $self->_inflate_object($class, $response);
1618 }
1619  
1620 7 ▶sub update_status {
Subroutine update_status: called CC=3 SCAR=11.0
Pod documented
1621 7 my ($self, $object) = @_;
1622  
1623  
1624 7 my $class = ref($object);
1625 7 ▶ my $metadata = $object->metadata or croak "object must have metadata";
Branch: 1 branch
BranchTrueFalseTotal
my $metadata = $object->metadata or croak("object must have metadata") 7 0 7
1626 7 ▶ my $name = $metadata->name or croak "object must have metadata.name";
Branch: 1 branch
BranchTrueFalseTotal
my $name = $metadata->name or croak("object must have metadata.name") 6 1 7
1627 6 my $namespace = $metadata->namespace;
1628  
1629 6 my $path = $self->_build_path($class,
1630 name => $name,
1631 namespace => $namespace,
1632 subresource => 'status',
1633 $self->_unstructured_hint($class, $object),
1634 );
1635 6 my $response = $self->_request('PUT', $path, $object->TO_JSON);
1636 6 $self->_check_response($response, "update_status " . ref($object));
1637  
1638 5 return $self->_inflate_object($class, $response);
1639 }
1640  
1641 40 ▶sub delete {
Subroutine delete: called CC=1 SCAR=0.0
Pod documented
1642 40 my ($self, $class_or_object, @rest) = @_;
1643  
1644  
1645 40 my ($class, $response) = $self->_delete_request($class_or_object, @rest);
1646 25 $self->_check_response($response, "delete $class");
1647  
1648 24 return 1;
1649 }
1650  
1651 # delete() up to the response, unchecked: returns the resolved class and the
1652 # raw response, for the same reason as _list_request - ensure_only() treats a
1653 # 404 (already gone) differently from a failure.
1654 #
1655 # propagationPolicy goes out as the query parameter the API server reads
1656 # DeleteOptions from. Any other argument croaks before anything is sent: a
1657 # misspelt propagationPolicy that was silently dropped would leave a Job's
1658 # Pods orphaned (karr k49).
1659 56 ▶sub _delete_request {
Subroutine _delete_request: called CC=11 SCAR=24.1
1660 56 my ($self, $class_or_object, @rest) = @_;
1661  
1662 56 my ($class, $name, $namespace, %args);
1663  
1664 56 ▶ if (ref($class_or_object)) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $class_or_object) { } 25 31 56
1665 # Object passed: delete($object), delete($object, propagationPolicy => ...)
1666 25 my $object = $class_or_object;
1667 25 ▶ croak "Invalid arguments to delete()" if @rest % 2;
Branch: 1 branch
BranchTrueFalseTotal
if @rest % 2 0 25 25
1668 25 %args = @rest;
1669 25 $self->_croak_unknown_args('delete', \%args, 'propagationPolicy');
1670 23 $self->_propagation_policy_or_croak('delete', $args{propagationPolicy});
1671 23 $class = ref($object);
1672 23 ▶ my $metadata = $object->metadata or croak "object must have metadata";
Branch: 1 branch
BranchTrueFalseTotal
my $metadata = $object->metadata or croak("object must have metadata") 23 0 23
1673 23 ▶ $name = $metadata->name or croak "object must have metadata.name";
Branch: 1 branch
BranchTrueFalseTotal
$name = $metadata->name or croak("object must have metadata.name") 23 0 23
1674 23 $namespace = $metadata->namespace;
1675 } else {
1676 # Support: delete('Kind', 'name'), delete('Kind', 'name', namespace => 'ns'),
1677 # delete('Kind', name => 'name'), delete('Kind', name => 'name', namespace => 'ns'),
1678 # each with propagationPolicy => ... as well
1679 31 ▶ if (@rest == 1) {
Branch: 3 branches
BranchTrueFalseTotal
if (@rest == 1) { } 2 29 31
elsif (@rest >= 2 and not $rest[0] =~ /^(name|namespace|propagationPolicy)$/) { } 21 8 29
elsif (@rest % 2 == 0) { } 8 0 8
1680 2 $args{name} = $rest[0];
1681 ▶ } elsif (@rest >= 2 && $rest[0] !~ /^(name|namespace|propagationPolicy)$/) {
Condition100%3/3
@rest >= 2 and not $rest[0] =~ /^(name|namespace|propagationPolicy)$/
!ll&&!rl&&r
2621
MC/DC100%2/2
@rest >= 2 and not $rest[0] =~ /^(name|namespace|propagationPolicy)$/
@rest >= 2 not $rest[0] =~ /^(name|namespace|propagationPolicy)$/
Truth table100%3/3
A and not(B)
A= @rest >= 2B= not $rest[0] =~ /^(name|namespace|propagationPolicy)$/
ABresult
0X0
100
111
1682 # First arg is name, rest are key=value pairs
1683 21 $args{name} = shift @rest;
1684 21 %args = (%args, @rest);
1685 } elsif (@rest % 2 == 0) {
1686 8 %args = @rest;
1687 } else {
1688 0 croak "Invalid arguments to delete()";
1689 }
1690 31 $self->_croak_unknown_args('delete', \%args,
1691 qw(name namespace propagationPolicy));
1692 29 $self->_propagation_policy_or_croak('delete', $args{propagationPolicy});
1693  
1694 28 $class = $self->_expand_class_or_croak($class_or_object);
1695 21 ▶ $name = $args{name} or croak "name required for delete";
Branch: 1 branch
BranchTrueFalseTotal
$name = $args{"name"} or croak("name required for delete") 19 2 21
1696 19 $namespace = $args{namespace};
1697 }
1698  
1699 42 my $path = $self->_build_path($class, name => $name, namespace => $namespace,
1700 $self->_unstructured_hint($class, $class_or_object));
1701 41 my $policy = $args{propagationPolicy};
1702 41 ▶ return ($class, defined $policy
Branch: 1 branch
BranchTrueFalseTotal
defined $policy ? : 25 16 41
1703 ? $self->_request('DELETE', $path, undef,
1704 parameters => { propagationPolicy => $policy })
1705 : $self->_request('DELETE', $path));
1706 }
1707  
1708 # The propagationPolicy values DeleteOptions takes.
1709 91 my @PROPAGATION_POLICIES = qw(Background Foreground Orphan);
1710  
1711 # Croak unless $policy is undef (none given) or one of @PROPAGATION_POLICIES.
1712 # $label only appears in the message.
1713 75 ▶sub _propagation_policy_or_croak {
Subroutine _propagation_policy_or_croak: called CC=3 SCAR=11.0
1714 75 my ($self, $label, $policy) = @_;
1715 75 ▶ return $policy if !defined $policy || grep { $_ eq $policy } @PROPAGATION_POLICIES;
Branch: 1 branch
BranchTrueFalseTotal
if not defined $policy or grep {$_ eq $policy;} @PROPAGATION_POLICIES 73 2 75
Condition100%3/3
not defined $policy or grep {$_ eq $policy;} @PROPAGATION_POLICIES
l!l&&r!l&&!r
26472
MC/DC100%2/2
not defined $policy or grep {$_ eq $policy;} @PROPAGATION_POLICIES
not defined $policy grep {$_ eq $policy;} @PROPAGATION_POLICIES
Truth table100%3/3
not(A) or B
A= not defined $policyB= grep {$_ eq $policy;} @PROPAGATION_POLICIES
ABresult
1X1
011
000
1716 2 croak "Unknown propagationPolicy '$policy' for $label() (use: "
1717 . join(', ', @PROPAGATION_POLICIES) . ")";
1718 }
1719  
1720 # Croak on the first key of %$args that is not in @allowed, naming it and
1721 # what is allowed, instead of ignoring it. $label only appears in the message.
1722 398 ▶sub _croak_unknown_args {
Subroutine _croak_unknown_args: called CC=2 SCAR=6.9
1723 398 my ($self, $label, $args, @allowed) = @_;
1724 398 my %allowed = map { $_ => 1 } @allowed;
1725 398 my ($unknown) = sort grep { !$allowed{$_} } keys %$args;
1726 398 ▶ return unless defined $unknown;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $unknown 331 67 398
1727 67 croak "Unknown argument '$unknown' to $label() (allowed: "
1728 . join(', ', @allowed) . ")";
1729 }
1730  
1731 # Shared hashref handling for ensure() and ensure_only(): turns a manifest into
1732 # a typed object. A manifest's apiVersion is authoritative - with one, the
1733 # class is resolved as that exact group/version/Kind, and an apiVersion no
1734 # class serves croaks instead of falling back to the version the bare Kind
1735 # happens to map to (HorizontalPodAutoscaler alone means autoscaling/v2, a
1736 # different endpoint and schema than an autoscaling/v1 manifest). Without an
1737 # apiVersion the bare Kind resolves as it always did, and a Kind nothing
1738 # resolves croaks naming it, as for every method taking a resource name -
1739 # not with the module loader's "Can't locate IO/K8s/<Kind>.pm" (karr k48).
1740 # Either way the class is resolved here, so it goes to struct_to_object with
1741 # its '+': IO::K8s takes it as that exact class instead of resolving the name
1742 # again (see _exact_class; the class need not be loaded yet, so this does not
1743 # ask it). $label only appears in croak messages.
1744 24 ▶sub _manifest_to_object {
Subroutine _manifest_to_object: called CC=5 SCAR=16.2
1745 24 my ($self, $label, $manifest) = @_;
1746 24 ▶ my $kind = $manifest->{kind} or croak "$label: hashref must have 'kind'";
Branch: 1 branch
BranchTrueFalseTotal
my $kind = $manifest->{"kind"} or croak("${label}: hashref must have 'kind'") 24 0 24
1747 24 my $api_version = $manifest->{apiVersion};
1748  
1749 24 ▶ return $self->k8s->struct_to_object('+' . $self->_expand_class_or_croak($kind), $manifest)
Branch: 1 branch
BranchTrueFalseTotal
unless defined $api_version and length $api_version 5 19 24
Condition66%2/3
defined $api_version and length $api_version
!ll&&!rl&&r
5019
MC/DC50%1/2
defined $api_version and length $api_version
defined $api_version length $api_version
Truth table66%2/3
A and B
A= defined $api_versionB= length $api_version
ABresult
0X0
100
111
1750 unless defined $api_version && length $api_version;
1751  
1752 19 ▶ my $class = $self->expand_class($kind, $api_version)
Condition100%2/2
$self->expand_class($kind, $api_version) // croak("${label}: no IO::K8s class for apiVersion '${api_version}', kind '${kind}'" . ' (add it to resource_map if it is a CRD)')
l!l
163
MC/DC100%1/1
$self->expand_class($kind, $api_version) // croak("${label}: no IO::K8s class for apiVersion '${api_version}', kind '${kind}'" . ' (add it to resource_map if it is a CRD)')
$self->expand_class($kind, $api_version)
Truth table100%2/2
A
A= $self->expand_class($kind, $api_version)
Aresult
11
00
1753 // croak "$label: no IO::K8s class for apiVersion '$api_version', kind '$kind'"
1754 . " (add it to resource_map if it is a CRD)";
1755 16 return $self->k8s->struct_to_object("+$class", $manifest);
1756 }
1757  
1758 # The apiVersion and Kind an object is an instance of, for ensure() and
1759 # ensure_only() to tell resources apart by. A typed object answers from its
1760 # class (api_version(), kind()); IO::K8s::Unstructured from its instance data,
1761 # since its class name says nothing about what it holds. The last segment of a
1762 # class name is not enough on its own: a CRD is free to reuse a built-in Kind
1763 # name in its own group.
1764 85 ▶sub _api_version_and_kind {
Subroutine _api_version_and_kind: called CC=6 SCAR=19.0
1765 85 my ($self, $object) = @_;
1766 85 ▶ my $api_version = ref($object) eq 'IO::K8s::Unstructured' ? $object->apiVersion
Branch: 2 branches
BranchTrueFalseTotal
ref $object eq 'IO::K8s::Unstructured' ? : 11 74 85
$object->can('api_version') ? : 74 0 74
1767 : $object->can('api_version') ? $object->api_version
1768 : undef;
1769 85 ▶ my $kind = $object->can('kind') ? $object->kind : undef;
Branch: 1 branch
BranchTrueFalseTotal
$object->can('kind') ? : 85 0 85
1770 85 ▶ ($kind = ref $object) =~ s/.*::// unless defined $kind;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $kind 0 85 85
1771 85 ▶ return ($api_version // '', $kind);
Condition50%1/2
$api_version // ""
l!l
850
MC/DC0%0/1
$api_version // ""
$api_version
Truth table50%1/2
A
A= $api_version
Aresult
11
00
1772 }
1773  
1774 51 ▶sub ensure {
Subroutine ensure: called CC=17 SCAR=28.4
Pod documented
1775 51 my ($self, $object, @extra) = @_;
1776  
1777  
1778 # Nothing after the object is read (karr k58): namespace => ... would not
1779 # move it, a second object would not be applied.
1780 51 ▶ croak 'Invalid arguments to ensure(): it takes one object or hashref'
Branch: 1 branch
BranchTrueFalseTotal
if @extra 2 49 51
1781 . ' (ensure_all takes several)'
1782 if @extra;
1783 49 ▶ $object = $self->_manifest_to_object('ensure', $object) if ref($object) eq 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
if ref $object eq "HASH" 15 34 49
1784  
1785 45 my $class = ref($object);
1786 45 ▶ croak "ensure requires an IO::K8s object or hashref" unless blessed($object);
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($object) 0 45 45
1787 45 my ($api_version, $kind) = $self->_api_version_and_kind($object);
1788 # The special cases below are the built-in core v1 PersistentVolumeClaim
1789 # and batch/v1 Job only. The apiVersion is compared exactly, not just its
1790 # group: the Job branch reads batch/v1's status fields and deletes what it
1791 # takes for a failed Job, so an apiVersion it was not written for falls
1792 # through to the plain update, where a mismatch fails loudly instead.
1793 45 ▶ my $is_pvc = $api_version eq 'v1' && $kind eq 'PersistentVolumeClaim';
Condition100%3/3
$api_version eq 'v1' && $kind eq 'PersistentVolumeClaim'
!ll&&!rl&&r
27162
MC/DC100%2/2
$api_version eq 'v1' && $kind eq 'PersistentVolumeClaim'
$api_version eq 'v1' $kind eq 'PersistentVolumeClaim'
Truth table100%3/3
A && B
A= $api_version eq 'v1'B= $kind eq 'PersistentVolumeClaim'
ABresult
0X0
100
111
1794 45 ▶ my $is_job = $api_version eq 'batch/v1' && $kind eq 'Job';
Condition66%2/3
$api_version eq 'batch/v1' && $kind eq 'Job'
!ll&&!rl&&r
3906
MC/DC50%1/2
$api_version eq 'batch/v1' && $kind eq 'Job'
$api_version eq 'batch/v1' $kind eq 'Job'
Truth table66%2/3
A && B
A= $api_version eq 'batch/v1'B= $kind eq 'Job'
ABresult
0X0
100
111
1795 45 ▶ my $metadata = $object->metadata or croak "object must have metadata";
Branch: 1 branch
BranchTrueFalseTotal
my $metadata = $object->metadata or croak("object must have metadata") 45 0 45
1796 45 ▶ my $name = $metadata->name or croak "object must have metadata.name";
Branch: 1 branch
BranchTrueFalseTotal
my $name = $metadata->name or croak("object must have metadata.name") 45 0 45
1797 45 my $namespace = $metadata->namespace;
1798  
1799 45 my @unstructured_hint = $self->_unstructured_hint($class, $object);
1800 45 my $path = $self->_build_path($class, name => $name, namespace => $namespace,
1801 @unstructured_hint);
1802  
1803 # Every branch below is taken on the status of the response, never on the
1804 # text of an error: a 500 or 422 whose message merely contains "404" or
1805 # "409" is a failure, not a missing object or a conflict (karr k44).
1806 44 my $existing;
1807 44 my $response = $self->_request('GET', $path);
1808 44 ▶ unless ($response->status == 404) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($response->status == 404) 16 28 44
1809 16 $self->_check_response($response, "ensure get $kind/$name");
1810 15 $existing = $self->_inflate_object($class, $response);
1811 }
1812  
1813 43 ▶ unless ($existing) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($existing) 28 15 43
1814 28 (undef, $response) = $self->_create_request($object);
1815 28 ▶ unless ($response->status == 409) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($response->status == 409) 23 5 28
1816 23 $self->_check_response($response, "create $class");
1817 22 return $self->_inflate_object($class, $response);
1818 }
1819 # 409 AlreadyExists: it appeared between the GET and the POST. From
1820 # here on it is an existing object like any other, special cases
1821 # included - a Job must not get a PUT onto its immutable Pod template.
1822 5 $response = $self->_request('GET', $path);
1823 5 $self->_check_response($response, "ensure post-409 get $kind/$name");
1824 5 $existing = $self->_inflate_object($class, $response);
1825 }
1826  
1827 20 ▶ return $existing if $is_pvc;
Branch: 1 branch
BranchTrueFalseTotal
if $is_pvc 2 18 20
1828 18 ▶ if ($is_job) {
Branch: 1 branch
BranchTrueFalseTotal
if ($is_job) 6 12 18
1829 # Read from TO_JSON, not status(): an IO::K8s::Unstructured Job has
1830 # no status accessor, its status rides in the unknown-fields bag.
1831 6 ▶ my $status = $existing->TO_JSON->{status} || {};
Condition50%1/2
$existing->TO_JSON->{'status'} || {}
l!l
60
MC/DC0%0/1
$existing->TO_JSON->{'status'} || {}
$existing->TO_JSON->{'status'}
Truth table50%1/2
A
A= $existing->TO_JSON->{'status'}
Aresult
11
00
1832 6 ▶ return $existing if $status->{succeeded} || $status->{active};
Branch: 1 branch
BranchTrueFalseTotal
if $status->{"succeeded"} or $status->{"active"} 3 3 6
Condition100%3/3
$status->{"succeeded"} or $status->{"active"}
l!l&&r!l&&!r
213
MC/DC100%2/2
$status->{"succeeded"} or $status->{"active"}
$status->{"succeeded"} $status->{"active"}
Truth table100%3/3
A or B
A= $status->{"succeeded"}B= $status->{"active"}
ABresult
1X1
011
000
1833 # Background, or the failed Job's Pods would be orphaned - the API
1834 # default for a Job (karr k49) - and the old Job is gone at once, so
1835 # the create does not run into it.
1836 3 eval { $self->delete($existing, propagationPolicy => 'Background') };
1837 3 return $self->create($object);
1838 }
1839 12 $object->metadata->resourceVersion($existing->metadata->resourceVersion);
1840 12 (undef, $response) = $self->_update_request($object);
1841 12 ▶ unless ($response->status == 409) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($response->status == 409) 11 1 12
1842 11 $self->_check_response($response, "update $class");
1843 10 return $self->_inflate_object($class, $response);
1844 }
1845 # 409 Conflict: the resourceVersion moved on server-side. Re-fetch it and
1846 # retry once; a second conflict croaks.
1847 1 $response = $self->_request('GET', $path);
1848 1 $self->_check_response($response, "ensure refetch $kind/$name");
1849 1 $existing = $self->_inflate_object($class, $response);
1850 1 $object->metadata->resourceVersion($existing->metadata->resourceVersion);
1851 1 return $self->update($object);
1852 }
1853  
1854 20 ▶sub ensure_all {
Subroutine ensure_all: called CC=1 SCAR=0.0
Pod documented
1855 20 my ($self, @objects) = @_;
1856  
1857  
1858 20 return map { $self->ensure($_) } @objects;
1859 }
1860  
1861 26 ▶sub ensure_only {
Subroutine ensure_only: called CC=18 SCAR=28.9
Pod documented
1862 26 my ($self, %args) = @_;
1863  
1864  
1865 # A misspelt option is not ignored, before anything is applied: a
1866 # propagation_policy typo would prune with Background, a namespace typo
1867 # scan cluster scope only (karr k53).
1868 26 $self->_croak_unknown_args('ensure_only', \%args,
1869 qw(label objects kinds namespaces propagationPolicy));
1870 23 ▶ my $label = $args{label} or croak "ensure_only requires 'label'";
Branch: 1 branch
BranchTrueFalseTotal
my $label = $args{"label"} or croak("ensure_only requires 'label'") 23 0 23
1871 23 ▶ my @objects = @{$args{objects} || []};
Condition50%1/2
$args{'objects'} || []
l!l
230
MC/DC0%0/1
$args{'objects'} || []
$args{'objects'}
Truth table50%1/2
A
A= $args{'objects'}
Aresult
11
00
1872 23 ▶ my @kinds = @{$args{kinds} || []};
Condition50%1/2
$args{'kinds'} || []
l!l
230
MC/DC0%0/1
$args{'kinds'} || []
$args{'kinds'}
Truth table50%1/2
A
A= $args{'kinds'}
Aresult
11
00
1873 23 ▶ my @namespaces = @{$args{namespaces} || [undef]};
Condition100%2/2
$args{'namespaces'} || [undef]
l!l
212
MC/DC100%1/1
$args{'namespaces'} || [undef]
$args{'namespaces'}
Truth table100%2/2
A
A= $args{'namespaces'}
Aresult
11
00
1874 # Background by default, as kubectl delete does: a pruned Job would
1875 # otherwise orphan its Pods (karr k49). Checked before anything is applied.
1876 my $propagation = $self->_propagation_policy_or_croak('ensure_only',
1877 23 ▶ $args{propagationPolicy} // 'Background');
Condition100%2/2
$args{"propagationPolicy"} // "Background"
l!l
221
MC/DC100%1/1
$args{"propagationPolicy"} // "Background"
$args{"propagationPolicy"}
Truth table100%2/2
A
A= $args{"propagationPolicy"}
Aresult
11
00
1878  
1879 22 for my $obj (@objects) {
1880 19 ▶ $obj = $self->_manifest_to_object('ensure_only', $obj) if ref($obj) eq 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
if ref $obj eq "HASH" 9 10 19
1881 }
1882  
1883 19 my @results = $self->ensure_all(@objects);
1884  
1885 # (group, Kind, namespace, name), taken from the object on both sides -
1886 # never from the kinds entry, which may be qualified ('autoscaling/v1/...')
1887 # and would then match nothing, deleting the objects just applied. Group
1888 # and Kind come from _api_version_and_kind: class-derived for a typed
1889 # object, instance data for IO::K8s::Unstructured. The group keeps the same
1890 # Kind name in two groups apart (Istio's and the Gateway API's Gateway);
1891 # the core group is ''. No version in the key: the same resource listed
1892 # through another version's class is still the same resource.
1893 39 ▶ my $key_of = sub {
Subroutine __ANON__: called CC=3 SCAR=11.0
1894 39 my ($obj) = @_;
1895 39 my ($api_version, $kind) = $self->_api_version_and_kind($obj);
1896 39 my ($group) = $api_version =~ m{\A(.*)/[^/]*\z};
1897 39 my $metadata = $obj->metadata;
1898 39 ▶ return join("\0", $group // '', $kind, $metadata->namespace // '', $metadata->name);
Condition75%3/4
$group // ""
l!l
1920
$metadata->namespace // ""
l!l
390
MC/DC100%1/1
$group // ""
$group
MC/DC0%0/1
$metadata->namespace // ""
$metadata->namespace
Truth table100%2/2
A
A= $group
Aresult
11
00
Truth table50%1/2
A
A= $metadata->namespace
Aresult
11
00
1899 19 };
1900 19 my %expected = map { $key_of->($_) => 1 } @objects;
1901  
1902 # A failed list or delete leaves stale objects behind, so it is reported
1903 # rather than swallowed - but only a real failure: a 404 on the list means
1904 # the cluster does not serve the Kind, a 404 on the delete that the object
1905 # is already gone. The status comes from the response, never from the text
1906 # of an error. The caught croak already names the caller's line, which
1907 # carp adds again, so the reason drops it.
1908 8 ▶ my $where = sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
1909 8 my ($ns) = @_;
1910 8 ▶ return defined $ns ? "in namespace '$ns'" : 'at cluster scope';
Branch: 1 branch
BranchTrueFalseTotal
defined $ns ? : 7 1 8
1911 19 };
1912 8 ▶ my $reason_of = sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1913 8 my ($error) = @_;
1914 8 $error =~ s/\s+\z//;
1915 8 $error =~ s/ at \S+ line \d+\.\z//;
1916 8 return $error;
1917 19 };
1918  
1919 19 for my $kind (@kinds) {
1920 22 for my $ns (@namespaces) {
1921 23 my %list_args = (labelSelector => $label);
1922 23 ▶ $list_args{namespace} = $ns if defined $ns;
Branch: 1 branch
BranchTrueFalseTotal
if defined $ns 22 1 23
1923 23 my $list = eval {
1924 23 my ($class, $response) = $self->_list_request($kind, %list_args);
1925 19 ▶ return if $response->status == 404;
Branch: 1 branch
BranchTrueFalseTotal
if $response->status == 404 1 18 19
1926 18 $self->_check_response($response, "list $kind");
1927 15 $self->_inflate_list($class, $response);
1928 };
1929 23 ▶ unless ($list) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($list) 8 15 23
1930 8 ▶ carp "ensure_only: cannot list $kind " . $where->($ns)
Branch: 1 branch
BranchTrueFalseTotal
if $@ 7 1 8
1931 . ', nothing pruned there: ' . $reason_of->($@)
1932 if $@;
1933 7 next;
1934 }
1935 15 for my $item (@{$list->items}) {
1936 26 ▶ next if $expected{ $key_of->($item) };
Branch: 1 branch
BranchTrueFalseTotal
if $expected{&$key_of($item)} 10 16 26
1937 16 ▶ next if eval {
Branch: 1 branch
BranchTrueFalseTotal
if eval { do { () = $self->_delete_request($item, "propagationPolicy", $propagation); $response->status == 404 or $self->_check_response($response, "delete $class") } } 15 1 16
1938 16 my ($class, $response) = $self->_delete_request($item,
1939 propagationPolicy => $propagation);
1940 16 ▶ $response->status == 404
Condition66%2/3
$response->status == 404 || $self->_check_response($response, "delete $class")
l!l&&r!l&&!r
1150
MC/DC0%0/2
$response->status == 404 || $self->_check_response($response, "delete $class")
$response->status == 404 $self->_check_response($response, "delete $class")
Truth table66%2/3
A || B
A= $response->status == 404B= $self->_check_response($response, "delete $class")
ABresult
1X1
011
000
1941 || $self->_check_response($response, "delete $class");
1942 };
1943 1 my (undef, $item_kind) = $self->_api_version_and_kind($item);
1944 1 carp "ensure_only: cannot delete $item_kind '" . $item->metadata->name
1945 . "' " . $where->($item->metadata->namespace)
1946 . ': ' . $reason_of->($@);
1947 }
1948 }
1949 }
1950  
1951 18 return @results;
1952 }
1953  
1954 12 ▶sub ensure_crd {
Subroutine ensure_crd: called CC=13 SCAR=25.7
Pod documented
1955 12 my $self = shift;
1956  
1957  
1958 12 my (@classes, %opts);
1959 12 ▶ if (@_ && ref $_[0] eq 'ARRAY') {
Branch: 1 branch
BranchTrueFalseTotal
if (@_ and ref $_[0] eq 'ARRAY') { } 8 4 12
Condition100%3/3
@_ and ref $_[0] eq "ARRAY"
!ll&&!rl&&r
138
MC/DC100%2/2
@_ and ref $_[0] eq "ARRAY"
@_ ref $_[0] eq "ARRAY"
Truth table100%3/3
A and B
A= @_B= ref $_[0] eq "ARRAY"
ABresult
0X0
100
111
1960 8 @classes = @{ shift() };
1961 8 %opts = @_;
1962 } else {
1963 4 @classes = @_;
1964 }
1965 # A misspelt option is not ignored, before any class is asked for its CRD
1966 # (karr k61): tiemout => 5 waited the default 30 seconds.
1967 12 $self->_croak_unknown_args('ensure_crd', \%opts, qw(timeout poll_interval storage));
1968 8 ▶ croak "ensure_crd requires at least one CRD class" unless @classes;
Branch: 1 branch
BranchTrueFalseTotal
unless @classes 1 7 8
1969  
1970 7 my $storage = $opts{storage};
1971  
1972 # Group the classes by the CRD they name (metadata.name = "$plural.$group"),
1973 # preserving first-seen order so the applied order is predictable.
1974 7 my (@order, %group);
1975 7 for my $class (@classes) {
1976 9 my $single = $class->to_crd;
1977 9 my $crd_name = $single->metadata->name;
1978 9 ▶ push @order, $crd_name unless exists $group{$crd_name};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $group{$crd_name} 7 2 9
1979 9 push @{ $group{$crd_name} }, { class => $class, single => $single };
1980 }
1981  
1982 7 my @crds;
1983 7 for my $crd_name (@order) {
1984 7 my $members = $group{$crd_name};
1985 7 ▶ if (@$members == 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (@$members == 1) 5 2 7
1986 5 push @crds, $members->[0]{single};
1987 5 next;
1988 }
1989 # Two or more classes are versions of the SAME CRD: assemble one
1990 # multi-version CRD rather than apply competing single-version ones.
1991 2 my @version_classes = map { $_->{class} } @$members;
1992 2 my @versions = map { $_->{single}->spec->versions->[0]->name } @$members;
1993 my $storage_version =
1994 !defined $storage ? undef
1995 2 ▶ : ref $storage eq 'HASH' ? $storage->{$crd_name}
Branch: 2 branches
BranchTrueFalseTotal
!defined($storage) ? : 1 1 2
ref $storage eq 'HASH' ? : 0 1 1
1996 : $storage;
1997 2 ▶ croak "ensure_crd: '$crd_name' is defined by multiple classes ("
Branch: 1 branch
BranchTrueFalseTotal
unless defined $storage_version and length $storage_version 1 1 2
Condition66%2/3
defined $storage_version and length $storage_version
!ll&&!rl&&r
101
MC/DC50%1/2
defined $storage_version and length $storage_version
defined $storage_version length $storage_version
Truth table66%2/3
A and B
A= defined $storage_versionB= length $storage_version
ABresult
0X0
100
111
1998 . join(', ', @version_classes) . ") naming versions ("
1999 . join(', ', @versions) . "); pass storage => '<version>' (or "
2000 . "storage => { '$crd_name' => '<version>' }) to name the storage version"
2001 unless defined $storage_version && length $storage_version;
2002 1 push @crds,
2003 IO::K8s::CRD->new(classes => \@version_classes, storage => $storage_version);
2004 }
2005  
2006 # Apply every CRD first, then wait for each to establish (so establishment
2007 # happens in parallel), then invalidate discovery exactly once.
2008 6 $self->ensure($_) for @crds;
2009 6 my @established = map { $self->_wait_crd_established($_, %opts) } @crds;
2010 3 $self->invalidate_discovery;
2011 3 return @established;
2012 }
2013  
2014 # Poll GET on a CustomResourceDefinition by name until its Established condition
2015 # is True, or croak on timeout. A 404 during polling means "not registered yet"
2016 # and is treated as not-established, not an error. That is read off the status
2017 # of the response, never out of the text of an error: any other failure - a
2018 # 500 whose message merely contains "404" too - ends the wait with that error
2019 # instead of being polled away into a timeout (karr k45).
2020 6 ▶sub _wait_crd_established {
Subroutine _wait_crd_established: called CC=7 SCAR=19.5
2021 6 my ($self, $crd, %opts) = @_;
2022  
2023 6 my $class = ref $crd;
2024 6 my $name = $crd->metadata->name;
2025 6 my $path = $self->_build_path($class, name => $name);
2026 6 ▶ my $timeout = defined $opts{timeout} ? $opts{timeout} : 30;
Branch: 1 branch
BranchTrueFalseTotal
defined $opts{'timeout'} ? : 4 2 6
2027 6 ▶ my $interval = defined $opts{poll_interval} ? $opts{poll_interval} : 1;
Branch: 1 branch
BranchTrueFalseTotal
defined $opts{'poll_interval'} ? : 2 4 6
2028 6 my $deadline = Time::HiRes::time() + $timeout;
2029  
2030 6 while (1) {
2031 8 my $response = $self->_request('GET', $path);
2032 8 ▶ unless ($response->status == 404) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($response->status == 404) 4 4 8
2033 4 $self->_check_response($response, "ensure_crd wait $name");
2034 3 my $current = $self->_inflate_object($class, $response);
2035 3 ▶ return $current if $current && $self->_crd_established($current);
Branch: 1 branch
BranchTrueFalseTotal
if $current and $self->_crd_established($current) 3 0 3
Condition33%1/3
$current and $self->_crd_established($current)
!ll&&!rl&&r
003
MC/DC0%0/2
$current and $self->_crd_established($current)
$current $self->_crd_established($current)
Truth table33%1/3
A and B
A= $currentB= $self->_crd_established($current)
ABresult
0X0
100
111
2036 }
2037 4 ▶ last if Time::HiRes::time() >= $deadline;
Branch: 1 branch
BranchTrueFalseTotal
if &Time::HiRes::time() >= $deadline 2 2 4
2038 2 Time::HiRes::sleep($interval);
2039 }
2040  
2041 2 croak "ensure_crd: CustomResourceDefinition '$name' did not reach the "
2042 . "Established condition within ${timeout}s";
2043 }
2044  
2045 # True when a CustomResourceDefinition object carries an Established=True
2046 # condition in status.conditions.
2047 5 ▶sub _crd_established {
Subroutine _crd_established: called CC=8 SCAR=25.5
2048 5 my ($self, $crd) = @_;
2049 5 ▶ my $status = $crd->status or return 0;
Branch: 1 branch
BranchTrueFalseTotal
my $status = $crd->status or return 0 5 0 5
2050 5 ▶ my $conditions = $status->conditions or return 0;
Branch: 1 branch
BranchTrueFalseTotal
my $conditions = $status->conditions or return 0 5 0 5
2051 5 for my $cond (@$conditions) {
2052 5 ▶ return 1
Branch: 1 branch
BranchTrueFalseTotal
if ($cond->type // "") eq "Established" and ($cond->status // "") eq "True" 5 0 5
Condition42%3/7
($cond->type // "") eq "Established" and ($cond->status // "") eq "True"
!ll&&!rl&&r
005
$cond->type // ""
l!l
50
$cond->status // ""
l!l
50
MC/DC0%0/2
($cond->type // "") eq "Established" and ($cond->status // "") eq "True"
$cond->type $cond->status
Truth table33%1/3
A and B
A= $cond->typeB= $cond->status
ABresult
0X0
100
111
2053 if ($cond->type // '') eq 'Established'
2054 && ($cond->status // '') eq 'True';
2055 }
2056 0 return 0;
2057 }
2058  
2059 36 ▶sub watch {
Subroutine watch: called CC=10 SCAR=23.0
Pod documented
2060 36 my ($self, $short_class, %args) = @_;
2061  
2062  
2063 # A misspelt option is not ignored (karr k58): timeoutSeconds ran for the
2064 # default 300. name is out too: it made the request a GET of one object,
2065 # which the server answers with the object, not a watch.
2066 36 $self->_croak_unknown_args('watch', \%args, qw(on_event timeout
2067 resourceVersion labelSelector fieldSelector namespace));
2068 my $on_event = delete $args{on_event}
2069 30 ▶ or croak "watch requires 'on_event' callback";
Branch: 1 branch
BranchTrueFalseTotal
my $on_event = delete $args{"on_event"} or croak("watch requires 'on_event' callback") 29 1 30
2070 29 ▶ my $timeout = delete $args{timeout} // 300;
Condition100%2/2
delete $args{"timeout"} // 300
l!l
326
MC/DC100%1/1
delete $args{"timeout"} // 300
delete $args{"timeout"}
Truth table100%2/2
A
A= delete $args{"timeout"}
Aresult
11
00
2071 29 my $resource_version = delete $args{resourceVersion};
2072 29 my $label_selector = delete $args{labelSelector};
2073 29 my $field_selector = delete $args{fieldSelector};
2074  
2075 29 my $class = $self->_expand_class_or_croak($short_class);
2076 27 my $path = $self->_build_path($class, %args,
2077 $self->_unstructured_hint($class, $short_class));
2078  
2079 27 my %params = (
2080 watch => 'true',
2081 timeoutSeconds => $timeout,
2082 # BOOKMARK events carry the server's current resourceVersion (k69).
2083 allowWatchBookmarks => 'true',
2084 );
2085 27 ▶ $params{resourceVersion} = $resource_version if defined $resource_version;
Branch: 1 branch
BranchTrueFalseTotal
if defined $resource_version 12 15 27
2086 27 ▶ $params{labelSelector} = $label_selector if defined $label_selector;
Branch: 1 branch
BranchTrueFalseTotal
if defined $label_selector 3 24 27
2087 27 ▶ $params{fieldSelector} = $field_selector if defined $field_selector;
Branch: 1 branch
BranchTrueFalseTotal
if defined $field_selector 3 24 27
2088  
2089 27 my $req = $self->_prepare_request('GET', $path, parameters => \%params);
2090  
2091 27 my $buffer = '';
2092 27 my $last_rv = $resource_version;
2093 # Without a start resourceVersion the server first replays the existing
2094 # objects as ADDED events, each with its own older version: no resume
2095 # point until the first BOOKMARK (k69).
2096 27 ▶ my $trusted = defined $resource_version ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
defined $resource_version ? : 12 15 27
2097 27 my $got_410 = 0;
2098  
2099 30 ▶ my $data_callback = sub {
Subroutine __ANON__: called CC=7 SCAR=19.5
2100 30 my ($chunk) = @_;
2101 30 for my $result ($self->_process_watch_chunk($class, \$buffer, $chunk)) {
2102 30 my $is_bookmark = $result->{event}->type eq 'BOOKMARK';
2103 30 ▶ $trusted = 1 if $is_bookmark;
Branch: 1 branch
BranchTrueFalseTotal
if $is_bookmark 4 26 30
2104 $last_rv = $result->{resourceVersion}
2105 30 ▶ if $result->{resourceVersion} && $trusted;
Branch: 1 branch
BranchTrueFalseTotal
if $result->{"resourceVersion"} and $trusted 13 17 30
Condition100%3/3
$result->{"resourceVersion"} and $trusted
!ll&&!rl&&r
31413
MC/DC100%2/2
$result->{"resourceVersion"} and $trusted
$result->{"resourceVersion"} $trusted
Truth table100%3/3
A and B
A= $result->{"resourceVersion"}B= $trusted
ABresult
0X0
100
111
2106 30 ▶ $got_410 = 1 if $result->{error_code} == 410;
Branch: 1 branch
BranchTrueFalseTotal
if $result->{"error_code"} == 410 1 29 30
2107 30 ▶ next if $is_bookmark;
Branch: 1 branch
BranchTrueFalseTotal
if $is_bookmark 4 26 30
2108 26 $on_event->($result->{event});
2109 }
2110 27 };
2111  
2112 27 my $response = $self->io->call_streaming($req, $data_callback);
2113  
2114 # 410 on the request itself is the same expired resourceVersion as the
2115 # ERROR event; without a resourceVersion it stays an APIError (k69).
2116 25 ▶ croak "Watch expired (410 Gone): resourceVersion too old, re-list to get a fresh resourceVersion"
Branch: 1 branch
BranchTrueFalseTotal
if $response->status == 410 and defined $resource_version 1 24 25
Condition100%3/3
$response->status == 410 and defined $resource_version
!ll&&!rl&&r
2311
MC/DC100%2/2
$response->status == 410 and defined $resource_version
$response->status == 410 defined $resource_version
Truth table100%3/3
A and B
A= $response->status == 410B= defined $resource_version
ABresult
0X0
100
111
2117 if $response->status == 410 && defined $resource_version;
2118 24 $self->_check_response($response, "watch $short_class");
2119  
2120 19 ▶ croak "Watch expired (410 Gone): resourceVersion too old, re-list to get a fresh resourceVersion"
Branch: 1 branch
BranchTrueFalseTotal
if $got_410 1 18 19
2121 if $got_410;
2122  
2123 18 return $last_rv;
2124 }
2125  
2126 23 ▶sub log {
Subroutine log: called CC=17 SCAR=28.5
Pod documented
2127 23 my ($self, $short_class, @rest) = @_;
2128  
2129  
2130 # Support: log('Pod', 'name', ...) and log('Pod', name => 'name', ...)
2131 23 my %args;
2132 23 ▶ if (@rest >= 1 && !ref($rest[0]) && $rest[0] !~ /^(name|namespace|container|follow|tailLines|sinceSeconds|sinceTime|timestamps|previous|limitBytes|on_line)$/) {
Branch: 2 branches
BranchTrueFalseTotal
if (@rest >= 1 and not ref $rest[0] and not $rest[0] =~ /^(name|namespace|container|follow|tailLines|sinceSeconds|sinceTime|timestamps|previous|limitBytes|on_line)$/) { } 20 3 23
elsif (@rest % 2 == 0) { } 3 0 3
Condition50%3/6
@rest >= 1 and not ref $rest[0] and not $rest[0] =~ /^(name|namespace|container|follow|tailLines|sinceSeconds|sinceTime|timestamps|previous|limitBytes|on_line)$/
!ll&&!rl&&r
0320
@rest >= 1 and not ref $rest[0]
!ll&&!rl&&r
0023
MC/DC33%1/3
@rest >= 1 and not ref $rest[0] and not $rest[0] =~ /^(name|namespace|container|follow|tailLines|sinceSeconds|sinceTime|timestamps|previous|limitBytes|on_line)$/
@rest >= 1 not ref $rest[0] not $rest[0] =~ /^(name|namespace|container|follow|tailLines|sinceSeconds|sinceTime|timestamps|previous|limitBytes|on_line)$/
Truth table50%2/4
A and not(B) and not(C)
A= @rest >= 1B= not ref $rest[0]C= not $rest[0] =~ /^(name|namespace|container|follow|tailLines|sinceSeconds|sinceTime|timestamps|previous|limitBytes|on_line)$/
ABCresult
0XX0
10X0
1100
1111
2133 20 $args{name} = shift @rest;
2134 20 %args = (%args, @rest);
2135 } elsif (@rest % 2 == 0) {
2136 3 %args = @rest;
2137 } else {
2138 0 croak "Invalid arguments to log()";
2139 }
2140 # A misspelt option is not ignored (karr k53): tail_lines => 10 would
2141 # fetch the whole log.
2142 23 $self->_croak_unknown_args('log', \%args, qw(name namespace container
2143 follow tailLines sinceSeconds sinceTime timestamps previous limitBytes
2144 on_line));
2145  
2146 20 ▶ croak "name required for log" unless $args{name};
Branch: 1 branch
BranchTrueFalseTotal
unless $args{"name"} 1 19 20
2147  
2148 19 my $on_line = delete $args{on_line};
2149 19 my $container = delete $args{container};
2150 19 my $follow = delete $args{follow};
2151 19 my $tail_lines = delete $args{tailLines};
2152 19 my $since_seconds = delete $args{sinceSeconds};
2153 19 my $since_time = delete $args{sinceTime};
2154 19 my $timestamps = delete $args{timestamps};
2155 19 my $previous = delete $args{previous};
2156 19 my $limit_bytes = delete $args{limitBytes};
2157  
2158 19 my $class = $self->_expand_class_or_croak($short_class);
2159 17 my $path = $self->_build_path($class, %args, subresource => 'log',
2160 $self->_unstructured_hint($class, $short_class));
2161  
2162 17 my %params;
2163 17 ▶ $params{container} = $container if defined $container;
Branch: 1 branch
BranchTrueFalseTotal
if defined $container 2 15 17
2164 17 ▶ $params{follow} = 'true' if $follow;
Branch: 1 branch
BranchTrueFalseTotal
if $follow 1 16 17
2165 17 ▶ $params{tailLines} = $tail_lines if defined $tail_lines;
Branch: 1 branch
BranchTrueFalseTotal
if defined $tail_lines 2 15 17
2166 17 ▶ $params{sinceSeconds} = $since_seconds if defined $since_seconds;
Branch: 1 branch
BranchTrueFalseTotal
if defined $since_seconds 2 15 17
2167 17 ▶ $params{sinceTime} = $since_time if defined $since_time;
Branch: 1 branch
BranchTrueFalseTotal
if defined $since_time 1 16 17
2168 17 ▶ $params{timestamps} = 'true' if $timestamps;
Branch: 1 branch
BranchTrueFalseTotal
if $timestamps 2 15 17
2169 17 ▶ $params{previous} = 'true' if $previous;
Branch: 1 branch
BranchTrueFalseTotal
if $previous 2 15 17
2170 17 ▶ $params{limitBytes} = $limit_bytes if defined $limit_bytes;
Branch: 1 branch
BranchTrueFalseTotal
if defined $limit_bytes 2 15 17
2171  
2172 17 ▶ if ($on_line) {
Branch: 1 branch
BranchTrueFalseTotal
if ($on_line) { } 4 13 17
2173 # Streaming mode
2174 4 my $req = $self->_prepare_request('GET', $path, parameters => \%params);
2175  
2176 4 my $buffer = '';
2177 5 ▶ my $data_callback = sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
2178 5 my ($chunk) = @_;
2179 5 for my $event ($self->_process_log_chunk(\$buffer, $chunk)) {
2180 5 $on_line->($event);
2181 }
2182 4 };
2183  
2184 4 my $response = $self->io->call_streaming($req, $data_callback);
2185 4 $self->_check_response($response, "log $short_class");
2186  
2187 # Process any remaining data in buffer (last line without trailing newline)
2188 4 ▶ if (length $buffer) {
Branch: 1 branch
BranchTrueFalseTotal
if (length $buffer) 0 4 4
2189 0 $on_line->(Kubernetes::REST::LogEvent->new(line => $buffer));
2190 }
2191  
2192 4 return;
2193 } else {
2194 # One-shot mode
2195 13 ▶ my $response = $self->_request('GET', $path, undef,
Branch: 1 branch
BranchTrueFalseTotal
%params ? : 7 6 13
2196 %params ? (parameters => \%params) : (),
2197 );
2198 13 $self->_check_response($response, "log $short_class");
2199  
2200 12 return $response->content;
2201 }
2202 }
2203  
2204 15 ▶sub port_forward {
Subroutine port_forward: called CC=16 SCAR=28.1
Pod documented
2205 15 my ($self, $short_class, @rest) = @_;
2206  
2207  
2208 15 my %args;
2209 15 ▶ if (@rest >= 1 && !ref($rest[0]) && $rest[0] !~ /^(name|namespace|ports|subprotocol|on_open|on_frame|on_close|on_error)$/) {
Branch: 2 branches
BranchTrueFalseTotal
if (@rest >= 1 and not ref $rest[0] and not $rest[0] =~ /^(name|namespace|ports|subprotocol|on_open|on_frame|on_close|on_error)$/) { } 13 2 15
elsif (@rest % 2 == 0) { } 2 0 2
Condition50%3/6
@rest >= 1 and not ref $rest[0] and not $rest[0] =~ /^(name|namespace|ports|subprotocol|on_open|on_frame|on_close|on_error)$/
!ll&&!rl&&r
0213
@rest >= 1 and not ref $rest[0]
!ll&&!rl&&r
0015
MC/DC33%1/3
@rest >= 1 and not ref $rest[0] and not $rest[0] =~ /^(name|namespace|ports|subprotocol|on_open|on_frame|on_close|on_error)$/
@rest >= 1 not ref $rest[0] not $rest[0] =~ /^(name|namespace|ports|subprotocol|on_open|on_frame|on_close|on_error)$/
Truth table50%2/4
A and not(B) and not(C)
A= @rest >= 1B= not ref $rest[0]C= not $rest[0] =~ /^(name|namespace|ports|subprotocol|on_open|on_frame|on_close|on_error)$/
ABCresult
0XX0
10X0
1100
1111
2210 13 $args{name} = shift @rest;
2211 13 %args = (%args, @rest);
2212 } elsif (@rest % 2 == 0) {
2213 2 %args = @rest;
2214 } else {
2215 0 croak "Invalid arguments to port_forward()";
2216 }
2217 # A misspelt option is not ignored (karr k61): whatever was not read went
2218 # on to build_path, which dropped it - on_message never saw a frame.
2219 15 $self->_croak_unknown_args('port_forward', \%args, qw(name namespace ports
2220 subprotocol on_open on_frame on_close on_error));
2221  
2222 10 ▶ croak "name required for port_forward" unless $args{name};
Branch: 1 branch
BranchTrueFalseTotal
unless $args{"name"} 1 9 10
2223  
2224 9 my $ports = delete $args{ports};
2225 9 ▶ croak "ports required for port_forward" unless defined $ports;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $ports 1 8 9
2226 8 ▶ $ports = [$ports] unless ref($ports) eq 'ARRAY';
Branch: 1 branch
BranchTrueFalseTotal
unless ref $ports eq "ARRAY" 0 8 8
2227 8 ▶ croak "ports required for port_forward" unless @$ports;
Branch: 1 branch
BranchTrueFalseTotal
unless @$ports 1 7 8
2228 7 for my $p (@$ports) {
2229 9 ▶ croak "invalid port '$p' for port_forward"
Branch: 1 branch
BranchTrueFalseTotal
unless defined $p and $p =~ /^\d+$/ and $p > 0 and $p <= 65535 2 7 9
Condition77%7/9
defined $p and $p =~ /^\d+$/ and $p > 0 and $p <= 65535
!ll&&!rl&&r
117
defined $p and $p =~ /^\d+$/ and $p > 0
!ll&&!rl&&r
108
defined $p and $p =~ /^\d+$/
!ll&&!rl&&r
018
MC/DC50%2/4
defined $p and $p =~ /^\d+$/ and $p > 0 and $p <= 65535
defined $p $p =~ /^\d+$/ $p > 0 $p <= 65535
Truth table60%3/5
A and B and C and D
A= defined $pB= $p =~ /^\d+$/C= $p > 0D= $p <= 65535
ABCDresult
0XXX0
10XX0
110X0
11100
11111
2230 unless defined($p) && $p =~ /^\d+$/ && $p > 0 && $p <= 65535;
2231 }
2232  
2233 5 ▶ my $subprotocol = delete $args{subprotocol} // 'v4.channel.k8s.io';
Condition100%2/2
delete $args{"subprotocol"} // "v4.channel.k8s.io"
l!l
23
MC/DC100%1/1
delete $args{"subprotocol"} // "v4.channel.k8s.io"
delete $args{"subprotocol"}
Truth table100%2/2
A
A= delete $args{"subprotocol"}
Aresult
11
00
2234 5 my $on_open = delete $args{on_open};
2235 5 my $on_frame = delete $args{on_frame};
2236 5 my $on_close = delete $args{on_close};
2237 5 my $on_error = delete $args{on_error};
2238  
2239 5 my $class = $self->_expand_class_or_croak($short_class);
2240 3 my $path = $self->_build_path($class, %args, subresource => 'portforward',
2241 $self->_unstructured_hint($class, $short_class));
2242  
2243 3 my $req = $self->_prepare_request('GET', $path,
2244 parameters => { ports => $ports },
2245 headers => {
2246 Accept => '*/*',
2247 Connection => 'Upgrade',
2248 Upgrade => 'websocket',
2249 'Sec-WebSocket-Protocol' => $subprotocol,
2250 },
2251 );
2252  
2253 3 my $io = $self->io;
2254 3 ▶ unless ($io->can('call_duplex')) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($io->can("call_duplex")) 1 2 3
2255 1 croak "IO backend does not support port_forward(): missing call_duplex()";
2256 }
2257  
2258 2 return $io->call_duplex($req,
2259 on_open => $on_open,
2260 on_frame => $on_frame,
2261 on_close => $on_close,
2262 on_error => $on_error,
2263 );
2264 }
2265  
2266 16 ▶sub exec {
Subroutine exec: called CC=26 SCAR=32.7
Pod documented
2267 16 my ($self, $short_class, @rest) = @_;
2268  
2269  
2270 16 my %args;
2271 16 ▶ if (@rest >= 1 && !ref($rest[0]) && $rest[0] !~ /^(name|namespace|command|container|stdin|stdout|stderr|tty|subprotocol|on_open|on_frame|on_close|on_error)$/) {
Branch: 2 branches
BranchTrueFalseTotal
if (@rest >= 1 and not ref $rest[0] and not $rest[0] =~ /^(name|namespace|command|container|stdin|stdout|stderr|tty|subprotocol|on_open|on_frame|on_close|on_error)$/) { } 14 2 16
elsif (@rest % 2 == 0) { } 2 0 2
Condition50%3/6
@rest >= 1 and not ref $rest[0] and not $rest[0] =~ /^(name|namespace|command|container|stdin|stdout|stderr|tty|subprotocol|on_open|on_frame|on_close|on_error)$/
!ll&&!rl&&r
0214
@rest >= 1 and not ref $rest[0]
!ll&&!rl&&r
0016
MC/DC33%1/3
@rest >= 1 and not ref $rest[0] and not $rest[0] =~ /^(name|namespace|command|container|stdin|stdout|stderr|tty|subprotocol|on_open|on_frame|on_close|on_error)$/
@rest >= 1 not ref $rest[0] not $rest[0] =~ /^(name|namespace|command|container|stdin|stdout|stderr|tty|subprotocol|on_open|on_frame|on_close|on_error)$/
Truth table50%2/4
A and not(B) and not(C)
A= @rest >= 1B= not ref $rest[0]C= not $rest[0] =~ /^(name|namespace|command|container|stdin|stdout|stderr|tty|subprotocol|on_open|on_frame|on_close|on_error)$/
ABCresult
0XX0
10X0
1100
1111
2272 14 $args{name} = shift @rest;
2273 14 %args = (%args, @rest);
2274 } elsif (@rest % 2 == 0) {
2275 2 %args = @rest;
2276 } else {
2277 0 croak "Invalid arguments to exec()";
2278 }
2279 # A misspelt option is not ignored (karr k61): containr => 'app' ran the
2280 # command in the default container.
2281 16 $self->_croak_unknown_args('exec', \%args, qw(name namespace command
2282 container stdin stdout stderr tty subprotocol on_open on_frame on_close
2283 on_error));
2284  
2285 11 ▶ croak "name required for exec" unless $args{name};
Branch: 1 branch
BranchTrueFalseTotal
unless $args{"name"} 1 10 11
2286  
2287 10 my $command = delete $args{command};
2288 10 ▶ croak "command required for exec" unless defined $command;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $command 1 9 10
2289 9 ▶ $command = [$command] unless ref($command) eq 'ARRAY';
Branch: 1 branch
BranchTrueFalseTotal
unless ref $command eq "ARRAY" 1 8 9
2290 9 ▶ croak "command required for exec" unless @$command;
Branch: 1 branch
BranchTrueFalseTotal
unless @$command 1 8 9
2291 8 for my $part (@$command) {
2292 10 ▶ croak "invalid command element for exec"
Branch: 1 branch
BranchTrueFalseTotal
unless defined $part and not ref $part and length $part 2 8 10
Condition83%5/6
defined $part and not ref $part and length $part
!ll&&!rl&&r
208
defined $part and not ref $part
!ll&&!rl&&r
118
MC/DC66%2/3
defined $part and not ref $part and length $part
defined $part not ref $part length $part
Truth table75%3/4
A and not(B) and C
A= defined $partB= not ref $partC= length $part
ABCresult
0XX0
10X0
1100
1111
2293 unless defined($part) && !ref($part) && length $part;
2294 }
2295  
2296 6 my $container = delete $args{container};
2297 6 ▶ my $stdin = delete($args{stdin}) ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
delete $args{'stdin'} ? : 2 4 6
2298 6 ▶ my $stdout = exists($args{stdout}) ? (delete($args{stdout}) ? 1 : 0) : 1;
Branch: 2 branches
BranchTrueFalseTotal
exists $args{'stdout'} ? : 2 4 6
delete $args{'stdout'} ? : 1 1 2
2299 6 ▶ my $stderr = exists($args{stderr}) ? (delete($args{stderr}) ? 1 : 0) : 1;
Branch: 2 branches
BranchTrueFalseTotal
exists $args{'stderr'} ? : 2 4 6
delete $args{'stderr'} ? : 1 1 2
2300 6 ▶ my $tty = delete($args{tty}) ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
delete $args{'tty'} ? : 2 4 6
2301  
2302 6 ▶ my $subprotocol = delete $args{subprotocol} // 'v4.channel.k8s.io';
Condition100%2/2
delete $args{"subprotocol"} // "v4.channel.k8s.io"
l!l
24
MC/DC100%1/1
delete $args{"subprotocol"} // "v4.channel.k8s.io"
delete $args{"subprotocol"}
Truth table100%2/2
A
A= delete $args{"subprotocol"}
Aresult
11
00
2303 6 my $on_open = delete $args{on_open};
2304 6 my $on_frame = delete $args{on_frame};
2305 6 my $on_close = delete $args{on_close};
2306 6 my $on_error = delete $args{on_error};
2307  
2308 6 my $class = $self->_expand_class_or_croak($short_class);
2309 4 my $path = $self->_build_path($class, %args, subresource => 'exec',
2310 $self->_unstructured_hint($class, $short_class));
2311  
2312 4 ▶ my %params = (
Branch: 4 branches
BranchTrueFalseTotal
$stdin ? : 2 2 4
$stdout ? : 3 1 4
$stderr ? : 3 1 4
$tty ? : 2 2 4
2313 command => $command,
2314 stdin => $stdin ? 'true' : 'false',
2315 stdout => $stdout ? 'true' : 'false',
2316 stderr => $stderr ? 'true' : 'false',
2317 tty => $tty ? 'true' : 'false',
2318 );
2319 4 ▶ $params{container} = $container if defined $container;
Branch: 1 branch
BranchTrueFalseTotal
if defined $container 2 2 4
2320  
2321 4 my $req = $self->_prepare_request('GET', $path,
2322 parameters => \%params,
2323 headers => {
2324 Accept => '*/*',
2325 Connection => 'Upgrade',
2326 Upgrade => 'websocket',
2327 'Sec-WebSocket-Protocol' => $subprotocol,
2328 },
2329 );
2330  
2331 4 my $io = $self->io;
2332 4 ▶ unless ($io->can('call_duplex')) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($io->can("call_duplex")) 1 3 4
2333 1 croak "IO backend does not support exec(): missing call_duplex()";
2334 }
2335  
2336 3 return $io->call_duplex($req,
2337 on_open => $on_open,
2338 on_frame => $on_frame,
2339 on_close => $on_close,
2340 on_error => $on_error,
2341 );
2342 }
2343  
2344 12 ▶sub attach {
Subroutine attach: called CC=19 SCAR=29.5
Pod documented
2345 12 my ($self, $short_class, @rest) = @_;
2346  
2347  
2348 12 my %args;
2349 12 ▶ if (@rest >= 1 && !ref($rest[0]) && $rest[0] !~ /^(name|namespace|container|stdin|stdout|stderr|tty|subprotocol|on_open|on_frame|on_close|on_error)$/) {
Branch: 2 branches
BranchTrueFalseTotal
if (@rest >= 1 and not ref $rest[0] and not $rest[0] =~ /^(name|namespace|container|stdin|stdout|stderr|tty|subprotocol|on_open|on_frame|on_close|on_error)$/) { } 9 3 12
elsif (@rest % 2 == 0) { } 3 0 3
Condition50%3/6
@rest >= 1 and not ref $rest[0] and not $rest[0] =~ /^(name|namespace|container|stdin|stdout|stderr|tty|subprotocol|on_open|on_frame|on_close|on_error)$/
!ll&&!rl&&r
039
@rest >= 1 and not ref $rest[0]
!ll&&!rl&&r
0012
MC/DC33%1/3
@rest >= 1 and not ref $rest[0] and not $rest[0] =~ /^(name|namespace|container|stdin|stdout|stderr|tty|subprotocol|on_open|on_frame|on_close|on_error)$/
@rest >= 1 not ref $rest[0] not $rest[0] =~ /^(name|namespace|container|stdin|stdout|stderr|tty|subprotocol|on_open|on_frame|on_close|on_error)$/
Truth table50%2/4
A and not(B) and not(C)
A= @rest >= 1B= not ref $rest[0]C= not $rest[0] =~ /^(name|namespace|container|stdin|stdout|stderr|tty|subprotocol|on_open|on_frame|on_close|on_error)$/
ABCresult
0XX0
10X0
1100
1111
2350 9 $args{name} = shift @rest;
2351 9 %args = (%args, @rest);
2352 } elsif (@rest % 2 == 0) {
2353 3 %args = @rest;
2354 } else {
2355 0 croak "Invalid arguments to attach()";
2356 }
2357 # A misspelt option is not ignored (karr k61): stdn => 1 attached without
2358 # stdin.
2359 12 $self->_croak_unknown_args('attach', \%args, qw(name namespace container
2360 stdin stdout stderr tty subprotocol on_open on_frame on_close on_error));
2361  
2362 7 ▶ croak "name required for attach" unless $args{name};
Branch: 1 branch
BranchTrueFalseTotal
unless $args{"name"} 1 6 7
2363  
2364 6 my $container = delete $args{container};
2365 6 ▶ my $stdin = delete($args{stdin}) ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
delete $args{'stdin'} ? : 2 4 6
2366 6 ▶ my $stdout = exists($args{stdout}) ? (delete($args{stdout}) ? 1 : 0) : 1;
Branch: 2 branches
BranchTrueFalseTotal
exists $args{'stdout'} ? : 2 4 6
delete $args{'stdout'} ? : 1 1 2
2367 6 ▶ my $stderr = exists($args{stderr}) ? (delete($args{stderr}) ? 1 : 0) : 1;
Branch: 2 branches
BranchTrueFalseTotal
exists $args{'stderr'} ? : 2 4 6
delete $args{'stderr'} ? : 1 1 2
2368 6 ▶ my $tty = delete($args{tty}) ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
delete $args{'tty'} ? : 2 4 6
2369  
2370 6 ▶ my $subprotocol = delete $args{subprotocol} // 'v4.channel.k8s.io';
Condition100%2/2
delete $args{"subprotocol"} // "v4.channel.k8s.io"
l!l
24
MC/DC100%1/1
delete $args{"subprotocol"} // "v4.channel.k8s.io"
delete $args{"subprotocol"}
Truth table100%2/2
A
A= delete $args{"subprotocol"}
Aresult
11
00
2371 6 my $on_open = delete $args{on_open};
2372 6 my $on_frame = delete $args{on_frame};
2373 6 my $on_close = delete $args{on_close};
2374 6 my $on_error = delete $args{on_error};
2375  
2376 6 my $class = $self->_expand_class_or_croak($short_class);
2377 4 my $path = $self->_build_path($class, %args, subresource => 'attach',
2378 $self->_unstructured_hint($class, $short_class));
2379  
2380 4 ▶ my %params = (
Branch: 4 branches
BranchTrueFalseTotal
$stdin ? : 2 2 4
$stdout ? : 3 1 4
$stderr ? : 3 1 4
$tty ? : 2 2 4
2381 stdin => $stdin ? 'true' : 'false',
2382 stdout => $stdout ? 'true' : 'false',
2383 stderr => $stderr ? 'true' : 'false',
2384 tty => $tty ? 'true' : 'false',
2385 );
2386 4 ▶ $params{container} = $container if defined $container;
Branch: 1 branch
BranchTrueFalseTotal
if defined $container 2 2 4
2387  
2388 4 my $req = $self->_prepare_request('GET', $path,
2389 parameters => \%params,
2390 headers => {
2391 Accept => '*/*',
2392 Connection => 'Upgrade',
2393 Upgrade => 'websocket',
2394 'Sec-WebSocket-Protocol' => $subprotocol,
2395 },
2396 );
2397  
2398 4 my $io = $self->io;
2399 4 ▶ unless ($io->can('call_duplex')) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($io->can("call_duplex")) 1 3 4
2400 1 croak "IO backend does not support attach(): missing call_duplex()";
2401 }
2402  
2403 3 return $io->call_duplex($req,
2404 on_open => $on_open,
2405 on_frame => $on_frame,
2406 on_close => $on_close,
2407 on_error => $on_error,
2408 );
2409 }
2410  
2411 91 1;
2412  
2413 __END__
« lib/Kubernetes/REST/V0Group.pm ↑ Summary lib/Kubernetes/REST/CLI/Minikube.pm »