►
Description
Agent repository: https://gitlab.com/gitlab-org/cluster-integration/gitlab-agent
A
Hello
there
yeah
this
is
It's
Time
to
Go
episode,
number
I,
don't
know
five,
maybe
or
four,
and
we
decided
to
do
an
overview
of
the
GitHub
agent
project
of
the
repository
and
the
code
structure,
and
maybe
Timo
will
have
questions
or
you
know
how
things
to
talk
about.
Let's,
let's
see
so
this
is
the
repository
like
I,
don't
know
what
exactly
to
talk
about
so
I
will
just
start
somewhere
and
then
we
will
go
somewhere
from
from
there.
A
So
the
we
have
two
binaries
that
I
built
from
this
repository.
This
is
a
cast
and
Agent
K.
They
are
here
in
CMG,
then
we
have
some
documentation,
then
the
doc
directory.
This
is
mostly
technical
design
decisions
that
we
document.
We
try
to
document
anything
non-trivial
here,
then
I,
don't
know
some
examples.
I
think
this
is
like
git
model
is
pointing
to
some
other
posters.
I
haven't
talked
to
them
for
quite
a
while
and
then
pkgs.
A
Like
exported
packages
like
public
theoretically
for
public
consumption
or
public
API,
to
some
extent,
this
is
a
pass
configuration
brought
above
for
cast
configuration.
Then
plot
above
for
Agent
K
configuration
the
one
that's
stored
in
the
git
repository
the
agent
configuration
report
is
through.
Then
we
have
the
generated
docs
here,
thanks
Timor,
then
we
also
have
soft
forecast.
We
also
have
the
config
example
yaml.
This
is
generated
based
on
this
test.
A
Well,
this
test
constructs
an
object
like
minimal
configuration,
and
then
it
validates
that
the
contents
of
this
file
match
the
minimal
configuration
with
defaults
applied
the
test
fails,
if
that
it
doesn't
matter.
So
it's
like
an
example
of
not
a
minimal
configuration,
but
it's
the
it
shows
the
defaults
that
are
encoded
in
code.
A
It's
convenient
to
give
a
link
for
to
the
file
and
the
particular
line
and
say
hey.
This
is
the
default
value
rather
than
digging
through
code
yeah.
So
this
is
basically
all
defaults
and
I
also
leave
comments
here
in
certain
places
where
this
is
the
default.
Well,
no,
this
is
the
parameter
that
can
be
put
here
and
also
some
required
parameters
here
as
well.
A
A
B
A
Probably
so
what
else?
The
internal,
which
I
skipped
is
the
code
for
everything,
and
that
is
not
in
PKG
and
not
in
CMD.
So
API
is
just
internal
API
types
that
are
used
throughout
the
code
base,
which
are
not
too
many
like
our
domain.
Api
types,
token
information
about
the
guitarist
server
information
about
an
agent.
A
This
is
used
for
bycast,
not
by
Agent
K,
by
the
way,
just
like
information
about
guitar
and
so
on.
We
get
this
from
rails,
basically
and
information
about
the
project.
This
is
for
github's,
again
information
about
where
in
gitale
this
lives.
This
types
is
important
from
Italy
we
have
a
dependency
on
Italy
Italy's,
gitlabs
grpc
wrapper
around
git
to
simplify
it
a
lot,
but
that's
the
main
thing
main
feature
of
it,
and
then
this
is
a
helper
function
and
then
the
next
gitale
is.
A
Things
to
talk
to
Italy,
like
special
any
code
that
we
use
to
talk
to
Italy
or
parse
responses,
or
anything
like
that.
Fetch
files,
like
visit
the
directory
with
files,
Paul
a
repository,
pull
connections
to
Italy,
because
Italy's
multiple
servers
and
we
establish
grpc
connections
to
different
servers.
So
basically-
and
we
have
reference
discovery
copied
and
modified
optimized.
B
A
Is
the
the
this
is
a
very
deep
web
client
to
use,
but
it's
a
eggplant
one
of
a
few.
So
it's
basically
a
wrapper
around
the
library,
HTTP
client,
with
functional
options.
Pattern
applied
plus
we
have
a
few
convenience
response
handlers
which
allow
you
to
like
read
the
response
and
Marshall
it
into
an
object
and
blah
blah
blah
handle
different
things.
A
B
A
The
response
from
the
server
like
we
are
mastered
into
this
extract,
and
this
is
like
the
function
that
is
called.
It
gets
the
client
token
and
options,
and
then
this
is
the
interesting
kind
of
business
logic
of
this
function
and
then
it
just
populates
the
response
from
like
populates
an
object.
It
returns
based
on
this
response.
So
this
is
an
internal
kind
of
thing
to
this
package.
As
you
can
see,
it's
an
exported
and
it
returns
an
API
type
which
looks
slightly
different
to
to
this.
To
this
struct.
A
B
A
A
A
B
B
A
A
Well,
it's
convenient
actually
because
of
validation
code
is
generated
right
with
handwritten
types.
We
don't
do
any
validation
here
and
with
this
one
we
will
do
validation,
so
I
think
we
should
probably
change
all
of
them
so
that
we
can
Define
validation,
rules
in
product
in
the
protofile
and
then
validate
them.
A
Anyway-
and
this
is
the
GitHub
module
and
then
this
is
the
meat
of
the
project,
so
it's
modules
that
it's
a
way
to
compartmentalize
functionality
into
building
blocks
and
described
here
in
this
readme.
No,
no,
it's
not
here.
It's
just
right
in
the
dock
modules
yeah
this
is
described.
This
describes
what
it
is.
Well,
it's
indirectly
with
directories,
but
each
one
is:
where
is
a
good
example?.
A
This
one,
you
have
stuff,
that's
part
of
the
agent
and
stuff,
that's
part
of
the
server,
and
then
you
have
an
RPC
and
that
they
use
like
to
talk
to
each
other.
That's
basically
the
canonical
example
of
a
module,
and
then
we
just
call
them
agent
module
server
module,
but
this
whole
thing
is
the
module.
Then
they
may
have
shared
are
both
agent
and
server
are
optional,
that
you
don't
have
to
build
both
if
you
don't
need
both
like
configuration
is
only
one.
A
The
server
and
configuration
for
a
client
is
a
pretty
special
thing,
so
we
have
like
a
helper
to
watch
configuration,
but
the
the
agent
kind
of
can
contains
code
that
calls
this
call.
This
calls
this
Watcher
in
the
like
in
the
main
application
code.
Basically,
it
doesn't
have
a
module
for
configuration,
at
least
that's
how
it's
currently
structured.
A
Service
RPC
and
then
messages
then
server.
Okay,
let's
look
at
how
modules
a
server
or
agent
what
what
structure
they
have
so
they
they
have
factories
Factory
is
what
is
used
to
instantiate
a
module.
It's
instantiated
only
once
in
the
beginning
of
the
program
and
then
actually,
let's
look
at
the
module
interface.
This
is
the
server
module
interface
of
a
server
module,
so
once
it's
it's
instantiated
you
have
run
and
just
the
name
to
get
the
name
of
them.
A
So
we
have
such
case
and
maybe
not
even
one
so
some
things
have
called
in
the
root.
Well,
it
makes
sense
this
one
is
used
in
a
few
other
places
and
then
some
have
called
as
I
showed
you
in
RPC,
because
it's
kind
of
part
of
our
PC.
This
thing
is
a
is
a
weighted
RPC
and
we
also
have
cases
where
we
have
sub
packages
for
sharing
for
sharing
code.
Well,
it's
described
in
the
in
the
dock
there,
but
yeah.
So
there
is
a
factory.
Actually
Factory
also
has
a
type.
B
A
A
It's
because
agents
send
information
about
themselves
to
the
server,
and
this
is-
and
this
is
done
via
an
RPC.
So
this
kind
of
lives
here
as
a
shared
thing,
which
is
used
by
both
server
and
clients
and
agent,
and
there
are
a
few
other
things
that
are
shared
and
then
for
server
and
the
agent
we
have
apis
and
other
things
that
make
sense
from
modules
so
API
for
Server
we
have
various
constants
varios.
A
This
is
the
one
of
the
important
things
configuration
so
the
host
program
because
gives
this
configuration
struct
to
each
module
when
it
starts
the
module
and
the
same
with
agent.
Actually
agent
host
program
gives
configuration,
and
then
this
is
the
shared
API
and
then
so.
I
have
two
kind
of
apis.
One
for.
B
A
So
here
we
have
one
more
interesting
thing:
this
is
a
leader
module,
so
a
module
can
implement
this
interface,
which
it
just
needs
an
extra
method,
and
this
is
the
same
thing
just
extra
dock
here.
Basically,
so
this
is
if
a
module
wants
to
only
run
when
a
particular
configuration
is
given
to
agent,
and
it
wants
to
run
only
when
only
one
instance
should
be.
B
A
B
A
A
B
A
A
C
A
It's
just
wait.
No,
this
is
the
wrong.
One
must
see
just
a
wrapper
around
the
standard
generator
to
make
it
thread
safe,
because
the
standard
library
is
not
okay
and
also
we
have
a
helper
yeah
helpers,
all
right
here
in
this
particular
key,
and
then
we
have
other
other
things,
but
now
I
think
it's
super
interesting,
but
I
think
some
of
the
things
are
used
by
both
server
and
agent.
Some
things
are
not
okay,
anyway,
YouTube's
director
tools,
director
here
an
interesting
thing
is
testing.
A
A
A
A
B
A
C
B
A
We
created
it
before
the
chart
chart
was
actually
contributed,
but
by
by
someone
else
like
not
not
a
gift
lab
employee,
so
a
community
contributor
contributed
the
chart,
so
this
is
stuff
for
bills.
Basically,
and
then
here
we
just
have
Plumbing
for
CI
and
other
things,
and
here
in
the
road
we
have
various
dot
files
and
obviously
it's
obvious
what
these
are
workspace
is
the
basal
workspace
definition
and
nothing
particularly
interesting.
A
B
A
C
Yeah
yeah
I
mean
it
would
be
nice
to.
Maybe
if
you
can
walk
us
through
a,
but
let's
take
an
example
like
if
an
agent
starts,
you
know
how
it
connects
to
to
Cass
if
it
enable
or
if
it
has
like
githubs.
How
does
it
install
a
manifest,
like
you
know,
go
through
the
kind
of
the
code
and
the
critical
pieces
where
it
ends
up
and
how
it's
implemented?
That
will
be
helpful.
Oh
and
yeah.
You
can
take
the
example
I
made
if
it
makes
sense.
B
A
B
A
Global
one
because
there
are
some
libraries
that
use
the
global
random
generator.
Okay,
so
like
kubernetes
libraries
use
that
actually
and
I
think
yeah
anyway.
This
is
more
safety
measure,
because
some
some
code
somewhere
can
use
the
random
number
generator
yeah
anyway.
So
the
command
is
basically
binding.
The
flags
doing
virus
setup,
our
loggers
environment
variables
via
Flags.
A
We
try
not
to
have
Flags
here,
but
for
some
things
they
are
inevitable.
The
main
ones
are
these
two
and
CI
certificate
and
then
push
for
observability,
another
side,
certificate
certificate
and
key
and
blah
blah
blah.
Then
this
is
the
interesting
struct.
It's
the
constructed
application
from
flags
and
environment
variables.
We
also
have
very
few
environment
variables
that
we
need
and
then.
A
Yeah
well,
this
is
where
we
do
where
we
construct
all
the
objects
that
are
needed,
like
or
instantiate
all
the
structs
and
compose
the
graph
of
the
application
like
this
is
Cast
Connection,
it's
tracing
internal
grpc,
server
and
so
on.
So
on,
like
kubernetes
client
and
everything
that's
needed
for
it,
leader
election
for
leader
election
construct,
we
are
constructing
modules.
Then
we
running
the
modules
like
module,
Runner
construction
model
Runner.
Then
we
are
registering
modules
with
model.
Runner
I'll
go
into
details
about
each
in
the
second
iteration,
but
this
is
the
overall
structure.
A
Basically,
we
are
constructing
all
the
things
that
we
need,
or
the
agent
needs
to
execute
the
run,
and
then
we
run
those
things.
This
is
a
library
that
I
wrote
a
long
time
ago,
but
it's
quite
useful.
It's
super
simple,
but
quite
useful.
So
it
starts
things
in
go
routines,
but
then,
when
it
gets
a
signal
from
Context,
it
stops
them
in
in
reverse
order.
A
B
A
So
it's
a
way
to
do
ordered
shutdown,
because
these
things
depend
on
these
things,
and
these
things
depend
on
these
things
and,
like
so
on,
and
the
last
to
terminate
will
be
the
leader
election,
because
modules
lose
neither
use
the
reduction
and
internal
server
uses
modules.
So
it
starts
and
starts
after
and
stops
before.
The
modules
and
internal
modules
can
be
can
use
anyway.
C
B
A
Yeah,
this
is
the
implementation.
It
starts
to
function
in
the
gore
routine
and
it
cancels
everything
if
a
function
exits
with
a
non-new
error.
If
everything
was
fine,
then
it
just
puts
that
into
a
channel.
That's
that's
the
stage,
but
then
there's
another
thing
that
this
is
stages,
but
let's
not
go
too
deep
into
details
the
so
this
is
the
kind
of
how
it
starts,
and
this
is
what
is
needed
to
actually
start
so
connection
to
cast
is
created
here
and
we
read
token
and
blah
blah
blah
certificates.
A
A
A
A
We
give
the
signature
that
is
compatible
with
grpc
options,
so
we
can
give
grpc
a
way
to
dial
using
this
library,
and
this
Library
does
all
the
networking
and
grpc
just
thinks
it's
a
network
connection,
usual
network
connection
and
then
grpc
that
websocket
Library
uses
uses
this
HTTP
client.
With
this
transport
to
these
parameters
and
GLS
configuration
and
everything
and
and
then
we
support
proper
unwrapped.
B
A
So
this
is
the
construct
modules
method,
and
this
is
the
list
of
factories
to
construct
modules,
and
we
just
iterate
through
the
through
that
list
and
call
the
new
method
providing
the
configuration.
As
you
can
see,
this
comes
from
that
package
with
apis
and
interfaces
for
agent
modules
config.
Yes,.
A
The
only
difference
is
the
logger.
It
contains
the
module
name,
each
yeah.
Everything
else
is
identical.
Okay,
no
agent,
API
is
also
different
because
we
also
put
a
module
name
here,
but
everything
else
is
identical.
All
the
like,
Cast
Connection,
internal
server,
all
those
things
are
the
same.
So
we
get
the
module.
Then
this
is
the
leader
election
thing
which
maybe
wraps
the
module.
It
just
checks.
A
C
B
A
If
no
one
is
interested
in
be
participate
in
agent
participating
in
leader
elections
and
this
agent
will
not
participate
in
leader
election,
it
will
revoke
its
leadership
if
it
was
a
leader
and
the
dynamic,
because
configuration
is
dynamic.
So
based
on
configuration,
different
modulus
May
needs
to
you
know
be
to
work.
They
might
need
this
agent
to
be
to
participate
in
leader
election,
but
actually
this
was
implemented.
It
all
works,
it's
all
fine,
but
then
we
have
starboard
vulnerability,
module
which.
B
A
But
anyway,
maybe
this
will
be
removed
because
we
had
a
solute
module
and
it
got
removed.
So
maybe
this
will
be
removed,
someday,
who
knows
and
that
Machinery
that
I
built
for
leader
election
still
may
need
to
be
conditional
because
and
otherwise-
and
we
have
the
guitars
that
also,
it's
probably
a
good
example.
B
A
A
A
A
So
yeah
anyway,
we
have
constructed
the
modules
we
return
them
separately
because
of
that
shutdown
Quirk,
and
then
we
have
a
module
Runner.
This
thing
is
responsible
for
fake
for
fetching
configuration
it
establishes
a
connection
to
cast
and
cut
and
weights,
and
thus
eventually
my
sand
configuration
and
then
their
module.
Runner
is
responsible
for
pushing
this
configuration
to
each
module.
Basically
and.
A
B
B
A
Yeah
and
he
will
do
the
same-
we
shut
down
the
thing
that
pushes
configuration
and
then
shut
down
the
modules
that
we
run
here
in
the
reverse
order
and
then
yeah.
This
is
the
Watcher
where
we
watch
for
configuration
updates,
and
then
we
apply
configuration
updates
by
first
running
all
the
defaulting
on
that
configuration.
Each
model
can
contribute
to
defaulting
of
configuration
and
then
once
all
modules
have
applied
the
defaults
and
none
of
them
returned
an
error
we
use
that
configuration,
we
send
it
to
all
modules.
A
A
A
Here,
where
we
support
the
tops
manifest,
so
it's
a
it's
a
list
repeated.
So
it's
a
list
of
manifest
projects,
so
we
have
a
module,
a
worker
manager.
Basically
we
have
a
go
routine,
at
least
one
actually
more
than
one
for
each
source
of
manifests,
so
they
they
are
applied
concurrently.
They
have
code
concurrently
and
then
yeah.
So
we
it's
just
a
loop
over
the
channel.
We
get.
A
A
A
It
was
fed
into
the
decode
stage,
which
is
here
the
code
sector
file,
the
code
file,
they're
all
methods
on
the
worker,
but
it's
so
much
simpler
to
find
one.
That's
structured
like
that.
So
this
one
gets
the
desired.
State
here
tries
to
parse
it
with
a
retry
Loop,
which
is
not
a
simple
loop.
It's
like
quite
a
complex
Loop.
A
There
are.
There
are
reasons
for
that
because
the
decoder
might
need
to
it
might
fail
initially,
but
then
in
like
in
the
case
with
custom
resource
definitions
once
they
are
yeah
I
understand
establish
it.
Then
you
can
parse
the
Manifest
and
blah
blah
blah.
So
we
do
it
kind
of
in
a
loop
with
with
back
off.
A
New
job
new
job,
okay,
this
dry
pipeline
pushes
the
results
of
process
if
they
are
successful,
new
job
pushes
them
into
their
jobs
and
channel
second
channel
here
and
that
jobs
channel
is
read
by
apply.
So
it's
the
terminal
last
stage
of
you
that
three-stage
Pipeline
and
this
one
is
again
reading
from
that
channel
and
it
uses
Clio
cues
to
apply.
A
B
A
It
certainly
loved
here-
and
this
thing
also
prints
some
details.
I
think
we
do
have
an
epic
and
issues
and
even
the
design
for
agent
activity
page,
and
we
want
to
show
such
things
like
failures.
They
are
an
aged
activity
page
and
we
even
have
technical
documentation
to
some
extent
about
about
it,
but
we
haven't
defined
the
format,
the
protot
definition
for
the
event,
and
it
wasn't
a
priority.
So
this
is
kind
of
stuck,
but
we
do
want
to
show
it
in
the
user
interface
and
maybe
notifications
and
like
whatever
the.
B
A
B
A
A
A
This
is
the
service
githubs
and
it
has
the
get
objects
to
synchronize
the
request
here.
There's
a
string
in
the
project
ID,
then
it's
the
last
commit
processed
to
avoid
sending
the
same
stuff
every
time.
Only
if
coming
changes-
and
this
is
the
of
the
paths
to
scan
and
the
response
is
basically,
this
defines
a
finite
automata
for
this.
The
response
stream,
because
request
is
just
a
request,
but
the
response
is
a
stream
of
response
objects
response
messages.
A
A
You
can
get
a
stream
of
messages
and
the
first
has
to
be
the
first
then
allow
transitions
are
two
or
three,
so
this
one
or
this
one
and
then
after
each
one
is
like
two
or
three.
So
this
one
can
repeat,
because
it
allows
a
loop
two
to
two
and
and
eventually
to
go
to
three
and
three
can
only
go
to
E
off.
A
Or
it
can
also
be
just
evolve
if
server
decided
to
close
connection
and
it's
a
valid
thing
to
do,
for
it
and
validation
as
well
virus
validation
yeah.
So
that-
and
we
also
have
where?
Is
it
dream
visitor
thing,
which
is
the
code
that
uses
this
options
on
fields
to
enforce
that
the
stream
follows
this
graph
definition
of
what
is
allowed.
So
this
is
basically
to
foreign,
malicious
people,
sending
invalid
messages
and
triggering
a
known
behavior
in
the
server
it's
protection
for
the
server.
A
B
A
Basically,
had
header
object,
trailer
one
two
three,
this
constants
and
it
calls
callbacks
on
header
on
the
object
of
trailer
and
basically
header
contains
meta
information.
Object
contains
call
or
a
piece
of
object
is
if
the
Manifest
file
is
too
big,
it's
chopped
into
sections,
and
then
this
thing
concatenates
them
here
in
memory
and
then
trailers
is
just
some
bookkeeping
and
then
once
it
has
consumed
the
stream,
it
calls
the
Callback
which
we
saw
in
the
agent
module.
It
gets
that
object.
B
A
B
A
Factory
Factory
constructs
a
module
and
module
uses.
This
new
server
I
know
Factory
uses
this
new
server
and
it
registers
right.
The
module
doesn't
do
anything
because
we
construct
the
server
in
the
factory
and
register
it
with
the
agent
server
agent.
Server
is
just
dark.
It's
just
the
grpc
server
that
the
age
of
drugstore.
Basically-
and
this
is
the
server
we
give
it
a
lot
of
stuff
configure
virus
configuration
and
the
server
has
only
one
exposed
API.
Everything
else
is
just
implementation
of
that
thing.
A
Get
project
info
where
on
which
guitarist
server
that
repositories,
then
it
pulls
that
Repository
on
a
successful
poll
when
commit
is
a
different
commit.
We
basically
send
start
sending
the
response
stream,
the
header
we
have
header
object
and
trailer,
so
we
send
header.
Then
we
send
the
body
as
zero
or
more
object
messages,
and
then
we
send
the
trailer
yeah.
That's
how
the
server
works.