►
From YouTube: MeshSync Weekly Meeting (July 28th, 2020)
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
And
yeah
we
got
to
think
about
that.
So
so
we'll
do
a
tiered
fingerprinting
of
the
mesh
and
just
to
just
to
basically
make
sure
that
we're
we're
doing
it
sequentially
and
if
something
is
not
found,
maybe
we
treat
it
as
an
error,
or
maybe
it's
just
a
maybe
report
the
error
and
go
to
the
next
fingerprinting
so
yeah.
That's
that's
yet
to
be
decided,
but
yeah,
that's
the
idea.
A
I
mean
the
reason
I
want
to
use
pipeline,
even
though
I'm
mentioning
sequential
is
because
some
things
could
happen
in
parallel
like
discovering
the
image,
and
maybe
the
control
plane
at
the
same
time
could
happen.
A
So
they
would.
They
would
run
in
parallel
and
fill
out
the
models.
The
mesh
info
object
and
the
mesh
info
object
is
going
to
be
queryable
at
any
point.
We're
going
to
protect
it
for
the
read,
write
mutex.
So
as
the
fingerprinters
are
adding
more
information
to
the
mesh
info
object,
anyone
can
query
for
it.
A
C
Another
example
of
parallel
processing
might
be
yeah
once
you've
identified,
that
there's
an
istio
control
plane,
for
example,
that
if
you
want
to
go
over
and
analyze
each
of
istio's
individual
custom
resources,
you
might
be
able
to
do
that
in
parallel
right
right.
That's
a
good
point.
C
A
C
C
Yeah
yeah,
but
not
yet
anyway,
while
it's
listening
on
a
port,
I
don't
know
that
yeah.
I
don't
know
that
it's
it's
listening
for
an
event.
Okay,
again,
like
I
kind
of
kind
of
tormented
on
this
particular
thought,
because
to
date
the
place
for
service
mesh,
specific
knowledge
has
been
inside
of
an
adapter
and
so
flowing.
Information
about-
and
you
know
a
mesh
through
the
the
thing
is,
is
I'm
sorry
flowing
information
about
a
specific
mesh
through
its
relevant
adapter
yeah
today
makes
some
sense
so
that
logic
can
be.
C
The
reality
is
that
there
are
mesh
specific,
that
really
like
it's
funny,
that
there
are
like
three
adapter.
We
have
six
adapters,
I
think,
three
of
which
are
more
or
less
based
on
the
same
thing,
because
they're
all
three
of
those
service
meshes,
you
are
istio
or
implementations
of
istio,
and
so
it's
it's
really
just
the
configuration
analysis
portion
that
we
have
inside
of
the
istio
adapter.
C
C
That
is
that
has
service
mesh,
specific
knowledge
that
we
would
want
to
look
at
at
such
an
event
and
say:
wait
a
second
you're.
You
know
you.
C
Because
the
the
life
cycle
management
operations
about
installing
and
uninstalling
istia
are
while
they're
istio
specific
inside
the
adapter.
I
don't
know
that
those
life
cycle
management
operations
much
care
about
info.
That
mesh
think
is
going
to
get.
C
C
C
And
that
kind
of
an
effort
is
painful,
because,
because
it
doesn't
it's
a
better
architecture
or
whatever
that
v2
is
potentially
it's
not
really
something.
I
I
want
to
try
to
actively
chase,
but
the
reason
that
it's
painful
is
because
none
of
the
users
give
a
rip
because
it
like
doesn't
help
them
any
more
than
they're
being
helped.
Today,.
C
C
I
went
ahead
and
prodded
a
few
people
to
start
the
visual
topology
understanding
that
we're
getting
some
traction
with
mesh
sync
that
will
be
able
to
pump
some
info
through
the
system
and
after
a
couple
of
days,
one
of
the
contributors
has
just
took
a
sent
me
a
recording,
late
last
night
of
an
early
prototype,
not
consuming
any
any
actual
info,
but
just
and
so
I'm
going
to
show
share
that
with
you
guys
now.
C
The
second
topic
is
to
potentially
show
tinkai
a
a
bit
of
the
code
that
does
fingerprinting
for
istio
and
to
potentially
so
that
he
might
potentially
consider
something
similar
for
kuma
or
yep
cool,
okay,
all
right.
So
so
the
let
me
let
me
share
my
whole
screen.
C
Yes,
my
I
have
a
headache
from
lack
of
sleep
from
the
from
last
night's.
Tell
me
about.
A
I'm
still
building
out
the
demo,
so
we
have
the
slides,
I'm
building
out
the
demo,
putting
it
on
github
and
then
we
got
to
record
the
talk.
So
hey.
I
wanted
to
ask
what
software
do
you
use
to
record
your
talks.
C
We
went
on
to
we,
we
went
on
to
the
in
the
system
that
they
had
for
us,
but
that
said,
if
I
was
doing
it
by
myself,
I
would
use,
and-
and
this
might
be
something
that
we'll
have
a
subsequent
conversation
on
the
so
I'm
on
a
mac,
but
it
does
not
that
it
it's.
I
would
use
this
open
source
software,
it's
called
the
abbreviation,
is
called
obs
open,
broadcast
studio.
C
Okay
and
it's
you
know
slightly,
it's
an
open
source
piece
of
software,
so
ux
is
not
the
best,
but
but
it
is
fairly
powerful
and
it's
kind
of
neat
because
it'll,
let
you
set
up
like
it,
makes
it
look
professional
where
and
actually
honestly,
you
might
want
to
check
in
with
it.
If
you
do
this,
like
it's
neat
because
it'll,
let
you
take
your
screen,
put
your
present
your
presentation
in
this
section
and
then.
D
C
Face
in
this
section-
and
you
can
paint
the
background
with
something
out
like
it's-
it's
nice,
so
this
is
a
post
editing
well
or
while
you're
do
you
nope,
you
can
set
it
up
and
then
and
get
it,
get
it
configured
how
you'd
like
for
it
to
be
recorded
and
kind
of
look
and
then,
when
you're
ready
to
give
your
talk,
you
you
just
give
it
like.
You
normally
would
and
but
the
way
that
the
video
it
draws
in
video
from
your
webcam.
D
Sharing
yeah
a
window
or
yeah
that
sounds
pretty
good
I'll,
send
it
out
to
our
coach
as
well.
A
Okay,
oh
so
so
it's
funny,
someone
from
our
cautious
team
like
who
wasn't
in
any
of
her
calls
just
posted
a
link
to
mystery.
I
o
on
our
yeah.
I
I
was
I
was
wondering.
Maybe
I
should
email
her
because
she
she
is
a
golang
buff
and
she
wants
to
learn
about
service
meshes.
Maybe
she
can
join
our
community
so
I'll.
Try
to
do
that
because
I'm
pretty
sure
she'll
be
interested.
C
That's
awesome,
yeah!
I
do
absolutely
that's.
I
love
it
man
it
you
just
keep
doing
good
things
and
more
more.
C
This
is
it's
kind
of
a
hard
screenshot
to
see
because
there's
a
little
bit
of
youtube
text
overlaying.
But
what
we
had
here
was:
do
you
see
the
blue
background
and
purple?
Okay?
So
that's
just.
We
just
took
an
image,
a
background
image
that
was
provided
by
the
docker
gun
and
then
using
the
the
software.
We
said
the
obs
we
loaded
up
the
background
image
and
then
it
we
said
okay.
Well,
we
have.
We
want
two
video
sources,
one
for
my
webcam,
one
from
and
actually
not
from
kanesha.
C
We
just
put
a
picture,
so
it's
a
picture,
video
source
and
then
a
different
screen
or
a
different
type
of
video
source,
which
was
just
my
screen
being
shared,
but
I
was
doing
it
full
screen.
While
I
was
talking
here
but
yeah
obs
was
bringing
it
together
to
look
just
like
this.
So
that's.
C
I'll
say:
okay,
there's
yeah,
there's
some
nice
little
write
up
like
cheat
sheet.
That
might
be
helpful.
A
D
C
I
know
I
this
is
good,
so,
okay,
well,
so,
by
the
way
the
service
mesh
performance
specifications
site
is
hideous
at
the
moment,
but
but
a
new
site
is
coming
together
and
that's
actually
for,
I
included
a
little
bit
about
it
in
last
night's
talk
and
I'll.
Do
it
again
in
a
much
bigger
way
in
the
upcoming
talk.
C
The
thing
I
wanted
to
share
with
you
guys
is
there's
a
gentleman
anirud
who
is.
C
Well,
who's!
I
don't
know
if
you
can
see
this,
but
he's
been
working
on
this
so
he's
taken.
Oh
that's,
pretty
cool
yeah,
and
that
was
really
quick.
What
just
happened
so
I'll
kind
of?
Let
me
slow
it
down.
So
it's
you
know.
So
it's
ugly,
the
canvas
but
but
hey
it's
integrated
into
mastery
itself.
So
this
is,
I
get
really
excited
and
then
so
he's
hovering
he's
having
some
interaction.
C
D
C
C
So
then,
right
here
you
know
what
what
he's
got
happening
is
like.
It
is
a
modal
right
in
context
of
the
visual
thing,
you're,
seeing
okay
and
actually
as
soon
as
like
kush
and
kaneshkar,
have
been
working
on
performance
test
profiles,
meaning
yeah
you
just
you,
don't
have
to
type
it
all
in
all
the
time
you
just
type
it
all
in
once
you
you
save
it
as
a
name
and
instead
of
showing
the
form
likely,
we
would
just
show
you
know
a
list
of
profile
names,
so
you
can
say.
C
Oh
yeah,
I
want
to
run
the
soak
test
three
and
then
you
start
to
see
all
the
traffic
go
across.
The
note
you
know
like
he:
there
is
no
traffic
going
across
them,
but
the
point
of
showing
this
to
you
guys
is
this
isn't
possible
and
we
wouldn't
really
start
unless
mesh
sync
is
because
mesh
sync
is
becoming
a
thing.
C
It's
possible
to
start
on
this
and
then
so.
The
the
other
topic
that
we
could
touch
on
is
tinkai.
Did
that
did
do
you
think
it
would
be
time
well
spent
to
take
a
look
at
what
natish
has
done
on
discovering
istia.
C
And
national,
do
you
want
to
share,
or
I
can
bring
up
something.
B
B
C
C
C
But
obtain
so
I'll
give
you
the
very
high
level
tour
and
then
the
tish
will
interrupt
me
at
some
point.
There's
a
main.go
kick
off
the
main
program.
Part
of
what
the
design
for
mesh
sync
is
that,
hopefully
we're
designing
in
such
a
way
that
they
will
be
able
to
run
as
as
deployed
inside
of
a
cluster
or
just
running
on
your
local,
you
know,
or
or
outside
of
the
cluster
outside
the
cluster.
It's
going
to
need
a
cube
config
to
be
able
to
speak
to
kubernetes
inside
the
cluster.
C
C
And
then
the
dish
from
here
like
a
like
this
is
the
main
construct
of
the
program.
Right
is
the
fact
that
it's,
and
so.
C
I'm
trying
to
think
of
anything
interesting
here
here.
What
is.
A
So
this
is
this:
is
your
runner
function?
The
channel
is
if
someone
hits
control
c,
we
want
to
do
a
graceful
shutdown,
okay,
so
it
it
it
basically
gracefully
shuts
down.
Go
routines
blocks
it'll,
make
sure
that
things
are
cleaned
out
if
the
resources
are
located,
or
there
were
some
upstream
connections
that
you
want
to
terminate.
A
A
A
C
I'll
bite
my
tongue,
I
mean,
I
think,
part
of
what
you're
saying
is
like
hey.
If
tinkai
were
to
get
started
on
a
different
mesh,
it
might
be
frustrating
over
time
because
he'll
have
to
it'll
be
refactored
a
few
times
as
mesh
sink
evolves,
yep,
as
opposed
to
the
sort
of
going
a
little
bit
deeper
on
the
existing
area
of
focus,
which
is
which
is
istio.
A
Yeah,
so
so
what
we
want
to
do
is
so
we're
creating
a
synchronizer
client
for
istio.
If
you
go
to
sync
dot
go
so
this
is.
This
is
our
interface
that
we
want
to
implement
for
each
of
our
meshes.
You
have
mesh
sync,
which
has
the
synchronize
and
fingerprint
interfaces
so
when
you
go
into
the
istio
directory,
so
if
you
go
to
sdo.go,
so
ac.go
is
an
implementation
of
that
interface.
So,
if
you
scroll
down,
you'll,
see
the
synchronize
function
and
the
fingerprint
function
so
that
satisfies
the
interfaces.
A
The
idea
is
in
the
synchronize
function
is
where
you
do
all
the
leg
work.
So
as
soon
as
synchronize
is
called,
it
kicks
off
a
go
routine,
which
is
start
discovery
and
in
here
you're
just
you're
just
handling
events
coming
in
so
so
these
events
could
be.
The
event
coming
in
could
be
like
a
broadcast
or
something
it
could
be
done
over
here
or.
However,
you
want
to
handle
the
events,
but
in
the
start,
discovery
method
is
where
the
first
step
is
going
to
be
discovering
the
mesh
so
get.
A
Sto
versions
is
essentially
similar
to
sdo
ctl
version
and
it's
doing
it
on
a
periodic
basis.
We've
created
the
thicker
sync
period
and
every
time
it
ticks
it's
gonna
it
could.
It's
gonna
continue
probing
the
mesh
and
once
like,
when
it
figures
out
that
the
mesh
is
discovered,
it's
gonna
start
fingerprinting,
the
mesh,
or
in
this
case
fingert
printing.
A
I
I
think
I
I
don't
know
if
I've
pushed
the
fix.
I
I
made
the
fix
somewhere.
Maybe
it's
in
my
branch
but
yeah
the
fingerprinting
is
essentially
a
pipeline
like
we
were
discussing
earlier.
This
could
be
fingerprinting
in
parallel,
like
lee
said
it
could
be
identifying
what
what
custom
resources
are
available,
identifying
the
workloads
that
might
be
or
services
that
might
be
part
of
this
current
mesh
and
belong
to
our
own
are
owned
by
that
mesh.
A
So
there
could
be
a
lot
of
things
that
we
we're
gonna
collect.
But
when
you
see
that
event
channel.
A
So
this
is
the
structure
of
events
and
again
it's
an
interface.
You
have
a
details,
function
which
gives
you
our
abstract,
struct
or
abstract
object.
That
represents
some
mesh
in
mesh
sync.
So
this
is
a
mesh
agnostic.
A
So
if
you
want
to
jump
into
mesh
info
info.go,
so
it's
it's
pretty
mesh
agnostic,
you'll
right
now
we
just
have
the
version
string.
All
all
meshes
should
have
a
version
string,
we'll
start
identifying.
What
else
is
common
to
our
meshes?
What
kind
of
info
do
you
want
to
store
in
this
struct
and
then
there's
an
opaque
field
which
could
hold
mess
specific
information?
A
So
it's
it's
up
to
the
the
consumer
of
this
object.
So
I
think
there
will
be
a
type
field
too
that
I'm
missing.
So
above
the
version
we
can
say
a
mesh
type
or
something
and
which
could
be
an
enum
where
zero
is
istio,
one
is
kuma
blah
blah
blah,
whatever
we
need
to
and
based
on
the
type
you'll
have
your
switch
case
where,
where
it
knows
how
to
interpret
the
opaque
object,
so
so
yeah,
that's
yeah!
That's
the
idea.
A
C
There's
a
few
protos.
C
You
it'd
be
nice
to
be
able
to
import
this
package
and.
C
Is
any
of
that
coming
together.
E
Yeah
yeah,
maybe
I
was
just
curious
and
not
very
specific
to
this
mastery
operator,
but
we
when
we
like,
deploy
like
rounding
when
we
were
running
this
mastery
operator.
How,
like
just
curious,
how
how
do
you
know
that
these
service
mesh
meshes
will
send
the
information
to
mastery
operator
like
we
are
catching
the
event
here
like
how?
How
do
you
guarantee
they
will
send
the
event
to
where
you
want.
A
So
that
get
get
sto
versions
is
basically
probing
the
istio
control
plane
and
the
control
plane
in
the
right
name
space.
So
one
instance
of
sto
could
be
running
in
a
steel
system.
Is
your
system
one?
So
it's
going
to
probe
the
control
plane
and
steer
system
one,
and
then
you
have
istio
system
two.
So
it's
gonna
probe.
Is
your
system
two.
A
So
it's
it's
basically
that
discovery
is
a
pole
based
model
rather
than
an
eventing
model,
so
periodically
it's
just
asking
the
control
plane.
Basically,
it's
it's
checking
that
it
the
control
plane,
is
responding.
A
So
it's
more
like
a
health
check
after
the
first
discovery
or
if
something
changed,
maybe
that
information
will
be
updated
too
and
there's
going
to
be
a
lot
of,
I'm
pretty
sure,
there's
going
to
be
a
lot
of
things
that
are
missed
out
in
here
so
yeah
I
mean
if,
if
you
can
dissect
this
code
and
think
of
reasons
why
it's
not
gonna
work
or
maybe
some
modifications-
please
please
do
so.
There's
there's
nothing
set
in
stone,
so
I'm
really
open
to
being
convinced
otherwise,
and
we
can
start
modifying
this
code.
E
E
C
So
part
of
that
is
that
there
will
be
certain
certain
things
that
mesh
sync
will
have
to
first
discover
and
then
I
think,
to
the
extent
that
we
can
once
we've
discovered
them,
that
we
would
be
able
to
subscribe
for
updates
on
that
object.
C
So,
in
this
case,
like
as
we're
discovering
the
version
of
istio,
we
are
importing
in
istio's
go
client,
it
has
a
function
to
figure
out
where
the
control
pla,
if
there's
a
control,
plane
there.
I
know
where
it
is,
and
then,
if
so,
what
the
version
number
is.
Yep,
okay
and
that's.
E
Oh
okay,
yeah.
Maybe
I
have
another
question
so
when
I
just
reading
through
the
code
here
like
if
I
were
to
write
this
code,
like
I
I
was
wondering
like
how
did
you
know
that?
How
did
you
design
such
functions
like?
How
do
you
know,
for
example,
starter
discovery,
has
signature
context
and
think
period
and
what's
the
what's
the
context
here
like.
E
Or
fingerprinting,
how
did
you
what's
the
event
like?
How
do
you
design
this
function
like
no,
we
have
these
two
parameters
and
what's
the
output
of
this
function.
A
So
so
there
is
no
real
spec.
These
are
all
made
up
objects,
anything
that
I
could
think
of
the
event
object.
I
I
wanted
to
create
an
object
which
could
carry
an
error
message
if
an
error
occurred
or
if
not,
then
it
could
carry
the
the
mesh
sync
object.
A
The
info
object
the
details
about
the
mesh,
so
so
these
events
can
happen
at
any
point
in
the
pipeline
and
what
we
want
there-
and
maybe
it's
missing
in
here,
but
what
we
want
there
is
it'll
at
least
send
even
if
an
error
occurs,
it'll
go
it's
going
to
send
the
event
object,
that's
populated,
maybe
in
step
one
and
step
two
of
the
pipeline
and
step
three
is
where
you
hit
an
error.
So
so
you
want
to
quickly
at
any
of
the
pipelines.
You
don't
want
to
be
blocked.
A
Till
everything
runs
to
send
an
update
about
the
event
or
about
the
mesh
mesh
object.
You
want
to
do
this
constantly
in
every
pipeline
every
step.
Every
stage
of
the
pipeline.
E
Okay,
just
following
about
here
like
could
you
could
you
tell
me
like
what's
the
context
here
like
what
what
is
actually.
A
The
context
there's
there's
nothing
in
the
context:
it's
it's
again.
It's
just
used
for
the
cancel
function
and
if
you,
if
you
go
so,
I
haven't
added
the
context
cancel.
But
if
you
were
in
the
controller
controller.go,
so
when
when
a
quit
happens,
where's
our
quit,
we
put,
we
passed
the
quit
to
synchronize.
So
so,
if
you
go
to
synchronize,
so
what
I'm
going
to
do
here
is
I'm
going
to
change
these
signatures
a
bit.
A
So
when
a
quit
happens,
it's
going
to
do
a
context,
cancel
on
on
all
instances
of
the
synchronizers
and
all
of
them
will
do
like
a
graceful
shutdown.
A
So
that's
why
I
said
like
there's.
The
context
was
added
added
retroactively,
so
some
of
the
signatures
will
need
to
change.
Okay,
and
I
can
I
can
change
this.
A
C
Cool.
Thank
you.
Oh
of
of
a
potential
item
that
kinkai
might
be
able
to
add.
Is
that
taking
a
look
at
for
a
specific
for
an
a
specific
istio
custom
resource,
or
is
that
inappropriate.
A
We
need
we
need
to
identify
like
the
something
I
was
we
were
talking
about.
The
other
day
was
what
are
the
requirements
in
terms
of
fingerprinting
like
what?
What
kind
of
data
do
we
want
to
collect,
because
if
you
were,
if
you
were
to
say,
identify
the
custom
resources,
it's
possible
that
there
is
no
custom
resource
created
in
the
cluster.
It's
just
the
crds
are
deployed,
but
there's
no
workloads
running.
So
that's
a
possibility.
A
It
should
not
be
an
error
case
if,
if
we
do
find
objects,
we're
going
to
relay
that
information
back
to
through
that
events
object
so
whenever
it
finds
something
but
yeah
I
mean
no.
C
Yep
that
that
question
might
be
in
advance
of
where
we
were,
or
that
suggestion
might
be
an
advance
of
our
readiness
for
a
particular
also.
I
guess
after
I
asked
that
or
suggested
that
thinking
about
the
potential
use
of
pipeline
right.
A
Yeah
there's
a
there's
a
lot
of.
I
can
anticipate
a
lot
of
react,
pre-architecture
and
redesign
in
this
case,
so.
C
I
wonder
if
something
is
as
small
as
maybe
pulling
this
package
so
that
there's
an
enum
that
we
can
use
for
identifying.
C
I
don't
know
I'm
trying
to
get
tinkai's
fingers
wet.
E
Yeah
yeah,
the
the
measure
type
in
them
will
be
something
from
the
the
mastery
specification
like
the
the
one
we
just
saw
yeah
here
right
right.
C
Hey
yep,
that's
right
question
as
we
go
to
add
additional.
C
What
we
got
service
meshes
later,
if
you
ever
retroactively,
go
back
in
time
and
switch
out
the
number
for
one
of
these,
I'm
assuming
that
has
a
massive
that
has
breaking
effects
for
anyone
consuming
the
proto
like
is
that
right
when
you're
in
the
code
when
you're
referring
to
when
you
want
to
refer
to
link
or
d,
if
you've
imported
this
this
package
is
the
code
itself
going
to
be
matching
off
of
the
number
four
or
will
it
always
be
matching
off
of
the
text
itself?.
C
Actually
asking
me
or
yeah
or
nitish
or
or
I
know
yeah,
I
probably
noticed.
Could
you
repeat
that
sorry,
as
you
go
to
use
a
proto
file
and
you
import
a
package
like
this
into
mesh
sync,
I'm
curious
about
how
protobuf
protos
work
in
general?
C
Is
it
if
you
clearly,
you
can
come
in
after
the
fact
have
another
version
of
this
and
add
add
on
additional
enums
right,
but
if
you
needed
to
go
back
in
time,
what
I'm
trying
to
ask
is
when
this
is
imported,
is
it
the
numeric
four
that
is
referenced
in
in
a
package
like
mesh
sync,
or
is
it
the
string
text,
linker
d,
that's
matched
so.
A
So
when
you
generate
the
go
code
from
the
protofile
there'll
be
a
lot
of
helper
functions,
so
you
will
get
the
enum
so
yeah.
If
you
look
at
pb.go,
you
get
the
constant
you
get
the
the
map
that
maps
from
id
to
name
or
the
number,
to
name
and
name
to
write
name.
The
number.
A
So
there's
a
lot
of
things,
but
the
idea
is
gonna
be
to
import
the
pb.go
file.
So
it's
it's
up
to
the
maintainer
of
mesh.
What
was
this
is
this
yeah
this
this
repo
to
keep
it
up
to
date
and
it's
meshing's
job
is
to
just
import
that
pb.go
file
and
use
it,
as
is
so.
If
anything
new
is
added,
it's
you.
You
do
nothing
initially
and
when
you
start
adding
support
for
it
and
mesh,
think
you
basically
handle
that
that
mesh
as
well
based
on
the.
C
Type
and
for
new
type,
I
can
see
how
you
know
kind
of
like
kind
of
like
a
database
and
changing
the
schema
of
a
database,
that
adding
new
columns
is
never
there's
generally
doesn't
isn't
a
breaking
change.
But
when
you,
I
guess
when
I'm,
but
when
you
delete
a
column
that
can
potentially
mess
up,
you're
not
allowed
to
and.
A
C
Cool-
and
I
think
that
in
part
answers
my
question
of
like
that
was
kind
of
what
I
was
trying
to
get
to
is
like
hey.
If
you
wanted,
if
you
wanted
to
order
these
in
alphabetical
order,
and
you
went
to
rearrange
the
mapping
it,
it
seems
like
best
practice
for
a
client
like
like
the
like
mesh
sync,
as
it's
importing
this
package,
that
you
would,
as
you're
coding
up
mesh,
think
that
you
would
refer
to
things
yeah.
C
C
C
Okay,
all
right,
I'm
feeling
somewhat
good
about
this
week
in
terms
of
maybe
doing
the
first,
maybe
doing
the
thing
that
I
need
to
do
to
assist
with
the
some
of
the
use
cases,
and
some
of
the
to
you
know
be
able
to
have
some
of
those
discussions
so
that
tiered
discovery
and
other
things
make
sense.
A
No,
I
I
think
this
is
good.
I
will
try
to
work
on
this
again
on
the
weekend.
That's
the
only
time
again,
because
there's
there's
so
many
things
to
balance
right
now,
but
yeah.
I
I
I
wanna,
do
the
arc
the
architecture,
diagram
or
a
sequence
diagram,
because
that'll
be
an
easier
way
of
designing
and
redesigning
things,
and
people
can
come
in
and
we
can
spec
it
out
before
we
start
adding
more
code
or
removing
code
yeah.
A
So
let
me
try
that
on
the
weekend,
there's
still
more
ideas
that
I
got
after
talking
today
about
eventing
on
how
we
want
to
do
that
pipelines.
Pipelines
could
be
forever
processes
also,
so
maybe
maybe
some
of
my
design
is
wrong.
Instead
of
a
taker,
the
ticker
could
be
fine
for
a
health
probe
because
you'll
periodically
check
if
the
control
plane
is
still
there,
but
the
every
fingerprint
process
that
she
starts
should
become
its
own
core
routine
and
keep
running
again
periodically
or
based
on
events.
A
So,
like
the
reason
I
came
up
is
because
we
need.
We
need
one
fingerprinter
to
watch
the
custom
resources,
so
it
will
basically
need
to
periodically
ask
api
server
that
do
we
have
any
new
virtual
services.
Do
we
have
any
new
destination
rules
and
as
it
as
it
gets
that
information
it's
going
to
populate
the
info
object
and
send
an
event
out
that
a
virtual
service
was
added
and
whoever
wants
to
consume.
It
could
consume
that
event
and
do
whatever
it
needs
to
do
with
it.
A
A
Yeah
another
use
case
of
this
eventing
model
that,
like
the
broadcast
events,
is
going
to
be,
the
visual
topology
could
get
events
the
ui
the
front
end
would
get
events
from
there
where
it
tells
you
that
a
new
version
service
was
added,
so
it
would
be
dynamic
in
nature
that
a
new
new
service
was
added
or
a
new
control.
Plane
was
added.
So
that's
why
I
want
to
keep
that
inventing
model
and
needs
a
little
more
thought
and
it
it
doesn't
have
to
be
this.
It
doesn't
have
to
be
in
process
eventing.
A
Eventually
it
could
be
a
broker
message,
broker
or
nats,
or
something
else
that
we
could
use
kafka,
and
I
know
we
discussed
kafka
and
it's
too
heavy.
It's
probably
going
to
be
nats
and
whatever
other
micro
services
want
to
subscribe
to.
It
can
do
that
yeah,
it's
organically,
going
to
grow,
it's
gonna,
it's
gonna
break,
it's
gonna
be
restructured
rebuilt,
but
that's
the
fun
of
it.
A
It's
not
it's!
It's
it's
still
up
in
the
air
like
we
still
don't
know
exactly
what
mesh
thing
does
we
have
a
basic
idea
of
what
we
want
to
do,
but
there's
going
to
be
like
actually
yeah,
actually
building
it
out
and
materializing,
it
is
is
where
the
challenge
is.
A
Okay,
so
yeah
that
that
would
be
ideal.
Then
I
don't
know:
does
the
ui
talk
to
a
node.js
backend.
C
A
A
Oh
okay,
okay,
got
it
all
right,
so
yeah
I
mean
the
back
end
gets
an
event.
It
probably
keeps
a
web
socket
open
or
how.
However,
the
dynamic
thing
works
with
the
front
end
yeah
it
should
be,
it
should
be
pretty
cool.
I
mean.
Obviously,
it's
periodic,
because
istio
is
not
giving
us
too
many
events
discovering
virtual
services
or
objects
is
going
to
be
event
driven.
So
it's
not
really
a
full
model,
but
they're
like
looking
at
the
image
or
something
else
like
istio.
Ctl
version
is
a
periodic
thing.
A
If
you
want
to
get
some
information
from
the
site
cars,
the
proxies
that's
going
to
be
a
periodic
thing,
because
the
proxy
is
not
going
to
send
an
event
saying
that
hey.
This
is
the
call
back
when
something
happens
so.
A
Certain
things
are
event
driven
certain
things
are
polled
so
event.
Driven
ones
are
dynamically
sent
over
nats
to
our
front
end
back
in
front
end
and
the
other
things
are
pulled
and
sent
to
nats.
C
I
see
I
just
yeah
yeah
see
kush,
that's
why
that's
why
the
operator
has
that
mesh
sink
logo
as
his
heart,
because
it
that's
the
hub.
C
Nice
good
this
is
this-
is
fantastic
tinkai.
There's
an
issue
coming
your
way
about
this
proto.
I
guess.
C
We're
good
gentlemen
same
time
next
week,
maybe
with
some
actual
things
on
paper
and
some
other
preparation.