►
From YouTube: Layer5 Development Meeting (Sept 16th, 2020)
Description
Extensibility of Meshery Remote Providers..
A
C
Very
nice,
so,
as
you
can
see,
I
just
booted
up
the
ui
in
which
I've
configured
my
cluster
and
I've
also
configured
my
adapter.
Basically
I'm
running
on
a
kuma
adapter
right
now
and
yeah.
So,
let's,
let's
begin
with
the
test,
so
basically
to
run
the
conformance
test.
You'll
have
to
go
here
and
then
press
on
validate
conformance
option
and
that
would
internally,
in
the
background,
begin
the
test,
and
so
this
this
test
would
approximately
take
around
like
a
good
ten
minutes.
So
I'm
gonna.
D
D
D
C
Really
sure
I
just
take
it
off
and
I
can
see
this
has
been
running
so,
let's,
let's
so
until
then
I'll
fill
the
gaps
basically
to
until
the
test
comes
back.
Test
results
come
back,
so
basically,
when
the
results
come
back
it
it
would
be
a
notification
in
here
and
that
the
results
have
been
processed
persisted
in
the
measuring
server
and
each
of
the
test
result
would
look
something
similar
to
this.
C
So
that's
that's
yet
to
be
merged.
So
if
that
is
that
is
in
then
yeah,
this
this
process
would
be
completed
and
yeah.
So
basically,
this
is
the
overall
idea
of
what
you're
going
to
achieve
here,
and
so
so,
if
you
look
at
the
columns,
it
shows
you
about
every
detail.
When
the
test
has
learned
what
is
the
mesh
version
and
the
mesh
name
on
which
it
ran,
it
is
the
percentage
of
the
performance.
C
Basically,
we
run
several
test
cases
over
different
specs
of
smi,
and
the
percentage
pass
would
evaluate
the
the
rate
of
conformance
of
that
particular
service
mesh.
To
view
more
details,
you
can
click
on
this
drop
down
here
so
that
it
will
give
you
more
details
on
each
spec
that
it
ran
on.
Basically,
we
right
now
have
three
specs
on
which
we
run
the
conformance
test
and
yeah.
C
So
that's
that's
pretty
much
all
the
details
and
we
should
see
the
missing
columns
here
in
which
the
data
is
not
present
yet,
but
that
that
pr
is
actually
in
place,
and
it
should
be
shortly
becoming
and
just
to
note
this
way.
The
previous
test,
which
abhishek
ran
yeah
before
so
in
about
like
in
a
couple
of
minutes,
the
the
test
that
I
just
ran,
should
come
up
as
another
result
as
another
row
in
here.
So
until
then
yeah,
I
guess
lee
should
be
fill
it
with
something
else.
Fill
the
gap.
D
C
C
C
D
So
let
me
let
me
take
some
liberties
here.
One
is,
I
think,
I'm
gonna.
I
was
hanging
out
on
the
google
meet
and
I'm
gonna
quit
that
because
it's
really
distracting,
but
I
wanted
to
make
sure
that
anyone
who
accidentally
joined
there
got
redirected.
So
I
think
we're
good,
because
I'm
excited
about
folks
like
pratik,
who
are
on
the
call
who
are
relatively
fresh
and
shubham,
whose
audio
is
just
about
to
come
on
out:
hey,
hey
shubham.
We
were
just
kind
of
waiting
for
you
to
join
sort
of.
D
D
I
wanted
to
make
sure
that
everyone
had
the
right
context
for
what
abhishek
and
dhruv
are
showing
here.
This
has
been
a
work
in
progress
from
kush
and
naveen
and
kaneshkar
from
a
collection
of
people,
and
I
might
not
have-
I
might
have
missed
some
people
in
that,
but
very
briefly,
mesherie
interacts
with
eight
different
service
meshes
a
lot.
I'm
got
my
fingers
crossed
that,
maybe
by
before
the
end
of
this
month
that
we
would
interact
with
the
ninth,
there
was
a
new
service
mesh
that
just
was
announced
yesterday.
D
It's
like
one
ring
to
rule
them
all
one
api
to
rule
all
the
functionality
of
the
service
meshes
and
as
each
individual
service
mesh
project
goes
to
conform
to
that
standard
api
they
may
or
may
not
implement
all
of
the
apis
or,
if
they
do,
they
might
implement
the
behavior
that
that
service
mesh
has
might
be
divergent
from
the
specification
of
the
api,
and
the
effort
that
the
community
here
is
giving
is
to
confirm,
is
to
validate
or
confirm
conformance
of
each
individual
service.
Meshes
implementation
against
that
standard.
D
D
Given
that
context,
that's
a
pratik
and
shubham.
I
was
sort
of
calling
you
guys
out
to
make
sure
that
that
you
were
paying
attention
and
you
had
kind
of
a
understanding
of.
What's
going
on,
I
know
shubham,
you
didn't
get
to
see
the
demo
just
now,
so
this
is
not
a
fair
question
for
you,
but
just
you
know
pratika
as
a
way
of
like
kind
of
cracking
the
breaking
the
ice
so
to
speak
in
any
feedback
that
you
have
of
what
you
saw
can
any.
D
D
D
You,
wouldn't
you
still
wouldn't
yet,
have
results
available
and
persisted
on
the
left
hand
side,
but
I
guess
just
a
fairly
high
confidence
that
when
you
invoke
a
set
of
validations
here
after
10
minutes
or
so
you'll
get
the
results
back.
If
the
user
was
on
a
different
screen,
they'll
see
the
notification
come
through.
That
says,
results
are
complete,
I
probably
probably
missed
it,
but
do
we
navigate
them
over
to
the
specific
service
mesh,
the
specific
adapter
that
those
tests
were
invoked
from
is
that
where
they
see
the
results.
C
C
D
C
D
Briefly,
like
a
lot
of
this
is
obvious,
I
know
you
get.
I
know
this
is
a
work
in
progress,
so
it
doesn't
really
help
to
like.
So
just
the
the.
If
you
go
back,
if
you
minimize
the
table,
you
kind
of
go
back
to
the
the
the
id
just
these
things,
I'm
sure
that
you
guys
are
already
all
getting
to,
but
it's
probably
it
is
good
to
kind
of
just
let
people
know
that
these
are
individual
like
to
show
them
the
id
column.
D
D
Inside
and
so
I
understand
that,
hey
under
the
under
the
percentage
past
you'll
have
an
aggregate
number
that
says
you
know
of
the
30
something
tests
you're
at
70
pass
rate.
Or
what
have
you
that's
great?
Here's
your
service
mesh,
here's
the
version
that
it
was
done.
It
might
be
that-
and
I
I
now
I
can't
remember
quite
what
was
in
the
mock-up,
but
it
might
be
that
it's
appropriate
to
show
the
smi
version
that
we're
that
this
test
suite
was
run
against.
C
Actually,
basically
I'll
move
the
smi
version
inside
and
here
because
the
issue
is
that,
let's
say
if
we
are
running
traffic
axis
for
alpha
one
p1
and
we
are
running
classic
split
on
something
else
like
beta1
v1,
then
that
it's
it's
specific
to
the
spec
rather
than
it's
specific
to
it.
It's
not
specific
to
the
test.
So
that's
very
important.
D
C
B
C
D
C
C
That
was
done
in
the
background,
and
so,
if
you
click
on
any
of
on
any
one
of
them,
you
would
get
the
the
test
and
the
assertions
that
run
inside
that
random
site.
So
basically
on
every
specification,
it's
my
specification
like
a
traffic
access,
split
or
spec
and
how
long
it
ran
for
and-
and
there
are
like.
C
There
are
a
couple
of
missing
parameters
in
here
which,
for
which
we
put
a
pr-
and
that
is
to
be
done
by
today,
so
yeah,
so
those
parameters
will
also
get
filled.
So
basically
it
will
show
you
all
the
capabilities
and
and
all
the
results
of
how
conformant
the
meshes
with
the
service
mesh
interface
so
yeah.
So
that's
that's
pretty
much
what
I
have
demo
in
here.
C
So
if
you're
wondering
what
smi
is,
then
it's
basically
a
set
of
specs
that
that
any
service
mesh
could
use
to
sort
of
develop
their
own
service
mesh,
and
so
these
specs
are
nothing.
But
a
set
of
crds
that
that
facilitate
you
know
to
build.
A
service
must
show
that
that's
pretty
much
this
just
of
what
smi
is,
and
we
are
just
running
a
test
to
make
sure
that
make
sure
to
test.
If
the
service
mesh
is
confirmed,
how
how
conformant
is
the
service
mesh
with
the
with.
B
D
Fair
enough!
I
suspect
there
isn't
any
additional
feedback.
Nice
work,
guys
we're
almost
there.
It
is
time
for
us
to
engage
with
a
couple
of
the
with
the
kuma
team.
As
a
good
example,
they're
aware
of
this
effort,
I
messaged
with
them
recently
it's
I'll
go
ahead
and
initiate
a
mail
thread
with
the
kuma
team
actually
and
see
if
we
can
have
them
start
to
start
to
test
it
out.
F
With
yeah,
okay,
so
in
this
presentation
I
will
be
talking
about
go
plugin,
a
tool
built
by
hashicorp.
It's
an
open
source
project.
So
before
that,
I
would
like
to
give
some
context
about
plugins
and
a
little
detail
about
them.
So
first
I
would
like
to
talk
about
how
do
we?
How
can
we
build
plug-able
apps?
So
the
google
app
is
is
nothing
but
an
extensible
app,
for
example,
your
browser,
in
which
you
can
add
extensions,
something
like
that.
F
Okay,
so
some
terminologies
that
I
will
be
using
a
host
a
host
is
nothing
the
main
app.
The
main
process,
for
example
browser
and
plugin,
is
nothing
but
an
extension
and
interface
interface
is
basically
a
definition
of
something
like
a
collection
of
methods
or
something.
Okay.
Let's
just
go
back
then
yeah
how
to
build
the
giveaway.
So
as
simple
and
intuitive
approaches,
let's
create
an
interface
collection
of
methods.
Our
host
will
just
call
those
methods
and
our
plugin
will
implement
them
now.
F
Okay,
so
yeah,
we
implemented
our
plugin.
We
have
prevented
the
interface,
then
how
we
are
going
to
add
that
plugin
to
our
host
okay,
so
one
approach
is
that
yeah
we
will
just
implement
that
in
a
new
file
and
we
will
add
the
file
to
our
host
code
so
that
host
will
directly
can
just
load
the
plugin
code
and
directly
access
the
methods.
F
That's
one
approach,
but
there
are
some
pros
and
cons
related
to
it.
Yeah
it's
beginner
friendly.
Essentially
what
a
plugin
developer
will
do
it
will
he
will?
He
will
just
implement
the
interface
easy
to
install.
We
just
have
to
copy
and
paste
the
paste
the
file,
but
there
are
some
columns
like
language,
for
example,
language
constraint.
So
if
the
host
is
written
in
go
then
we
cannot
use
any
other
language,
for
example
python
or
some
other
language.
We
have
to
write
the
plugin
in
go
itself.
F
Another
is
stability.
So
what
what
do
I
mean
by
stability
here
so
for
say
our
host
our
host
will
work.
Fine
if
there
was
no
plugin
means.
What
I'm
going
to
say
is
if
there
is
some
error
in
plugin
and
our
code
will
just
our
the
panic
will
the
plug
the
plugin
will
panic
and
our
host
will
again
panic
with
it.
So
that's
an
issue
because
I
I
don't
want
that.
Okay,
some
a
user
has
added
some
plugin
and
because
the
plugin
was
panicking.
F
My
my
whole
program
just
crashed
because
my
host
may
be
running
other
plugins
and
maybe
it
it
was
doing
some
other
work
too.
So
I
don't
want
that.
So
next,
next
approach
is
plug-in
as
a
process.
So
what
we
can
do
is
we
can
just
it's
what
we
can
do,
so
our
host
will
be
one
process
and
our
plugin
will
be
one
process
and
they
will
be
talking
over.
F
Some
networks
see
some
tcp
connection
or
something,
and
the
idea
here
is
same,
that
we
are
using
interface
because
yeah
we
want
to
have
those
things
like
beginner,
friendly,
easy
to
install
beginner
friendly,
easy
to
implement
and
those
things,
and
in
fact
this
will
be
easy
to
install
too,
because
we
just
have
to
run
the
plugin
process
and
run
the
host
process
and
they
will
communicate
okay.
So
how
do
we
add
the
plugin
to
our
host?
F
F
So
let's
talk
about
go
plugin.
So
all
the
pros
all
the
cones
go
plugin
has
taken
care
of.
I
like
almost
all
of
them,
so
plugins
are
essentially
go
interfaces,
which
is
nothing
but
collection
of
methods
and
gross
language
support.
We
can
implement
plugins
using
grpc.
We
can
implement
plugin
using
rbc2,
but
if
we
want
close
language
support,
then
we
have
to
implement
the
plugins
using
grpc.
F
F
A
host
and
a
plugin
will
have
to
run
on
the
same
machine,
same
localhost
machine
if
they
are
running
on
different
machines,
so
say
hosting
running
on
your
machine
and
plugin
is
running
also
some
remote
machine.
Then
this
won't
work.
It
will
just
give
us
some
unexpected
results,
some
unexpected
errors.
It
is
remote
support.
F
There
is
no
support
for
remote
plugins
right
now,
and
there
are
so
many
other
features
too,
like
logging
and
all
those
things,
but
I
this
these
were
the
most
important
features
that
I
want
to
talk
about
and
yeah.
Okay
get
this.
Let's
talk
about
them:
okay,
yeah!
This
was
the
hardest
part
of
this
presentation.
I
just
couldn't
get
this
thing
right.
So,
let's
talk.
I
have
implemented
both
the
grpc
and
rpc
plugins,
but
I
will
go
through
the
grpc
and
rpc
is
essentially
the
same.
F
So
the
core
idea
behind
go
plugin
is
that
it
should
be
as
easy
as
possible.
It
should
be
like
that.
Plugin
is
implementing
an
interface
and
the
course
is
consuming
that
interface,
so,
for
example,
so
let's
just
go
through
the
code,
and
this
will
help
you
understand
it
a
little
bit
more.
So
what
we
are
doing
in
this.
F
So
okay,
we
just
created
a
client,
and
this
is
rpc
client.
So
it
is
some
you
can
say
it
is
some
something
related
to
network,
not
exactly
network.
It
is
related
to
the
plugin,
and
in
that
plugin
there
will
be.
There
may
be
multiple
multiple
services
running.
You
can
sales,
for
example,
creator
service
or
maybe
some
other
kind
of
service,
some
other
kind
of
methods,
so
I'm
just
getting
the
greater
one
from
that.
Plugin
and
the
client
will
be
loaded
into
this
row.
Now.
F
What
I
am
doing
is,
I
am
basically
just
converting
the
interface
to
the
I'm,
just
basically
converting
the
interface
to
the
interface
that
I
have
divided.
I
will
cover
that
in
face
in
a
moment,
but
essentially
now,
what
I'm
just
doing
is
I'm
just
calling
the
method
over
this
creator
that
is
created
and
nothing
else
so
yeah
it
is
just
you
can
here.
F
There
are
some
details
related
to
the
plugins
related
to
the
go
plugin,
but
essentially,
if
you
see
what
is
doing,
it
is
just
consuming
an
interface
that
is
greater
okay,
yeah
and
let's
go
to
the
plug-in
side.
Now
get
this
right
in
plugins,
nothing.
We
just
implemented
the
we
just
implement
the
greater
interface
and
then
just
pass
it
to
the
greater
plugin
and
everything
will
be
handled
for
us
and
yeah.
We
are
just
serving
this
and
that's
it
so
this,
if
you
see
this
thing,
will
is
same
for
like
many
different
plugins.
F
F
So,
okay,
now
the
host
and
the
plugin
has
to
talk
to
each
other
right.
So
he
has
to
agree
upon
the
common
language
they
can
understand
each
other.
So
what
we
are
doing
is
so
this
is
the
interface
which
both
of
them
has
to
implement.
So,
no
so
you
know
both
of
them
have
to
implement.
The
plugin
is
implementing
this
interface
and
our
host
is
consuming
this
interface,
okay,
and
so
right,
as
I
said
that.
F
Right
now,
the
this
this
plugin-
I
had
made
this
plugin
to
run
over
grpc,
so
I
have
to
create
a
grpc
client
and
I
have
to
create
a
grpc
server
for
that.
Grpc
client
will
do
nothing,
but
it
will
just
scroll
the
the
like
in
grpc
what
it
does.
It's
just
cool,
this
great
method
and
it
just
get
a
response
and
yeah.
It's
just
return
that
response,
that's
it
and
grpc
server.
What
this
thing
is
doing
is
it's
basically
implementing
the
server
for
our
grpc
and
yeah.
F
This
great
method
will
run
because
of
the
remote
procedure
course
this
method
will
work
and
greater
plugin,
so
we
defined
this
grpc,
client
and
grpc
server
to
basically
define
how
how
grpc
will
work
and
creator
plugin
will
basically
give
us
the
grpc,
client
and
grpc
server.
So
let's
go
here:
let's
go
to
main.com,
okay,
so
I
am
getting
here
this
creator.
Now
I
have
to
define
somewhere
that
what
this
creator
is
like.
So
it's.
F
Yeah
here
I
am
defining
a
plug-in
map
and
that
plug-in
map.
I
am
defining
that.
Okay,
if
you
want
to
get
something
related
to
greater,
then
you
will
get
this
struct
griddle
plug-in
okay,
now
but
main
notebook,
but
the
host
will
do
it
will
get
that
written
plug-in.
It
will
use
the
grpc
client
method
of
that.
So
grpc
client
is
doing
nothing
but
returning
the
client,
jrbc
client,
and
that
will
just
call
the
that
will
just
call
that
method.
F
The
great
method,
okay
and
now,
let's
come
to
grpc
server,
so
this
grpc
server
will
be
used
by
the
plugin
okay.
So
first
we
have
to
initial.
We
have
to
basically
initiate
instantiate.
We
have
to
create
an
instance
of
twitter
again,
so
we
are
just
showing
that
here
shared
creator
plugin
and
we
are
just
passing
it
our
implementation
of
the
creator
interface
and
we
are
just
storing
it
in
a
map
and
the
plugins
now
what
grp?
But
this
will
do
this
plugin
dot
server.
F
It
will
basically
just
run,
and
this
grpc
server-
that's
it
and
that's
how
they're
basically
talking
to
each
other
and
all
these
things,
grpc
server
and
everything
is
go.
Plugin
is
taking
care
of.
All
of
that
we
just
have
to.
Essentially
we
just
have
to
implement
this
interfaces,
and
so,
as
I
talked
about
the
language
that
we
have
to
first,
we
have
to
define
a
language
in
which
they
will
talk,
so
this
jrbc
dot
profile
is
basically
defining
that
language,
and
these
are
the
interfaces.
F
These
are
grpc,
client,
grpc,
server,
plugin
and
these
file
will
be.
This
file
will
be
shared
between
the
host
and
the
plugin.
So
again,
we'll
implement
the
interfaces
by
us
using
this
file
and
our
host
will
run
the
will
consume
the
interface
using
this
right.
So
this
is
basically
a
transfer
you
should,
you
can
think
of
it
as
no
not
exactly
transferred.
We
are
adding
all
the
details
about
the
interfaces
and
how
grpc
will
work
to
this
file.
This
grpc
good
profile.
F
F
This
so
I
ran
the
jtc
host
program,
but
it
did
okay,
it
started
the
plugin
like
it
started,
waiting
for
our
pc
address.
So
when
our
host
will
start
the
we'll
start,
this
plugin
as
a
child
process,
the
child
process
will
return
its
ip
address
its
protocol,
its
port,
for
which
it
is
running.
It
is
accepting
connection
in
standard
out
and
our
host
will
read.
All
those
details
from
the
standard
out
standard
is
basically
nothing.
For
example,
this
thing
is
printed
here.
You
can
see
it
as
standard
out.
F
That's
a
very
bad
way
to
explain
this,
but
I
I
really
don't
know
how
to
explain
that.
So
so,
okay
waiting
for
plugin
address,
then
it
connects
to
that
and
yeah
this.
It
goes
the
create
method.
There's
here,
this
fmt
dot,
print
red
line,
data
node
three,
it
holds
the
read
method.
The
greet
method
just
returns
hello,
and
that's
it
after
that.
There
is
nothing
to
do
here.
It
will
just
stop
the
plugin
and
it
will
just
exit
this
program
and
one
more
thing
that
that
is.
F
So
if
we
try
to
run
the
plug-in
binary
on
itself,
that
is
not
passing
it
to
some
some
some
host.
Then
it
has
been
taken
care
of
so
what
it
will
do.
It
will
basically
print
out.
Okay,
this
binary
is
a
plug-in.
They
are
not
meant
to
be
executed
directly.
These
excuse
yeah
all
those
things,
so
how
this
thing
is
working.
F
So
when
we
are
initiating
our
client,
we
are
creating
an
instance
for
this
client.
We
are
passing
it
a
handshake.
So
what
does
this
hand
check?
Let's
go
to
our
language
language
file,
again
the
interfaces
so
in
this
handshake
we
defined
some
kind
of
magic
matching
cookie
value,
basic
plugin
and
hello,
and
these
have
this
thing.
So
plugin
is
expecting
to
get
this
magical,
picking
and
magic
cookie
value,
and
then
it
will
know.
Okay,
I
go
these
values
and
these
are
matching,
so
I
was
called
by
the
right
host.
Otherwise
it
will.
F
It
will
give
away
user
friendly
error,
and
that
is
if
some
some
other
host
tries
to
connect
with
it
that
yeah,
if
you
are
not
the
yeah,
if
some
other
host
try
to
connect
with
it
that
okay,
so
I
am
not
going
for
you
something
like
that.
I
I
then
try
to
run
that
and
if
there
is
no
basic,
plug-in
and
hello,
that
is
when
we
try
to
run
this
like
this,
don't
slash
plug-in,
then
it
will
just
okay.
F
D
The
foremost
reason
is
for
each
of
you.
It
was
for
me.
It
was
it's
for
each
of
you
if,
if
it's
not
interesting,
don't
bother
with
the
questions,
but
if
it's
remotely
interesting,
this
is
a
safe
place
like
this
is
as
safe
as
an
open
source
places.
You're
gonna
find
to
ask
what
you
think
are
you
know
silly
questions
and
understand
that
they're
not
I've
got
about
10
silly
questions
right
now,
and
so
I
guess
what
I'm
trying
to
say
is
like
please
jump
in.
D
D
D
You
know
works
a
little
bit
differently,
doesn't
necessarily
exchange
all
of
its
messages
over
grpc
the
like,
if
we
were
to
add
layer
in
if
a
plug-in
were
to
be
loaded
in
as
at
the
point
in
time
in
which
someone
signs
in
domestry,
they
choose
a
provider,
they
authenticate
that
provider
the
provider
would
dynamically
load
up
additional
capabilities,
it
does
so
did
today.
It
just
doesn't
do
it
in
as
dynamic
of
a
way
in
which
you
just
presented,
which
is
why
you're
presenting
because
we
need
we
need
a
better
solution.
F
No,
actually,
I
am
trying
to
understand
what
I
am
getting
confused
by
yeah.
So
the
thing
is:
okay,
okay,
so
we
want
to
add
our
front
end
more
pluggable,
right
right,
okay,
so
what
I
get
from
go
plugin
is
that
it
is
essentially
for
the
means
for
the
back
end,
and
so,
if
what
I'm
getting
is
we?
We
are
trying
to
say
that
we
will,
we
will
add,
react.
Complete
apps
react,
pluggable
apps
that
basically
can
that
can
use
these
pluggable
these
plugins,
and
then
you
can
display
something.
G
D
Oh
shh,
since
this
is
probably
the
last
top.
I
think
this
is
the
last
scheduled
topic
that
we
have
and
it's
kind
of
it's
kind
of
a
big
one.
It's
an
intriguing
one.
Let
me
make
sure
that
I
demo,
so
everyone
has
the
right
context
as
well
for
the
for
the
nice
presentation
you
gave
actually
so
hopefully,
everyone
is
kind
of
familiar
with
this
page.
D
If
you
don't,
if
your
user
doesn't
have
an
authenticated
session,
mastery
will
present
you
with
this
provider
interfaces
or
I'm
sorry.
With
this
provider
ui
to
authenticate,
you
can
click
to
learn
a
little
bit
about
providers
right
in
the
ui.
Here.
There's
really
two
functional
providers
today
with
two
other
providers
kind
of
in
the
works
they're
disabled
at
the
moment,
so
the
two
that
are
available
today
is
the
default
provider
called
meshri
and
there's
another
one
called
none.
D
So
most
people
go
with
the
default
and
when
they
do
they
get
a
little
bit
of
an
enhanced
experience.
Let
me
go
with
none,
which
is
to
say
that
essentially,
someone
is
going
to
use
meshri
and
use
the
baked
in
local
provider.
I
know
the
terms:
are
it
doesn't
really
matter?
If
you
get
the
terms
or
not
just
the
the
thing
you
need
to
understand
is
that
there's
two
types
of
providers-
there's
two
types
of
ways
of
logging
in
to
measuring
one-
is
a
local
provider.
D
The
the
term
that
we
use
for
it
in
the
ui
is
called
none.
So
if
I
choose
none,
mashri
will
just
sign
me
in
and
it'll
sign
me
in
really
is
like
mesherie
at
this
point
kind
of
turns
into
a
single
user
mode
tool
or
like
there's
sort
of
this
implicit
single
user.
That's
in
there,
but
it's
kind
of
not,
but
it's
just
an
anonymous
user.
It's
yeah,
and
so
you
can
use
the
tool
to
do
various
things.
D
This
user
doesn't
have
any
performance
test
results.
There's
no
like
history.
Here
they
can
go,
run
a
performance
test,
and
after
they
do,
I
guess
I
won't.
I
won't
do
it,
but
after
they
do
they'll
see
results
here
and
they
can
stop
their
contain.
Like
this
storage
for
retain,
like
persisting
and
retaining
these
storage,
these
test
results
is
done
locally
local
to
the
container,
which
also
means
that
you
know,
since
containers
are
ephemeral
and
you
might
delete
one
or
what
have
you
like.
D
But
so,
if
you
sign
in
with
with
mesri
it's
a
I'm
sorry
with
the
message,
remote
provider,
its
authentication
system
use,
gives
the
user
choice
of
like
those
four
different
social
authors,
four
different
social
logins.
In
this
case
I
chose
my
my
twitter
account,
so
I
logged
in,
and
I've
used,
my
twitter
account
with
to
log
into
meshree
a
lot,
and
so
when
I
go
to
results
I'll
end
up,
seeing
a
bunch
of
performance
test,
results
that
have
been
run
and
those
are
retrieved
from
the
location.
D
D
D
And
so
to
to
enhance
that
framework,
dev
and
others
are
looking
at
a
utility.
You
know
a
library
package
like
go
plugin
to
be
able
to
take
capabilities
from
a
remote
provider
and
plug
them
in
kind
of
at
the
time
that
people
authenticate
sort
of
download
those
additional
packages,
those
additional
capabilities
that
that
provider
might
have
and
sounded
like
from
dev's
presentation.
In
this
case
those
those
back-end
capabilities
might
be
spun
up
as
a
process
and
sitting
there
available
to
do
whatever.
D
The
thing
is
that
they
were
written
to
do
that,
the
interface
that
we
might
use
grpc
to
interface
between
mastery
server
and
those
provider,
plug-in
processes,
to
the
extent
that
a
provider
were
to
not
only
include
back
end
processes,
back-end
capabilities
to
maybe
bring
support
for
nighthawk
as
a
load
generator,
just
as
a
as
an
example
to
the
extent
that
they
wanted
to,
you
know,
do
some,
you
know
have
a
new
ui
like
have
another
page
available.
Maybe
the
page
is
something
like
the
provider.
D
Is
we
pro
a
consulting
agency
and
they'd
like
to
have
a
new
menu
item
that
says
you
know
about?
We
pro
or
service
meshes
at
wipro,
or
so
something
like
that
that
they
can
the
the
framework
that
we
have
in
mesh.
We
should
facilitate
for
that.
It
should,
when
a
plug-in,
when
a
provider
is
authenticated
to,
we
should
be.
We
should
have
extensibility
in
the
ui
to
let
people
do
certain
things.
Maybe
they
want
a
white
label
measuring,
maybe
I
don't
know.
D
And
so
the
dev
therein
kind
of
lie.
Part
of
my
example
is
if
we
allow
people
to
load
in
new
menu
items
when
they
click
on
that
menu
item,
it'd
be
really
nice.
If
that
wasn't
an
iframe
or
a
separate
external
link,
but
rather
that
capability
is
part
of
the
same
single
page.
App
like
it's
part
of
the
same
react
app.