►
Description
Contributing to Meshery Adapters using Service Mesh Patterns (June 7th, 2021)
Join the community at https://layer5.io/community
Find Layer5 on:
GitHub: https://github.com/layer5io
Twitter: https://twitter.com/layer5
LinkedIn: https://www.linkedin.com/company/layer5
Docker Hub: https://hub.docker.com/u/layer5/
A
Yeah,
so
a
few
days
back,
we
actually
created
this
issue
which
says
that
support
for
serviceness
parents
in
lingard
adapter,
the
same
is
actually
true
for
every
adapter,
then
this
year,
because
it
still
has
basically
almost
percent
support
for
doing
things
via
patterns,
as
well
as
mesh
shops,
we'll
see
what
exactly
differences
and
those
kind
of
things.
A
So
the
idea
is
that
every
adapter
right
now
is
capable
of
performing
some
operations,
but
it
performs
those
operations
via
rbc
called
meshops,
but
the
same
operations
can
be
performed
via
patterns
also,
and
in
order
to
do
that,
we
have
a
function
called.
A
Actually
we
have
a
function
called
process
oem
this
process
om
is,
I
may
be
able
to
show
where
exactly
this
function
comes
from,
but
the
idea
is
that,
when
on
the
remote
side
mission,
whenever
it
sees
that
there
is
something
which
which
needs
to
which
which
is
a
pattern
and
should
be
invoked
in
the
on
any
adapter,
it
will
invoke
this
rpc.
This
is
an
obviously
it's
defined
on.
It
should
be
defined
on
any
every
other
document
right
right
now,
it's
available
only
on
istio,
that's
the
issue.
A
That
is,
this
should
be
actually
replicated
everywhere.
The
internals
of
this
rpc
won't
be
exactly
same,
but
the
basic
concept.
The
basic
idea
would
remain
same.
The
concept
is
that
this
process
om
rbc,
which
is
which
should
be
attached
to
handlers.
If
you
would
actually
look
into
the
adapters,
you
would
see
that,
for
example,
this
is
the
adapter
ac.
Adapter
is
kind
of
embedding
this
adapter
strut.
A
This
rafter
stop
comes
from
mystery,
adapter
library,
so
in
every
adapter
you
would
see
similar
structures,
the
similar
structs
and
you
you
will
have
to
add
methods
to
method
called
process
going
to
that
struct.
So
that's
what
his
is
being
done.
A
We
we
have
created
our
method
and
I've
attached
it
to
istio
struct.
Now
what
this
method
is
going
to
get
via
our
pc.
The
first
thing
is
context
this.
This
actually
is
being
implemented
by
the
grpc
grbc
client,
and
the
second
thing
is
actually
on
request.
There's
something
actually
today.
Namitha
was
also
basically
asking
that.
What
exactly
is
this
thing?
So
what
you
get
in
this
here
is
a
username
delete,
op
and
om
pumps
in
config
username
is
would
be
dependent.
A
So
this
is
basically
user
id
of
the
user.
Who
is
invoking
the
operation
this?
This
can
be
used
to
track
who
actually
invoke
the
operation.
The
second
is
delete
off.
If
so,
what
in
patterns?
If
someone
has
observed,
there
are
two
kind
of
operations
that
can
happen.
One
is
provisioning,
something
and
another
is
basically
provisioning.
Removing
that
thing.
So,
if
delete
off
is
set
to
true,
we
will
actually
have
to
reward.
That
is
whatever
we
have
provisioned.
A
Why
that
current
file
will
attempt
to
unprovision
deprovision
that
the
third
is
homecoms
will
see
what
forms
exactly
is.
It
is
represented
as
an
array
as
a
slice
of
string.
The
reason
is
that
grpc
is
strict
on
basically
strict
on
the
structure,
and
so
what
we
do
is
we
because
om
com
structure
change
very
frequently,
it
will
actually
depend
on
the
type
of
home
competitors
so
because
the
structure
changes
very
frequently.
A
So
what
we
do
is
we
convert
it
into
json,
and
then
we
package
it
in
a
slice
and
then
we
send
it
same
is
home
config.
This
is
actually
also
is
supposed
to
be
struct,
but
we
send
it
as
a
json.
That's
where
the
structure
is
looking
at
string,
so
this
is,
I
was
just
clearing
it
up
because
I
think
let
me
do
this
question
now.
What
we
do
on
the
on
the.
B
Question
I
could
question
the
so
understanding
the
history
around
the
provisioning
operation
and
the
delete
operation
all
right.
I
understand
that
moving
forward
the
so
a
separate,
separate
support
for
an
update
operation.
That's.
A
Yeah,
actually,
the
thing
is
that,
right
now
everybody
operation
automatically
supports
update
by
automatic
and
that's
absolute
term,
but
by
automatic
I
basically
mean
that
if
you
have
used
a
parent
file
already
to
provision
something
so,
for
example,
if
you've
used
pattern
file
for
provisioning,
a
steel
on
a
certain
namespace,
and
if
you
do
apply
again,
that
is
you.
Basically,
you
set
a
delete
top
to
false.
A
That
is
you
want
to
provision
something,
and
if
the
operations
see
that
the
entity
that
you're
trying
to
create
already
exists,
then
it
will
actually
update
that
thing,
so
it
will
right
now
every
operation
supports
that,
be
it
an
adapter,
be
it
and
server.
If
you
are
applying
more
than
once
the
same
pattern,
it
will
convert
it
into
update
thing.
Uniquely,
identifying
is
a
different
criteria.
Some
of
the
things
can
be
named.
A
Some
of
the
things
cannot
be,
may
not
be
named
space,
so
it
will
identify
that,
depending
on
the
object
that
we're
talking
about.
But
the
basic
idea
is
that
if
you
are
applying
the
same
pattern
file
over
and
over
again
the
next
time,
it's
actually
instead
of
trying
to
provision
it
again,
it
will
try
to
update
it.
That's
a
that's
an
undocumented
thing,
an
undocumented
thing
that
these
operations
do
actually
needs
to
be
documented.
B
A
So,
moving
on,
I
I'm
going
to
I'm
going
in
detail
of
what
this
process
owen
function
actually
does,
so
that
we
cover
the
contribution
side.
If
we
have
some
time,
we
can
go
that
how
the
entire
flow
works,
but
because
I
think
this
is
the
most
relevant
part
for
the
contribution
stuff.
So
let's
cover
this
thing
first.
So
what
what
we
have
covered
so
far
is
that
we
are
going
to
get
some
home
forms
and
home
conflict
which
we
have
no
idea
right
now.
What
it
is.
A
We
will
see
that
later.
So
what
we
are
trying
to
do
here
is
we
feed
the
home
pumps
that
we
have
received
or
the
slice
of
string
and
we
convert
into
own
pumpkin.
What
exactly
it
looks
like
is
here
you
would
actually
the
spec
has
updated
it's
on
version
0.3.0
right
now
what
we,
what
this
particular
ohm
components
in
home
config
these
actually
follow
version
0.1.1
v1,
alpha
one.
This
is
a
basically
the
we
are
not
updated.
With
this
pick.
A
As
of
now,
we
comply
with
version
0.1
0.1.0.
So
if
you
would
switch
to
that
branch,
you
would
be
able
to
see
this
particular
file,
which
is
actually
which
describes
that
how
application
components
should
look
like.
This
is
exactly
what
you
will
get
here.
This
function
is
exactly
doing
the
power
supplication
component,
and
so
the
application
component
that
was
sent
from
the
remote
side,
that
is
the
machine,
is
actually
now
converted
into
straw
lips.
A
So
yeah
the
basic
idea
is
that
we
just
converted
into
an
area
of
v
one
alpha,
one
dot,
confident
how
exactly
is
supposed
to
look
like
is
defined
here.
What
you
will
get
in
here
is
basically
this.
That
is,
you
define
some
workloads,
workflow
definition
and
trade
definition.
Okay.
Now
I'm
supposed
to
explain
what
worker
and
trades
are
we'll
keep
it
for
later.
The
thing
is
that
in
here
you
get
some
component
definitions
and
definitions.
As
we
talked
about
the
component,
definitions
will
have
names
like
this.
A
That
is
what
we
have
defined
in
json,
so
right
now,
this
is
the
resource
that
we're
talking
about
is
assuming
its
name
is
distinguished.
This
is
exactly
what
would
be
present
here
in
com.spec.net.
That's
what
you
are
going
to
get
so
I'm
mentioning
this,
because
we
will
encounter
it
in
some
other
function.
This
is
this
is
not
very
relevant,
but
we
are
just
extracting
out
the
component
definitions
and
conflict
definitions.
Let's
see
how
exactly
we
handle
them
now
now.
A
This
is
the
hardware
confidence
function
it
takes
in
the
area
of
component
and
is
it
a
delete,
operation
or
not,
and
then
we
try
if
we
see
that
comprehensive
type,
as
I
was
saying,
the
spectre
type
will
have
the
name
that
is
specified
here.
It
is
ensured
that
these
names
are
not
mismatched
by
mystery
server.
A
So
we
can
pretty
much
guarantee
that
if
this
name,
if
it
is
being
matched
here,
basically
every
time
it
will
be
matched,
it
will
be
valid
and
you
do
not
have
to
perform
any
kind
of
validations
on
this
end
because
every
validation
was
performed
on
the
mystery
server
side.
So
it's
pretty
much
guaranteed
that
everything
that's
coming
in
here
is
100
validated
for
now.
A
So
what
we
check
is,
if
the
us,
if
the
component
type,
is
istio
mesh,
then
we
can
just
go
on
and
try
to
provision
as
the
service
mesh,
and
if
we
see
that
the
type
is
virtual
service,
we
try
to
provision
virtual
service.
If
you
see,
if
it's
none
of
them,
then
we
actually
try
to
go
and
handle
these
the
ions
this.
This
comes
with
inherent
assumption
that
there
are
two
specific
kind
of
workloads,
but
one
is
istio
mesh,
one
is
virtual
service
and
the
rest
of
them
are
actually
irons.
A
Obviously,
if
one
of
the
thing
is
not
iron,
then
we
will
create
an
if
block
is
just
like
this,
because
this
is
the
recent
one
you
can
see.
It
is
created
a
week
ago
so
moving
on,
if
you
have
figured
out
that
the
type
of
workload
is
still
image,
then
you
can
actually
try
to
handle
that
workflow.
C
Now,
sorry
before
sorry
for
interrupting
yeah,
oh
so
that
pattern
om
function
that
term
it
didn't
look
like
it
had
anything
istio
specific
to
me.
Can
you
go
back
to
it.
C
Yes,
yes,
this
just
correct
me:
if
I'm
wrong,
there
is
nothing
still
specific
in
this.
A
Yeah,
actually,
it
gets
specific
a
bit
later
on.
So
the
thing
is
that
this
process-
this
is
just
our
pc-
this
rpc,
would
be
available
in
should
be
available
in
every
adapter.
This
is
just
a
way
for
machine
server
to
communicate
the
all
of
the
relevant
information.
That
is
the
application.
A
Confidence
in
our
issue,
cooperation,
those
kind
of
things-
even
memory
server
to
some
extent-
does
not
know
what
those
things
are,
because
it
isn't
supposed
to
exactly
know
that
what
those
things
are
it's
the
adapter
which
is
supposed
to
handle
those
kind
of
workloads
so
process.
Oem
is
definitely
not
very
specific,
not
very
linked,
specific
it's
by
design,
it's
not
very
specific,
but
when
we
come
into
the
details
that
what
process
om
is
exactly
doing
so,
you
would
see
that
here
this
compliment
istio
mesh.
A
This
is
where
it
starts
getting
specific
to
seo
service
mesh.
So
you
would
see
that
here
I'm
trying
to
actually
basically
I'm
trying
to
extract
version
from
settings
and
then
I'm
even
basically
casting
it
to
string.
A
I
would
I
should
have
checked
if
the
casting
is
right
or
not,
basically,
by
doing
something
like
this.
I
didn't
because
I
know
that
it
is,
it
is
supposed
to
be
string.
It
is
going
to
be
string.
The
reason
I
know
so
is
because
an
stms
definition
in
istio
mesh
json
schema.
This
is
something
that
we
can
talk
about.
I
have
already
specified.
This
is
something
that
actually
we
registered
to
machine
server
that
hey,
if
you
are
sending
me
anything,
please
do
verify
it
against
the
json
schemas
that
I'm
providing.
A
So
I
because
I
have
provided
that
version
is
supposed
to
be
string.
I
can
just
do
this.
I
I
can
pass
it
to
string,
so
this
is
where
actually,
it
starts
getting
very
specific
to
seo.
So
you
can
see
I'm
extracting
out
that
what
version
the
user
has
specified.
I
take
it
and
then
I
proceed
to
install
it.
This
function
is
actually
already
defined.
A
A
Responsibility
is
that
it's
going
to
get
an
application
component
definition,
it's
supposed
to
extract
out
the
stuff
that
it
needs
in
this
case
it's
version,
and
then
it
proceeds
to
call
the
older
function
that
it
already
had
and
that
so
we
haven't
seen
the
scene
how
install
it
still
works,
because
we
do
not
actually
we
may
have
to.
But
in
this
case
we
do
not
have
to.
This
was
a
functionality
that
was
already
available
in
the
adapter
and
that's
what
exactly
is
happening.
A
That
is,
we
are
just
kind
of
mapping
application
content
into
the
stuff
that
adapter
already
knows.
This
is
true
for
the
ac
provisioning
stuff,
but
may
not
be
true
for
other
things.
For
example,
if
you
would
see
virtual
service,
virtual
services
is
very
specific
concept
of
seo.
A
At
least
I'm
not
aware
of
someone
else
also
uses
virtual
service,
but
yeah,
it's
a
very
specific
concept
to
istio,
and
if
you
would
see
here,
there
is
no
function
which
so
here
we
already
had
a
function
called
install
istio,
because
this
functionality
was
already
available
in
the
adapter,
but
configuring
virtual
service.
That's
not
a
functionality
that
was
available
in
adapter,
so
here
we
get
a
bit
specific
to
it.
A
So
it's
what
we
do
is
we
create
something
that
looks
like
virtual
service
and
then
we
actually
extract
the
stuff
that
we
may
need
from
application
components
like
component.name
foundations
v.
This
is
actually
a
kind
of.
I
think
this
is.
This
is
documented
yeah.
We
are
not
supposed
to
touch
the
annotations
and
labels
because
we
do
not.
We
do
not
own
it
that,
after
us
do
not
own
it
own
it.
When
we
measured
us
misery,
can't
please
any
imitation
any
labels
so
that
it
can
keep
track
of
the
object.
A
So
we
just
taking
the
stuff
that
we
need.
We
pass
in
the
stuff
that
machine
server
has
passes
to
us,
and
then
we
actually
take
another
thing
that
we
may
have
need
may
have
made
it,
and
that
is
this
form.spec.settings
how
this
is
exactly
going
to
look
like
you
can
actually
see
it
in
here.
This
is
very
huge
because
this
was
converted
on
the
flat,
but
we
are
pretty
much
sure
that
this
thing
is
going
to
comply.
A
The
json
schema
that
we
have
provided
because
machine
shows
up
once
we
have
that
we
convert
it
into
yaman
and
then
just
apply
the
manifest.
This
is.
This
is
one.
This
is
example
of
functionality
which
was
not
present
in
the
raptor
and
it's
very
specific
to
the
patterns.
Only
patents
have
access
to
it.
For
now,
you
cannot
invoke
this
particular
operation
via
mesh
operation,
which
we
already
had
it's
a
rpc
that
we
already
have.
A
So
if
you
would
have
seen
the
ui,
you
cannot
basically
call
a
lot
of
operations
by
the
ui,
and
those
happens.
Why
are
my
shops
are
pc?
This
is
not
a
functionality
that's
exposed,
so
this
is
very
specific
to
very
specific
to
patents.
So
the
idea
is,
as
you
were
saying,
that
processor
is
not
specific
to
this
theo,
but
the
internals
of
processor
m
do
get
specific
to
see
or
every
other
after
that
may
be,
implementing
it.
So
under
the
mtl
is.
This
is
very
specific.
Okay.
A
This
is
specific
to
mtls
in
this
case,
but
not
that
empty.
That
is
only
supported
by
seo.
I
hope
that
you
got
the
idea.
C
Yes
and
the
json
schema
you
were
referring
to,
they
are
influenced
like
they're
decided
by
that
om
guidelines
right.
A
No,
so
the
jason
schema,
so
the
thing
is
the
thing
that
is
determined
by
the
home.
Spec
is
this.
That
is
the
definition,
so
you
will
see
that
it
says
code
or
ohm
dot
del
b,
one.
This
is
the
one
that
we
are
following
right
now,
and
this
is
actually
influenced
completely
by
the
spec.
However,
the
json
schema.
We
refer
the
json
schema
here.
That
is
the
definition.
Reference
is
actually
here
and
you
would
see
that
this
is
what
we
are
calling.
So
this
recent
schema.
A
This
is
not
controlled,
not
governed
by
the
home
spec.
This
is
completely
up
to
us,
provided
that
you
are
using
schema
or
draft
zero.
Seven
draft
eight
in
draft
four.
These
are
the
four
json
schema
version
that
mystery
supports
right
now.
If
you
would
provide
anything
else,
it
will,
it
will
throw
introduction.
It
won't
register
your
things.
So
these
are
things
that
are
not
going
by
by
the
doctor,
sorry
by
the
om
spec.
However,
this
thing
is:
they
are
very
interrelated
internally
to
the
extent
that
they
are
even
registered
together.
A
So
you
can
see
that
we
are
referring
the
same
file
in
here,
and
this
is
what
mystery
would
actually
use
to
figure
out
that
where
the
schema
is
so
that
it
can
actually
verify
your
pattern
file
against
it.
B
B
B
Okay,
okay,
good
and
then
so
do
you
know,
can
we
reference
that
perpet,
like?
Is
that
a
constant
that
we
are
able
to
define
and
then
just
reference
that
instead
of
istio
like
in
this
case,
like
the
the
more
that
we
look
to
propagate
this
set
of
functionality,
the
more
I?
Ideally,
it
is
copy
pasta
like
the
you
know,
ideally,
even
if
it's
specific
areas
we
have
to
go
swap
out
the
name.
Even
that
would
be
nice
if
it's
just
consistent
like
there's
no
name
swapping.
E
B
B
Let
me
get
out,
let
me
get
out
my
red
pen
hold
on.
Okay,
second
question
is
well,
there
may
not
be
it.
There
may
not
be
the
answer
that
I'm
hoping
for,
but
so
if
the
component,
the
spec
type
for
a
given
component
that
we're
interacting
with
is
of
type
virtual
service,
that's
unique.
It's
special.
We
need
some
consideration
for
it.
B
Brainstorm
allowed
with
me
is
there
any
way
that
we
can
not
have
a
long
collection
of
if
statements
like,
is
there
any
way
that
some
of
these
considerations
are
like,
like
that
this
can
be
more
dynamic.
That,
like
is
there
a
particular
attribute
of
a
component
of
the
virtual
service
component
in
this
case
that
needs
to
be
handled
in
such
a
special
such
a
way
that,
like
any
other
component
with
that
same
attribute,
we
would
treat
in
the
same
way,
and
so
it's
not
an
if
the
type
is
virtual
service,
it's
more
like.
B
D
Okay,
so
we
can
create
a
collection
of
them
like
like
a
set
of
strings
and
then
basically,
you
can
see
if
they
are
a
part
of
those.
A
D
D
Is
it
possible
that
we
can
statically
have
it
in
a
conflict
and
kind
of
compare
in
this
form
like,
for
example,
if
that
set
of
conflicts
is
let's
say
types,
then
we
can
say
that
if,
if
the,
if
this
particular
type
is
present
in
the
types,
then
we
can
do
the
following.
A
But
the
thing
is
that
probably
we
can,
but
still
because
the
sdms
installation
is
estimated,
is
your
issue
mesh
specific
and
so
is
virtual
service.
So
the
thing
is
that
we
still
have
to
invoke
different
functions
in
that
case,
the
reason
is
that
the.
A
Internals,
the
internals
of
each
each
object
each
service,
each
workload
gets
a
bit
different.
So
in
this
case
we
have
something
called
version
under
settings,
but
we
do
not
have
a
version
in
here.
So
the
thing
is
that
we
have
to
extract
out
different.
We
may
have
to
extract
our
different
things
in
different
type
of
workloads.
That's
why
we
have
different
functions
and
basically
that's
where
it
starts
diverging.
A
So
if
you
would
see
that
we
have
a
single
function
for
histo
add-ons,
because
all
the
add-ons
have
actually
the
same
kind
of
need,
that
is
all
of
the
add-ons
are
guaranteed
that
they
have
that
they
will
have
same
kind
of
settings,
so
we
can
kind
of
put
them
in
the
same
brother
and
we
can
operate
similarly,
but
just
some
other
things.
Yeah.
D
Yeah
so
so
in
that
case,
we
can
like
basically
map
the
type
with
a
function
like
we
can
store
it
as
a
conflict
with
the
combination
of
a
type
being
mapped
to
a
function.
D
A
Yeah,
which
we
can
do
that,
basically
a
map
or
yeah,
basically
a
map
we
treat
where
the
type
is
we
have
original
service
and
that
is
mapped
to
this
particular
function.
So,
basically,
then
this
thing
would
it
basically
would
support
suppose
we
will
shorten
up,
because
all
we
will
do
is
substitute
the
type
that
we
get
from
here
into
that
map
and
whatever
function
it
returns.
We
just
invoke
that
is
that
right.
D
B
And
so
yeah
we
don't
so
would
cars
just
to
put
myself
in
your
shoes.
B
These
two
topics,
at
least
on
this
call
right
now,
just
because,
because
you
know
it
may
take
some
contemplation
may
take
a
little
bit
of
reflection
to
the
goal
of
the
to
both
of
the
questions
are,
is
in
a
lot
of
respects
like
how
do
we
make
the
vast
majority
of
the
support
for
pattern
files,
the
code
of
it
like
consistent,
well,
we're
trying
to
make
it
ubiquitous
and
as
we
go
to
do
that,
to
facilitate
both
making
it
ubiquitous
and
of
high
quality,
it
would
just
be
extremely
consistent
like
it
would
be.
B
The
to
what
you
had
said
earlier
is
like
really
the
only
changes
that
navendu
and
adidi
and
and
others
that
are
contributing
might
put
in
it-
are
like
it's
fairly
well
highlighted
like
hey
it's
over
in
this
map
of
custom
resource
names,
or
something
like
that,
like
it's
and
or
it's
or
you
know
it's
in
various
areas,
but
but
it's
pretty
it's
a
little
bit
of
a
different
requirement
than
what
you
were.
B
B
Yeah
like
it's
just
it's
just
it's
some
of
it's
just
stuff
like
well,
and
I
don't.
I
don't
know
again
like
think
this
is
just
stuff
to
think
on.
I
don't
know
that
these
are
the
right
suggestions,
but
it's
like
on
line.
Seven
well
well
line
seven,
but
it's
like
handle
handle
component
istio
add-on,
it's
like
well.
B
Maybe
it's
just
just
a
generic
service
mesh
add-on.
Are
we
because,
because
the
others
come
with
have
similar
type
things
you
can
for
liquid,
you
can
enable
disable
or
like
anyway,
it's
if
you
reflect
if
you
t,
if
you
put
on
those
goggles
and
look
at
your
code
through
that
perspective
after
the
fact
maybe
some
of
it
becomes
more
generic,
maybe
that
maybe
it
makes
it
harder
to
understand-
and
maybe
that's
not
worth
it.
You
know
I
don't,
which
is
just.
A
So
we
can't
actually
do
what
publishing
persistent
the
reason
that
we
would
be
able
to
do
that,
because
that's
almost
what
we
have
here
this
is
that
yeah
it
will
be
more
more
concise.
The
thing
that
we
may
not
be
able
to
do
is
to
have
just
one
function
which
handles
every
time.
The
reason
is
the
same
that
I
was
specifying.
That
is
every
basically,
every
workload
has
different
kind
of
schema,
so
we
may
what
may
not
be
able
to
pass
it
out
generally.
E
A
So
I
think
we
are
pretty
much
done
here.
I
just
actually
we
were
talking
about
the
other.
While
we
were
talking
about
the
confidence
application
components,
it's
just
like.
We
have
home
components,
we
also
have
home
configuration,
we
may
be
able
to
go,
how
they
differ
and
what
they
are,
but
I'm
not
sure
if
you
have
time
for
that
but
yeah.
So
the
thing
is
that
just
like
home
conference
work
we
have
home
configuration.
A
The
difference
is
the
primary
difference
is
that
that
was
a
slice.
This
is
not
a
size,
because
the
thing
is
that
measuring
server,
for
for
the
first
thing
is
that
machine
server
is
pretty
smart.
It
figures
out
that
these
three
workloads
or
these
number
of
workloads
share
same
configuration.
So
what
it
will
do
is
it
will
create
home
components,
three
ohm
configurable
packet
and
it
will
create
a
configuration
which
is
which
is
being
applied
on
three
of
them.
A
So
that
is
why
actually
configuration
is
always
one
and
components
are
n
number,
so
mystery
server
is
smart
in
distance,
that
it
will
basically
create
the
right
configuration
and
write
confidence
and
pack
it
up
and
send
to
that
right.
Adapter-
and
this
is
all
this
also
complies
with
the
homestead
homeswick-
also
demands
the
same.
That
is,
they
can
be
a
number
of
application
content,
but
should
be
only
one
application
configuration
at
least
0.1.0.
A
So
this
that's
the
only
reason
that
we
have
this
as
non-slice,
and
that
was
slice.
If
someone
was
wondering
that
why
is
the
disparity
but
yeah
so
here
the
thing
is
that
just
the
same
concept
that
we
have,
that
is,
we
are
looking
through
the
components.
So
the
thing
is
that
application
configuration
if
someone
is
interested
can
definitely
look
at
the
spec.
A
Basically,
in
order
to
go
and
detail
that
how
exactly
application
application
configuration
looks
like
and
what
exact
thing
it
may
or
may
not
have,
but
but
the
basic
idea
is
that
application
configuration
has
some
an
area
of
components
and
in
all
of
those
contents
there
is,
there
is
trades
defined.
Let
me
show
about
in
that
that
will
make
it
more
helpful.
So
the
thing
is
that
we
have
something
called
traits
and
pattern
files,
so
one
trait
is
called
mtlas
and
the
digital
is
called
automatic
site.
A
Conjunction
these
traits
are
in
parallel
to
the
home
traits.
So
if
someone
is
going
to
look
at
the
a
spec
after
the
after
the
session,
then
they
may
be
able
to
draw
some
parallels.
So
the
thing
is
that
we
have
something
called
traits
in
there.
These
are
exactly
same
as
phone
fruits,
so
this
is
what
we
are
trying
to
extract
in
here.
That
is,
we
lean
through
every
component.
We
see,
for
example,
is
the
sumish,
and
so
we
we
encounter
istio
mesh,
and
then
we
see
if
history
mesh
has
a
trait
called
imperius.
A
If
it
does,
if
its
name
is
impedance,
then
we
actually
do.
Basically
we
handle
impedance.
If
it
has
a
trait
called
automatic
side
conjunction,
then
we
actually
handle
automatic
cycle
injection.
Now
again,
these
two
are
under
the
ifs,
because
the
way
that
they
are
supposed
to
be
handled
is
a
bit
different.
So
you
can
see
that
in
case
of
empty
list,
we
are
actually
specify
the
policy
which
is
not
the
case
for
automatic
cycle
injection
in
automatic
cycle
injection.
We
basically
just
handle
the
basically
we
label
the
name
species.
That's
what
exactly
happens.
A
So
you
say
in
here
that
hey
anybody
automatic
side
conjection
for
these
namespaces.
So
that's
what
we
are
doing.
We
get
the
namespace
that
we
have
specified
in
there
under
trade
stock
properties.
You
cannot
see
properties
in
there
because
that's
something
that
happens
automatically,
but
that's
basically
that
we
extract
the
name
species
from
there,
but
we
cast
it
to
something
because
it's
something
and
then
we
call
the
handle
namespace
label
because
actually
automatic
cycle
injection
in
case
of
steroids,
nothing
but
adding
label
to
the
namespace
to
learning
space
resource.
A
So
that's
what
we
do.
That's
why
they
are
being
handled
differently.
So
the
basic
con.
The
basic
concept
of
basic
idea
behind
both
of
the
function
is
pretty
much
same,
and
that
is
that
we
take
in
the
be
taking
the
configuration
in
format
of
o
in
format
of
what
ohm
spec
actually
defines,
and
then
we
just
map
it
to
something
that
adapters
already
know.
E
B
A
B
Okay,
now
all
right
you
can
we
can
I'm
gonna
ask
this
question.
We
can
bring
it
back
up
later
if
it
is
easier
to
answer
later,
but
you
had.
B
You
had
referred
to
these
two
paths:
two
types
of
operations,
one
being
that
of
meshops,
meaning
sort
of
the
current
generation
of
service
mesh
operations
that
are
supported
by
adapters
today
and
then
the
pattern,
ops
or,
if
I
can
use
that
phrase
for
the
way
in
which
you
know
we're.
Looking
at
now,.
B
A
So
actually,
process
volume
can
displace
the
mesh
shocks
because
processor
m
is
more
flexible.
Basically,
it
is
flexible
because
we
specify
the
home
point.
Big
ass
string
and
home
comps
are
string.
So
basically
we
can
package
anything
that
we
want.
We
can
convey
the
adapter,
then
it
can
process.
The
way
it
wants
to.
The
thing
is
that
mesh
shops
is
kind
of
restricted.
As
far
as
I
understand,
but
as
it
has
some
rpcs
that
can
use
those
rpcs.
Definitely
it
has
it.
It
has
the
advantage.
A
Basically,
the
flexibility
comes
in
that
it
can
specify
n
number
of
operation
under
category.
But
the
thing
is
that
they
can.
They
are
binary.
Operations
like
they
can
be
on
or
off
or
what
they
can
be
is.
Basically
they
can
be.
They
can
apply
a
custom
manifest.
So
the
thing
is
the
the
reason
I'm
advocating
for
processor
is
basically
it's
more
flexible.
It
can
package
anything
that
it
want
to
convey
to
the
adapters.
B
Thanks
that
makes
sense
yeah.
It
sounds
like
we're
on
a
journey
to
potential
and
evolution
of
mesh
ops
of
the
current
form
of
operations
that
eventually
those
would
we
would
anticipate
those
will
be
displaced
by
that
those
would
all
eventually
perpetually
be
invoked
or
displaced,
displaced
or
invoked,
depending
on
by
pattern
ops
by
the
process,
ohm.
The
reason
that
I
say
that
it's
kind
of
tentative
is
like
the
way
that
their
mesh
ops
as
they
are
today
are
put
to
bed,
I
think,
is
when
the
grpc.
B
D
B
A
Like
I
couldn't
actually
understand
whether
your
voice
was
freaking
a
bit
for.
D
B
So,
just
for
adida
who
might
be
watching
this
later
or
anyone
else,
who's
watching
it
that
navindi
was
asking
you
know.
Can
you
show
how
process
ohm
show
how
the
process
ohm
is
called
from
measurey
server,
so
how
the
ohm
components
and
ohm
config
are
being
passed
from
measuring
server
to
the
adapters.
B
A
Where,
where
a
process
om,
actually
the
rpc
processor
actually
gets
called
so
the
things
that
we
were
actually
showing
on
that
site,
that
is
the
site
that
the
same
things
are
actually
available
here.
Also,
that
is,
we
have
a
username.
We
have
to
lead
off
if
the
operation
was
subtitled,
we
are
passing
the
homecoms.
This
is
for
your
type
slice
of
string
and
we
are
passing
the
home
conflict
string.
Where
did
this
come
from?
The
entire
flow
actually
is
not
very
complicated.
It's
just
that
we
have
a
pardon
file
handler
this
pattern.
A
File
handler
is
supposed
to
get
in
get
a
pattern.
Yama,
we
read
it.
We
create
a
pattern
file.
This
is
just
passing
behind
the
scenes,
not
exactly
it
does
passing,
but
it
actually
does
some
extra
checks.
Also,
then
we
create
a
plan
plan
of
execution.
It
takes
in
something
called
policies.
This
was
being
used
earlier.
A
Basically,
it's
just
us,
so
if
you
would
imagine
plan
as
a
graph,
it
adds
additional
edges
into
this
graph
so
that
we
can
enforce
a
few
things
on
the
pattern
itself.
So,
for
example,
if
you,
if
you
are
trying
to
create
a
pattern
where
you're
trying
to
provision
istio,
trafana
and
prometheus,
so
just
by
doing
this,
what
you
can
actually
enforces
if
the
user
hasn't
defined,
that
grafana
should
be
provisioned
after
a
prometheus,
it
will
enforce
that
automatically.
It
can
increase
that
automatically.
A
This
is
not
being
used
in
anywhere
right
now
it
was
being
used.
So
here
you
can
see
it's
empty
now.
This
is
plan
is
basically
just
a
graph,
and
now
we
check
for
the
feasibility
of
the
plan,
so
here
basically
what
we
check
if
there
are
cycles
in
in
there
or
not,
you
can
actually
check
the
implementation.
It's
it's
under
models
with
these
models
here
this
is
being
called
om
in
my
directory,
because
I
have
an
older
version
of
this
older
version
of
mystery.
A
A
This
is
where
the
actual
cycle,
detection
and
those
kind
of
pilgrims
are
written
in
these.
The
other
two
letters,
so
you
can
add
more
or
maybe
I
will
so
yeah.
Basically,
this
is
feasible
function,
nothing
but
detecting
cycles,
as
well
as
some
other
things.
So,
if
the,
if
we
see
that
the
execution
of
the
plan
is
feasible,
we
proceed
or
else
we
actually
say
that
in
valid
pattern,
execution
is
in
feasible.
Now
we
just
function,
create
config
pairs
and
execute
action,
as
a
name
suggest.
A
It
actually
creates
a
component
with
pairs
and
proceeds
to
create
basically
execute
the
action,
so
it
takes
in
the
plan
and
file.
Preference
of
these
are
not
relevant.
So,
let's
see
what
that
is,
create
from
point
click
pairs
and
execute
action.
Basically,
what
it
does
is
it
generates
application
configuration
from
the
pattern
file.
You
can't
see
the
internals
of
this
function,
but,
as
the
name
says
it
basically
takes
takes
in
the
pattern
file
and
will
automatically
generate
the
application
configuration.
A
This
is
also
of
this
is
a
struct
v1
one
dot
configuration,
and
then
this
is
the
main
function
which
actually
performs
everything.
This
is
called
plan.execute,
and
this
is
the
internals
of
this
function
is
not
very
complex,
but
what
it
actually
does
is
it's.
The
plan
is
already
a
graph,
but
what
will
it
do?
It
will
create
a
parallel
graph
behind
the
scenes.
What
paragraph
is
basically
all
of
the
nodes
are
go
routines
and
they
communicate
with
each
other.
A
They
also
make
sure
that
if
one
of
the
dependencies
are
still
then
all
of
them
all
of
the
further
dependencies
should
feel
like
a
domino.
So
this
this
execute
function
has
all
of
the
the
magic,
but
he
can
see
the
basic
at
least
from
overview.
It
looks
like
it
creates
a
parallel
process
draft
and
then
it
starts
traversing.
A
It
executes
the
callback
cd
cd
that
you
have
given
it
on
every
node
that
it
visits
I'll
yeah,
we'll
probably
fill
half
time,
which
we
may
not
we'll
see
that
how
that
works,
but
yeah.
The
basic
idea
is
that
on
every
note,
these
functions
are
getting
executed.
What
these
functions
are
do
these
are
basically
creating
a
comp
config.
A
We
are
supposed
to
call
at
the
end,
basically
at
the
end
of
the
processing
that
we
have
done
on
our
portfolio,
we'll
create
application
configuration.
We
do
some
further
validations
that
this
is
where
we
actually
validate
json
schema
and
those
kind
of
things,
and
once
we
have
done
all
of
the
validation
we
actually
create
a
we
create
the
we
create
the
entire
pair,
that
is
compound
filter,
and
then
we
finally
call
the
handle
config
pair
action.
A
So
this
is
where
this
is
where
this
is
how
ohm
comps
gets
generated.
That
is
this.
Is
your
application
component
button.
This
is
your
configuration
code
generator
and
then
we,
finally,
when
we
are
done
making
sure
that
json
schema
is
being
validated
all
of
the
trades
are
being
validated.
Actually
there
are
some
of
the
some
of
the
restrictions
are
being
put
by
the
home
specs,
for
example,
you
have
to
specify,
in
the
in
the
definition
files
like
these.
A
A
So
here
we
are
specifying
traits
called
mpns
and
automatic
site
injection,
but
you
cannot
specify
empty
the
straight
under
here.
The
reason
is
that
you
have
specified
an
emptiness
definition
that
hey
this
rate
is
specific,
is
can
be
applied
only
to
stimus,
and
that
is
also
a
validation
that
we
perform
here.
This
is
the
this
is
also
one
of
the
validation
that
we
perform
here.
Once
we
have
validated
that
validated
retreats
validated
the
workloads,
then
we
actually
finally
called
the
100
component
pair
action.
A
This
is
where
actually,
this
is
not
a
very
special
special
function.
This
is
not
very
intelligent.
What
it,
what
all
it
does
is.
Basically
it
converts
it
the
component
that
we
have
already
generated
so
far
and
the
configuration
into
json
quantity,
and
then
it
just
calls
the
execute
action
function
that
we
saw
earlier,
that
is,
it
calls
the
rpc
with
the
information
that
we
have
provided
yeah.
I
hope
that
made
sense.
Actually
this
is
this
is
a
hack.
A
I
placed
this
hack
because
adapters
used
to
at
least
crash
when,
when
the
operations
were
too
quick,
so
what
I
I
did
as
a
hack
was,
I
put
the
process
to
sleep.
That
is,
there
would
be
10
microseconds.
The
process
would
sleep
for
10
microseconds.
I
I
think
this
is
fixed
now,
so
we
can
probably
remove
this,
but
earlier
there
was
an
issue
that
adapter
needs
to
just
crash,
because
it
cannot
handle
the
actions
so
frequently
so
quickly.
A
So
that's
the
entire
processing
overview
is
that
initially
receives
a
patent
file.
It
creates
a
plan.
It
takes
a
feasibility
once
it
has
checked
the
feasibility,
it's
executing
it.
It
starts
executing
all
of
them.
Parallely,
it
also
takes
the
validation,
creates,
appears
and
then
finally
invoke
the
rpc
and
then
the
risk
is
handled
by
by
the
adapters.
One
other
thing
that
the
execute
function
does
is
that
you
can.
Actually,
if
you
return
an
error
from
the
rbc,
execute
action
will
make
sure
that
it
captures
that
error.
A
It
packs
it
with
and
sends
it
back.
At
the
same
time,
it
also
makes
sure
that
all
of
the
dependencies
or
gets
to
know
that
hey
one
of
your
dependencies,
that
is
one
of
your
parent-
has
failed
now,
it's
time
for
you
to
pay,
so
all
of
the
trials
will
start
feeding
so
yeah.
This
is
also
something
that
is
being
handled
by
the
execute
function.
A
A
B
Well,
one-
and
these
are
design
questions
I
guess,
but
do
we
have
an
operation
id
yet.
A
No,
no,
not
yet.
Okay,.
D
D
B
B
Oh
okay,
okay.
B
And
that's
in
part,
because
we're
going
to
want
to
build
on
the
messaging
notification
center,
hey
where
I
asked
measure
to
do
something:
where
is
it
at
now?
Actually,
as
we
think
about
that,
the?
U
n,
as
we
look
at
something
like
the
planner
use
of
temporal
or
the
integration
of
a
workload
engine
and
the
notion
that
it
would
have
ids
for
everything
that
is
invoking,
you
know
every.
B
Process
that
it's
running
might
be
something
we
would
leverage
instead
of
the
our
own
id.
It's
it's
okay,
to
have
multiple,
but.
B
So
is
the
username
so
anyway,
there's
that
thought.
The
other
thing
is:
is
the
username
enough,
so
the
user
that
invoked
the
operation
from
there?
You
could
derive
what,
whether
or
not
they
have
permission
to
do
that,
because
they
would
ultimately
you'd
be
able
to
look
up
what
role
they
have.
What
infrastructure
they're
asking
this
operation
to
be
invoked
upon?
That's
part
and
parcel
to
the
operation
itself,
what
account
or
organization
they
belong
to
the
basically
like
in
the
planner
itself.
E
B
B
Another
thought
here
just
to
clarify
inside
of
mesherie's
server
the
host
that
the
rpc
is
being
invoked
against.
That
host
in
this
case
is
the
adapter.
B
Is
because
the
the
other
host,
the
other
infrastructure,
you
know
the
so
the
kubernetes
cluster,
the
namespace,
the
the
rest
of
it,
becomes
a
point
of
consideration
as
we've
got
to
support
multiple
clusters,
multiple,
you
know,
and
that's
also
in
the
context
like
if
we
look
at
okay,
so
by
the
way,
these
call
types
is
that
raw
adapter
is
that
mesh
ops
and
home
adapter.
That's
pattern:
ops.
A
Yeah,
actually,
this
raw
doctor-
I
forgot
completely,
but
this
was
yeah.
I
said
that
applying
customer
operation
is
not
supported.
Actually
it
is
I
I
created
it
four
months
ago,
I
forgot
about
it
so
yeah,
basically
rod
after
is
basically
being
able
to
apply
raw
operations,
that
is
which
are
not
patent
via
button
files.
This
form
adapter
is
basically
the
remote
home
adapter
operations,
and
this
non-local
is
basically
oh.
A
I
have
the
older
version,
but
you
would
see
that
there
is
another
type,
none
local
and
that
is
basically
the
internal
operations.
That
is
the
present
in
the
application
one.
This
is
actually
the
older
version.
I
guess
so
it
does
not
have
that.
But
what
there
are
three
call
types,
one
is
none
local.
A
The
second
is
rod
after
third
is
home
adapter
home
adapter
is
the
remote
rpc's
raw
adapters,
also
remote
rpcs,
but
which
are
the
operations
which
are
not
facilitated
by
process
oem,
but
rather
the
older
shops
and
none
local
is
basically
the
internal
pulse
that
is
process
om,
but
the
internal
one.
I
do
not
have
that
here,
but
probably
we
have
here
that
probably
I
know
itself.
B
For
an
adapter,
okay,
yeah,
I
wonder
if
this
again
is
just
a
forward.
Thinking
thing
is,
I
wonder
if
we
don't
need
an
extension
point
explicitly
defined
like
the
adapter
itself
is
basically
the
entire
thing
is
an
extension
point
for
mastery.
You
design
behind
these
rpc
interfaces
and
you
can
bring
an
adapter
now
within
an
adapter.
We
haven't
discussed
much
areas
of
extensibility
with
respect
to
a
couple
of
things.
One
is
extended.
A
So
if,
if
measuring,
is
being
provisioned
somewhere,
where
the
I
and
it
is
reachable
while
the
public
internet,
so
what
can
happen
is
that
is
basically
they
can
send
their
capabilities
to
that
endpoint
and
when
actually
measuring
machine
would
come
here
I
mean
when
this
function
is
being
executed.
It
will
see
the
host
and
because
that
post
should
be
resolvable
resolvable
via
the
dns,
it
will
get
resolved
and
the
fall
would
be
actually
to
somewhere
else
communities.
A
This
is
this
can
also
be
a
security
talk.
That
is
hey.
Anyone
can
reach
out
to
the
end
point.
Anyone
can
raise
the
capabilities
and
potentially
can
draw
the
traffic
outside
the
cluster,
but
this
can
also
be
a
extension
point.
That
is
you
raise
to
the
capabilities
by
the
coming
through
the
big
internet.
If
you're
exposed
missionary
and
our
ministry,
we
miss,
you
would
just
look
at
the
hosts
that
were
provided
in
the
capabilities
and
it
will
try
to
invoke
rpc
on
that.
B
Yeah
yeah,
so
in
many
respects
like
basically
that
that
treats,
if
you
want
to
bring
your
own
adapter,
you
can
and
you
can
register
your
own
adapter's
capabilities,
which
is
more
or
less
what
you're
just
saying.
I
think
if,
but,
if
you
consider
that
a
little
more
surgically
like
if
you
wanted
to
provide
because
generally
the
model
would
be
that
well
not
always,
but
generally
the
model
would
be
that
you'd
want
to
have
a
deployment
of
a
management,
adapter
or
management.
B
You
know
like
sort
of
a
measuring
adapter
and
have
it
deployed
locally,
have
it
you
know
authorized
within
your
systems
are
accounted
for
and
that,
if
you
you
know
like
ideally,
the
extension
point
would
be
internal
to
the
existing
adapters
that
remote
providers
can
layer
on
additional
supported
operations
that
might
get
into
a
whole
mess
of
discussion
that
we
don't
need
to
go
into
now,
because
it
might
be.
B
You
could,
on
behalf
of
an
adapter,
you
could
register
a
capability
that
the
adapter
doesn't,
you
know,
didn't
explicitly
register
for
itself
a
separate
entity.
A
provider
could
register
a
capability
on
the
adapter's
behalf,
saying
that
that
capability
is
supported
by
the
adapter,
not
not
not
by
the
remote
provider
but
by
the
adapter
itself.
B
B
It
seems
like
you
could
layer
in
additional
operations
that
way
the
the
problem
is
most
of
the
time.
The
operation
that
you're
going
to
want
to
register
probably
has
its
own
special
considerations
that
you
would
need
to
have.
You
would
ideally
have
compiled
into
the
adapter
and
so
good.
I
think
that
that's
a
solvable
thing,
I
think
it's
a
little
bit
of
a
like
it'll,
take
some
conversations
and
design
and
et
cetera
and
we'll
have
to
figure
out.
B
If
that's
something
we
really
want
to
do
or
if
you
just
leave
the
extension
point
at
the
macro
level
saying
well,
you
know
remote
provider
you're
welcome
to
register
your
own
adapt
adapters
and
those
can
bring
their
own
operations
and
you
can
provide
the
plumbing
to
invoke
the
you
know.
Basically,
why
don't
you
just
provide
an
adapter
and
then
and
have
the
client,
the
user
spin
it
up
as
a
separate
as
a
separated
app?
B
Why
don't
you
just
fall
into
the
model
and
not
try
to
do
something
dynamic
externally,
et
cetera,
but
more
like
just
provide
another
adapter
and
have
them
spin
it
up
and
it'll
register
its
operations.
Just
like
anything
else,
it's
not
as
sleek
I
mean
the
separation
of
concerns
is
clear
in
that
model,
it's
not
as
it
would
be
like,
for
example,
with
mesh
map.
B
If
you
went
to
a
whole
different
ui
great,
you
could
go
use
mesh
map
in
a
different
ui
and
it's
very
clear
separation
of,
but
it's
not
nearly
as
slick
as
just
having
mesh
map
right
there
you
know
and
so
cool.
I
don't
know
that
we
would
right
now
that
we
need
that.
We
need
to
give
any
consideration
to
that
extensibility
that
I
just
mentioned
it
can.
B
Be
yeah
not
unless
yeah
yeah,
when
we
go
give
consideration
to
it.
It
might
be
something
where
we
have
a
catch-all,
a
catch-all
type
of
operation
that
can
be
registered.
B
A
So
that's
pretty
much
it
the
at
least
from
the
contribution
thing.
We
have
other
things
like
being
able
to
like
what
the
entire
flow
of
the
operations
is,
that
how
things
get
registered,
I'm
not
sure.
If
that's
something
that
we
would
be
going
and
do
or
should
we
I'm
not.
C
B
B
A
I
think,
as.
E
A
Probably
of
sheep
can
correct
me,
but
as
far
as
I
can
think,
this
can
just
be
another
field
in
here
which
states
population
id
and
is
being
controlled
by
mystery
as
a
single
entity
that
so
basically
stamps
the
from
the
request
with
some
operation
id.
A
Yeah,
it's
not
a
separate
photo
as
far
as
I
remember
at
least
the
last
I
checked
it
was
not
a
separate.
What
is.
A
Yeah
it's
in
the
same
product
just
like
other
operations,
cool,
okay,.
D
B
Cool
crash,
it
sounds
like
yeah
sounds
like
the
that
it's
worth
it
in
your
mind,
the
refactoring
to
be
a
little
more
generic.