►
From YouTube: WebAssembly Filters Meeting (Nov 08th, 2021)
Description
WebAssembly Filters Meeting - November 08th, 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
B
B
So
my
update
on
the
multiple
github
import
is
that
I
was
facing
an
issue
for,
let
me
know
the
issue
was
that
I
need
to
convert
all
the
files
in
the
mystery
service
mesh
pattern,
repo
into
a
single
url,
so
that
we
can
directly
upload
it
over
here.
So
recently,
just
now
before
the
call
me-
and
we
had
a
talk
about
how
to
solve
this
issue.
So
what
we
did
to
solve
this
issue
is,
we
are
passing
this
and
let
me
also
share
the
file.
B
So
we
are
passing
the
whole
file
as
a
single
set
of
array
so
that
it
gets
converted
with
the
single
url
and
we
have
used
the
approach
that
if
the
url
starts
with
this
thing,
data
https
github,
slash,
github,
slash,
getter.com
and
ends
with
dot
aml.
So
it.
B
What
it
will
do
is
that
it
will
take
whole
as
many
files
that
we
have
in
this
repo
and
pass
it
directly
to
the
url
so
that
we
can
once
we
apply
and
import
using
the
repo
so
that
we
can
get
all
the
service
mesh
patterns
over
here.
B
So
is
this
approach
fine,
so
we
can
proceed
with
this.
I
can
also
add
few
functions
to
get
this
yeah.
A
Actually,
this
is
this
is
sort
of.
I
think
we
are
duplicating
them,
because
this
exact,
I
won't
say
exact,
but
similar
logic
is
present
in
mystery
server
as
well,
so
you
can
just
give
it
the
url
and
it
will
actually
if
there
are
more
than
one
in
a
directory
or
if
you
ask
it
to
recurse.
In
that
case
it
will
import
all
of
them.
A
So
basically,
all
the
import
api
is
capable
of
importing
more
than
one
in
case
they
are
available
from
an
endpoint
so,
and
I
think,
right
now,
this
functionality
is
being
duplicated
here
as
well.
What
you're
doing
is
you
see
if
something
starts
with
github.com?
You
use
github
api
to
fetch
all
of
them
and
filter
out
all
of
the
files
which
are
which
end
with
dot
yamaha
dot
yml,
and
then
you
actually
append
that
into
the
single
file
and
probably
push
it,
but
all
of
this
is
actually
present
in
api
as
well.
B
A
Basically,
what
I'm
saying
is
that
you
don't
have
to
do
it
this
manually,
you
can
just
you
can
just
pass
in
the
url
to
the
endpoint
to
the
api,
and
it
will
take
care
of
making
sure
that
it
pulls
in
all
of
the
pattern
files
that
are
available
in
in
that
particular
repository,
and
it
does
an
additional
check
as
well
to
sort
of
verify
if
that
particular
gamut
is
a
potential
pattern
file
or
not
so
yeah.
A
B
A
Yeah
so
as
just
first
say
so,
our
github
input
is
not
much
different
than
the
url
import.
D
A
Yeah,
so
we
can,
you
know
just
just
use
one
I
think
yeah
actually
so,
just
to
add
the
there
is
a
slight
difference
between
a
github
import
and
a
url
report,
and
that
different
difference
is
that,
let's
say
you
want
to
import
something
from
service
mesh
service,
mesh,
hyphen
patterns,
and
I
mean
that
particular
repository
in
that
case.
You
can
also
specify
that,
from
what
branch
you
want
to
import
because
yeah
they
can
be
multiple
branch.
You
may
want
to
import
from
a
certain
branch.
A
The
default
one
is
so
if
you
don't
give
any
branch.
In
that
case,
we
import.
We
try
to
import
from
main
branch,
so
that
is
an
additional
field
which
can
which
would
be
present
in
a
github
import,
but
won't
be
present
in
normal
url
based
because
that
doesn't
confines
with
remote
thing.
So
yeah,
that's
the
only
thing
that
that
differentiates
github
import
from
you
know.
A
And
another
one
is
of
course,
a
path
that
is,
if
it's
a
github-based
or
any
the
goal
is
any
remote
get
repository,
but
right
now
only
for
github.
You
can
actually
provide
a
path
that
I
don't
want
to
you
to
get.
If
everything
in
the
depository
just
go
ahead
and
look
into
this
particular.
D
A
Also,
an
additional
thing
that
is
available
in
github-based
approach.
Okay,
just
one
one
minor
question
here:
so
is
there
like
three
text
field
required
for
getting
the
our
github
repository?
Then
directories,
then
branch
or
it
may
you
know
only
one
github.
A
You
know
one
github
url,
which
will
automatically
be
fetching
the
branch
as
well
as
the
daily
reason.
A
Yeah,
since
since
github
imports
are,
you
know
a
bit
different
from
url
imports,
so
github
imports
have
the
added
functionality
that
it
could
take
the
branch
name
as
well
as
the
directory's
name
right.
So
so
is
there
any
more
text
fields
required
in
the
ui
itself
to
know
get
those
branch,
values
and
directory
values
from
from
the
ui?
A
Is
it
required
or
no?
I
don't
think
so.
I
think
I
think
what
we
can
have
is
is
because
we
have
a
right
now
I
can
see
there
is
a
different
icon
for
github
in
this
different
model.
So
probably
what
we
can
do
is
we
can
just
take
in
the
organization
name,
repository
name.
So
two
takes
fields,
a
branch
name
if
they
want
to
an
option
one
or
the
default.
A
One
is
main
if
they
don't
give
one,
we
assume
and
a
path,
and
maybe
because
the
thing
is
right
now
it's
too
api
centric.
So
if
you
give
path
like
the
one
slash
door
to
star
star,
that
means
that
go
inside
directory,
one
then
directory
two
and
then
reverse
everything
inside
that.
Basically,
if
there
are,
hundreds
of
directories
go
inside
all
of
them
and
if
they
don't
give
slash
star
star,
then
that
basically
means
that
look
at
the
root
level.
A
A
I
think
you
can
have
just
a
text
box
if
the
option
and
if
they
give
master
we
use
master.
If
it
give
none,
we
use
me
they
can
give
x
y
z.
A
A
Yep,
so
let's
move
on
to
the
next
topic:
it's
from
cynthia
senten,
if
yeah
he's
on
call.
So
if
you
would
like
to
give
updates
regarding
github
action.
F
F
So
basically,
I
have
now
deployed
the
histo
and
you
can
see
that
my
pattern
is
getting
applied.
I
am
trying
to
upload
these
two
patterns.
One
was
the
hto
filter
pattern
and
another
one
is
a
book
info
pattern,
so
I
was
trying
to
see
now
right
now
there
are
two
now.
This
is
the
first
pattern
and
this
one
is
the
second
pattern
which
got
applied.
F
A
So
something
would
you
mind,
giving
some
context
to
those
who
are
not
aware
of
what
this
action
exactly
does.
F
So,
basically,
right
now
we
are
trying
to
create
previously.
I
think
there
were
two
actions.
One
was
the
smi
conformance
and
the
another
one
is
the
smps.
So
right
now
we
are
creating
another
github
action
by
which
we
will
be
applying
this
patterns.
So
you
will
find
some
sample
patterns
in
this
in
this
repository,
so
I
am
trying
to
deploy
this
pattern
into
machinery
through
my
github
actions.
F
So,
first
of
all,
I
have
like
just
a
minute
so.
F
So
this
is
the
repository
which
I
am
currently
working
on
so
right
now
there
are
four
thing
for
four
main
files,
so
basically,
this
main
dot
sh
file
is
actually
where
we
are
running
this.
The
other
two
scripts
like
one
is
the
machine
and
one
is
for
the
machery
ctl.
F
So
this
script
is
for
the
machery
before
we
are
actually
creating
our
cluster
over
here
and
like
if
it
is
first
checks
if
the
cluster
exists
or
not
after
that,
it
creates
its
own
cluster.
So
this
is
the
function
for
creating
the
class,
so
I
am
using
mini
cube
and
then
we
are
just
like
we
are
following
the
steps.
I
think
there
is
a
docs
in
docstar
message.io
there.
There
is
a
perfect
documentation
for
this
mini
cube,
like
configuring
mini
cube.
F
So
actually
we
are
using
mini
cube
in
this
github
action,
so
here.
So
this
is
the
measuring
script,
and
this
one
is
sorry.
This
one
is
for
the
measuring
ctl,
where
actually
we
are
applying
these
two
patterns.
So
these
four
steps
are
mentioned
in
the
mini
cube
docs
like
in
docs.measure.io
how
to
connect
the
mini
cube,
and
then
we
in
this
step
we
are
actually
applying
those
two
patterns.
I
have
shown
you
like
these
two
patterns,
the
raw
file
of
these
two
patterns
so
and
yeah.
This
is
the
thing.
A
So
I'm
not
sure
here,
but
do
we
want
to
hard
code
the
pattern
file
url
here
or
I
mean
basically
I'm
unaware
of.
F
No,
no,
no!
Actually,
we
don't
need
to
hardcode
this
thing.
Actually,
this
is
the
first
time
I
am
trying
to
use
this
github
action
and
I
don't
have
enough
knowledge
to
do
this
thing,
so
I'm
first
trying
this
with
the
hardware
like
hard
coding.
All
those
things
like
this
is
to
have
hardcoded
this,
but
in
my
previous
in
my
future
update
I
will
be
removing
all
these
things
and
user
will
be
like
giving
their
own
url
and
they
will
be
able
to
apply
their
pattern
from
there.
H
F
Yeah
yeah,
I
will.
I
will
change
this
docker
to
default,
one
like
the
q180s
one.
F
H
E
Oh
yeah,
so,
like
I
just
like,
if
you
are
looking
into
configurability
like
for
specific
adapters
or
something,
then
maybe
we
should
just
let
the
users
provide
a
custom
mesh
config
file
like
if
you
are
thinking
that
way,.
F
C
A
Let's
move
on
to
the
next
topic:
it's
cyclist
testing
of
favorismd
and
I
think
we
have
mariota.
So
why
did
you
have
do
you
have
like
you?
Don't
need
to
have
any
update,
but
do
you
have
some
some
updates
about
site
resisting
of
episode,
or
did
you
get
a
chance
to
have
a
look
at
it.
D
Hey
hi
yeah,
I
haven't
had
a
chance
to
take
a
look
yet
but
making
progress
in
a
couple
of
issues
I
have
assigned.
So
I'm
hoping
to
finish
the
second
issue
the
last
issue
soon,
so
I
can
focus
on
the
these
filters,
the
cypress
part
so
yeah,
maybe
is
there
some
resources?
I
could
take
a
look
to
get
more
familiar
with
the
feature.
A
Yeah
so
resources
regarding
the
web
assembly
filters
that
we
have.
D
That's
what
we
should
be
testing
with
cyprus
right
some
integration
and
end-to-end
tests.
With
that,
could
we
can
we
clarify
the
scope
of
what's
expected
actually.
G
Yeah,
so
so
the
there's
new
feat,
some
meshery's
management
of
webassembly
filters-
is
well
still
in
beta.
It's
a
new
feature,
set
new
feature
area,
and
if
anyone
has
measurey
running,
if
you
would
just
bring
up
the
web
assembly
the
the
filters
ui
so
so
this
whole,
so
it's
a
net
new
ui
that
doesn't
have
any
test
coverage,
any
functional
test
coverage.
G
Now
there
are-
and
so
so
the
scope
is
sort
of
with
respect
to
this
specific
ui
that
that's
about
we're
going
to
show
here
in
a
second
the
initial
functionality
that
we
allow
users
to
do
in
this
beta.
It's
it's
relatively
it's!
Well,
it's
a
beta,
yeah
yeah,
it's
basically
it's
like
crud,
it's
like
yeah!
They
can
update.
They
can
upload
a
new
entry
into
this
table
when
they,
when
they
create
a
new
entry
when
they
upload
a
new
entry
up
an
entry
being
a
web
assembly
filter
it.
G
Basically,
it's
just
it's
a
file,
a
single
file,
a
binary
that
I
don't
recall
if
we
have
like
input
field
validation
around
whether
or
not
it's
a
binary
or
a
piece
of
yaml
or
a
or
something
else,
but
but
there's,
but,
as
you
think,
about
testing
you
think
about
like
trying
to
break
the
functionality
or
what
have
you
like
good
good
things
to
verify
is
well,
it
should
well,
we
it's
a
good
question
for
us
to
put
into
the
meeting
minutes
like
someone
needs
to
define
if
we
only
allow
dot,
wasom
or
some
certain
type,
certain
file
type,
and
if
that
should
be
included
in
the
tests
or
not,
but
it's
actually
like,
if
you
take
away
any
of
the
funky
tech
that
we're
using
it's
like
extraordinarily
straightforward
thing,
it's
there's,
there's
a
there's
a
table
full
of
entries
that
let
you
create
new
entries
update
existing
entries.
G
So
the
update
is
if,
when
that
edit
button
is
clicked
for
a
given
existing
entry,
there
is
a
set
of
yaml
that
is
related
to
the
binary.
G
And
it's
on
this
point
that
actually
it
confuses
me
slightly,
and
that
is
this
is
a
question
for
the
others
that
are
on
the
call,
so
we're
allowing
users
to
upload
a
binary
and
that's,
what's
primarily
represented
by
the
filter
name
like
each
road.
It's
like
one
binary
one
web
assembly
filter
compiled
you
know
and
but
also
associated
with,
that
is
potential
configuration,
and
I
believe
that
that's
what
we
would
see
when
we
click
on
edit,
which
then
begs
the
question
okay.
So
when
someone
creates
a
new
entry,
are
they
uploading
both?
Oh
okay?
E
G
Which,
like
clarifies
the
question
in
so
much
as
mario
is
concerned
at
the
moment
like
over
time,
we
want
for
mario
to
be
writing
his
own
webassembly
filter
like
for
him
to
have
full.
You
know,
carnal
knowledge
of
the
system,
but
just
to
get
started
with
some
a
decent
functional
test.
Just
just
one.
Maybe.
G
One
yeah
right,
yeah,
that's
maybe
yeah,
you
know
another
basic
one
would
be
then
delete
that
filter
like
and
leaving
the
the
read
and
update
you
know
yeah,
leaving
that
to
the
side
because
it
looks
like
it
might
change
anyway.
Maybe.
G
Yeah,
mario
now
here's
the
good
news
well,
I
hope,
like
in
the
best
of
ways
level
one
so
abi
kumar
who's
on
the
call.
Abhishek
kumar
he's
interested
to
parlay
with
you
kind
of
track
along
as
you're
going
through
this,
which
would
be
good
as
we
you
you've
got
to
spread
that
knowledge
about
cyprus
and
how
we're
approaching
it
and
how
we're
measuring
ourselves
and
all
these
things.
D
G
D
G
Yeah,
and
can
I
force
him
to
do
a
pr
review?
You
know,
okay,
because
it's
how
it's
you
know
if
he's
having
to
review
it,
then
he's
having
to
understand
it
and
yeah
yeah.
Of
course,.
D
Yeah
yeah
sounds
great,
and
what
about
is
there
any
issue
to
track
this
work?
Should
I
create
it,
or
is
this
part
of
a
big
issue
like
feature
we're
working
on
like
I'm,
just
not
familiar
with
like.
G
G
Actually
it's
a
great
question
because
it
leads
us
into
like
a
bit
more
of
what's
the
test
strategy
itself
and
kind
of
how
does
how
do
test
cases
work
and
and
what
tooling
is
there
today
and
where?
Where
can
that
evolve?
Like
that's
all
the
other
piece
of
good
news
that
I'll
say
in
the
meantime
is
that
well
so,
emerging
functionality
is
in
measure
is
to
manage
web
assembly
filters,
and
so
we
just
kind
of
talked
about
the
extent
to
which
it
does.
It
is
really.
G
G
Fine
now
it
also
took
a
very,
very
similar
approach
to
two
other
features:
two
other
aspects
of
a
service
mesh
or
of
kubernetes
that
meshery
manages
and
they're
both
listed
adjacent
in
the
so
so
one
of
those
is
called
patterns
and
the
other
one
is
called
applications
and,
in
essence,
the
the
functionality
that's
provided
by
meshri
again
is
like
at
its
basic
form,
it's
crud
operations
on
an
application
and
what
is
an
application?
G
It's
a
yaml
file,
a
single
yaml
file;
okay,
fine,
that's
even
easier
to
kind
of
deal
with,
especially
about
like
an
edit
type
test
and
then
a
pattern.
What
is
a
pattern?
It's
a
yaml
file
again,
so
actually
we'll
find
that
we
probably
end
up
with
you
know
a
few
tests
that
look
pretty
similar
to
one
another
part
of
the
tests.
I
would
well.
I
would
expect
like
so
so
part
of
what
mario
needs
to
be
successful
in
verifying
that
something
like
an
upload
like
a
create
works
is
having
well.
G
I
don't
know
how
you
want
to
refer
to
it,
but
but
like,
but
having
a
functional
pattern
having
a
functional
web
assembly
having
accurate
content
like
three
three
that
are
known
good
now,
mario
in
cyprus,
testing
is,
is
it
common?
G
Is
it
common
for
people
to
put
in,
like
in
unit
tests,
you'll
intentionally
try
to
break
the
thing
you'll
give
it
bad
content,
bad
values.
D
G
D
If
it's
consistent,
you
know,
if
there's
expected
conditions
we're
trying
to
ensure
I
I
would
say
yes,
if
there's
a
specific
error
message,
for
example,
we
of
course
yeah.
If
this
is
part
of
the
acceptance
criteria
yeah.
Basically,
we
would
introduce
invalid
input
in
in
many
different
ways
right.
It
really
depends
to
the
feature
so,
for
example,
so
the
scope
is
these
three
pages.
Is
it
patterns,
filters
and
applications
or
just
patterns
for
now
trying
to
define.
G
That
the
scope
is
for
all
three
we
can
be
successful,
just
starting
with
one
and
just
starting
with
a
single
operation
like
that,
it's
okay
to
be
iterative
in
that
regard,.
D
Yeah
yeah,
I
would
think
that
the
and
an
objective
would
be
to
to
work
on
one
of
those
like
cypress
tests
for
one
of
those
and
then
try
to
make
reusable
test
code
or
utilities
to
work
on
the
others,
so
that
you
know
any
changes
would
be
managed
at
an
abstraction
layer
on
the
test
code,
so
yeah
and
the
upload.
If
the
upload
is
the
the
main
scenario,
it
is
right
like
upload
a
file.
G
Yeah
in
the
future,
I
think,
for
now
probably
it
is
upload
and
it
is
yes
in
the
future.
D
Yeah,
so
so
the
upload
on
cypress,
it's
very
specific
like
how
to
script
an
upload
on
a
web
application
for
cyprus.
It
really
depends
on
on
the
implementation
of
the
upload.
So
I
I'll
take
a
look
to
see
if,
if
there's
another,
let's
say,
there's
another
cypress
test
that
already
manages
that
I'll
try
to
reuse
that
and
if
not
I'll,
have
to
work
on.
On
the
specifics.
C
G
There's
so
it
would
arguably
it
would
work
equally
as
well
if
a
remote
url
is
used
as
the
upload
content
as
versus
like
local
file
system,
because
it's
yeah
sure
like
like
the
while
there
is
a
difference
between
the
two,
the
one
that's
yeah.
I
don't
know
anyway,
if
it's
easier
to
start
with
the
remote
url.
That's
that's
just
as
well.
D
Okay,
so
that's
functional
right:
it
works
right
now,
all
right
cool.
G
And
that's
kind
of
the
ui
that
they're
showing
like
import
using
url
is
the
and
so
the
there's
another
aspect
to
this
that
I
was
just
forgetting
so
yeah,
so
the
upload
and
delete
yep.
Those
are
the
two
in
the
future,
the
most
important
one
or
the
one,
the
test
that
will
flex
most
of
the
code
or
or
even
more
of
the
code
and
and
it
will
be
more
brittle
because
it's
more
complex
is
when
you
go
to
apply
any
of
either
the
application,
the
filter
or
the
pattern
that
that
play
is
right.
G
G
G
D
D
A
A
You're
good,
okay,
yeah
so
might
be.
The
play
button
is
actually
function.
The
error
that
so
you
can
get
some
errors
when
you
apply
it,
but
that's
not
because
it's
not
functions
because
the
pattern
was
either
invalid.
It
didn't
have
a
component
running
on
your
system,
so
python
expects
a
few
adapters
to
be
running
or
depending
upon
what
what
is
in
the
pattern
in
terms
of
the
content
so
yeah.
Basically,
the
play
button
is
working.
Sometimes
it
may
feel.
D
It's
fine,
oh!
I
guess
the
question:
does
the
play
button
trigger
a
request
to
the
server
side?
Yep,
it
is
cool
cool,
that's
good!.
D
Yeah
and
so
yeah
for
for
an
integration
test,
I'm
thinking
that
maybe
like
there
could
be
some
fixtures
to
to
pass
to
the
to
the
front
end.
So
then
this
could
be
populated.
You
know
and
then,
once
that
button
is
clicked,
if
there
is
a
request
being
sent,
you
know
we
could
assert
on
on
the
like,
intercept
the
request
and
then
assert
on
on
specifics
like
like
what
how
should
the
request
look
to
so
we
can
say
it's
working
properly
right.
D
So
that's
that's
part
of
like
cyprus,
integration
tests,
at
least
the
ones
I
I'm
familiar
with
right.
D
G
G
It's
a
great
foreshadowing
actually,
so
whomever
is
sharing
if
you
were
to
apply
a
pattern
again,
the
one
that
was
successful,
there's
a
small
snack
bar
or
a
small
toaster
notification,
whatever
you
want
to
call
a
small
ephemeral
notification
down
there.
That,
like
is
just
as
a
question
for
you,
mario,
like
as
in
as
a
general
approach
as
your.
G
Is
it
a
fragile
approach
to
be
looking
for
that
response
and
trying
to
match
against,
like
a
word
like
successfully
versus
a
word
like
failed?
Is
that
too
fragile?
Considering
that
those
messages
might
change,
or
is
that
do
you
generally
try
to
do
so
on
error
code.
D
Well,
the
base
most
basic
is
to
to
check
for
the
status
code
so
200
or
something
right
and
then
going
after
that.
If
it's
something
that
would
change,
of
course,
I
don't
think
it's
fragile.
It's
just
that!
D
Well
as
soon
as
it
changes,
we
would
have
to
to
modify
it
right,
it's
trying
so
that
as
long
as
that's
not
like
a
hassle
and
it's
something
that
we
all
forget
and
then
you
know
the
idea
is
to
so
that
the
tests
help
during
the
development
right.
So
if
something
breaks
it
should
tell
us,
but
of
course
we
wouldn't
want
that
to
like
be
so
sensitive
that
it
fails
like
on
every
change
so
so
yeah
we
could.
We
could
consider.
D
D
C
D
Sorry,
so
so
uh-huh,
so
the
problem
with
that
is
that
where
we
don't
have
control
over
what
we're
mocking
or
passing
back
to
the
browser
for
the
test,
we're,
we
need
to
be
very
aware
that
you
know
it's
hard
to
track
like
what
an
actual
backend
response
would
look
like
and
they
could
differ.
But
as
long
as
there's
like
knowledge,
like
there's
awareness
of
making
sure
that's
yeah
a
valid
backend
response
and
we're
okay,
you
know-
and
and
especially
if
it's
a
simple
response
right
it.
D
I
don't
visually,
it's
not
there.
It's
not
that
complex,
but
but
yeah,
that's
like
having
guarantee
on
the
integration
level
right.
If
something
is
not
right
in
the
front
end
code,
we
would
notice
like
faster,
and
these
tests
are
more
a
bit
more
resilient.
So
the
approach
is
to
combine
both
integration
tests
and
then
some
more
end-to-end
ish
tests,
but
yeah,
I'm
sorry
what
you're
saying
you
wanted
to
add
something
else:
yeah.
G
No,
no
that's
right,
yeah
make
using
regex
makes
it
less
fragile.
You
know
incorporating
http
status
codes,
potentially
along
with
regex,
can
be
helpful
depending
upon
how
well-written
the
server-side
responses
are.
Sometimes
people
you
know,
will
embed
an
error,
an
error
message
in
at
200,
and
so
you
know
in
a
in
a
conflicting
status
code,
and
so
as
we
get
into
this,
we'll
see
how
well
written.
D
Be
a
driver
for
improvement
upon
specifics,
right
of
the
yeah,
the
api
right
or
or
we
could
just
manage
like
specifics,
where
there's
a
failure,
but
we
don't
want
it
to
be
like
like
a
bad
failure
right.
Maybe
it
could
be
expected
on
some
conditions
and
then
that's
why
we
wouldn't
get
like
a
500
or
400
would
be
like
a.
I
don't
know.
Maybe
I
don't
know
if
it's
a
200
but
yeah,
I
I
get
you
like.
There's
some
gray
areas
right.
G
Yeah
yeah,
so
there
is
so
to
help
make
sure
that
you're
have
all
the
resources
that
you
need,
or
the
right
there
is.
G
So
navindu
is
a
good
individual
to
see
on
questions
surrounding
what
we're
about
to
talk
about,
which
is
a
little
bit
about
process
and
what
other
tests
are
going
on
and
and
just
and
so
one
of
those
things
is
that
there's
an
issue
out
here
that
well
gosh,
I
guess
kush
had
created-
that's
been
out
there
for
a
while,
but
it's
just
sort
of
highlighting
the
fact
that,
like
hey,
there's
a
bunch
of
things
to
test
and
that
this
was
in
context
of
cyprus
and
writing
tests
for
these
areas.
G
I
don't
know
that
this
yet
has
a
checkbox
for
the
new
web
assembly
filters,
the
applications
and
the
patterns.
So
so
we
can
definitely
either
edit
this
and
add
those
or
make
new
issues.
G
But,
but
is
that
there's
also
a
so
some
some
fixtures
that
you
might
need,
or
some
some
things
that
you
might
need
or
like
hey
known,
working
examples
of
a
pattern,
an
application
and
a
filter?
And
so
so
that's
support
that.
You
probably
need
from
the
community
from
navendu
from
folks
on
the
call,
and
then
the
other
thing
is
at
some
point.
Well,
there's
a!
G
I
think
we
have
the
cypress
free
tier
account
and
I
think,
if
memory
serves,
we
can
have
like
up
to
five
users
on
that
free
tier
account,
and
so,
as
you
get
hip
deep
into
this,
we
should
probably
make
sure
that
you're
able
to
the
extent
that
it's
helpful
to
you
like
that,
you're
able
to
that
your
user
is
added
to
that
team
or
that
you
can
get
in
there
and
do
what
you
need
to
do.
G
The
another
thing
is:
oh,
the.
So
we
every
two
weeks
we
have
the
build
and
release
meeting
and
in
there
we
end
up
talking
a
bit
about
mostly
is
recently
it's
been
about
test
cases
less
about
test
strategy.
The
there's
a
spreadsheet
out
there
that
we're
using.
I
don't
know.
G
G
Each
row
represents
a
test
case.
Ultimately,
ideally
like
the
end,
the
e
to
e
tests
will
like
cover
a
broad
swath
of
a
number
of
these.
What
are
what
are
otherwise
like
manually
executed
integration
tests,
so
so
some
of
this
next
topic
is
like
good
for
the
build
and
release
meeting.
That's
that
we
have,
but
I
thought
I
would
try
to
answer
a
couple
of
those
questions
that
you
have
so
navendu
oops.
If
you
don't
mind,
knowing
that
abi
and
mario
will
need
known
working
content,
we
should
either.
E
Yep
sure
I'll
add
that.
A
Yep,
so
let's
move
on
to
the
next
item
and
it's
from
abhishek
review
on
review,
updated
pattern
configurator
now
in
filter.
U
I
think
it
has
already
been
added
to
the
patterns
ui
that
we
have
so
obviously
yeah.
So
the
new
configurator
ui
is
like
active
in
the
patterns,
so
yeah.
C
A
Yeah,
so
it's
expected
just
like
very
similar
in
the
filters.
Also
right,
so
we
are
seeing
this
ui
in
the
patterns
we
are
having
the
authority
to.
You,
know
change
any
of
these
things
like
crds
and
then
modify
it
right.
So
is
it
is
it
if,
if
you
are,
if
you
are
thinking
from
the
table
of
filters,
so
are
we
just
gonna,
be
changing
the
filter
aspects
of
any
adapter?
G
Like
yeah
yeah,
I
think
that
yeah,
it's
a
really
good
question.
It's
it's
unclear
and
I
think,
for
a
number
of
us,
it's
kind
of
been
unclear
for
a
while
and
and
in
part,
because,
like
it's
kind
of
hard
to
pre-plan,
all
of
what
the
ux
might
be
until
we
kind
of
get
there
and
actually
for
me
in
some
respects
now
that
we've
arrived
at
a
beta
for
applications,
filters
and
patterns,
we
might
be
able
to
simplify
what
has
been
an
open
challenge
for
us
around
filters.
G
In
the
conversation
we
were
just
having
with
mario,
it
was
like
hey
what
what
entries
all
go
into
this
table
and
we
come
to
understand.
It
is
just
a
binary.
It's
a
single
file,
one
per
row,
a
binary
file,
and
most
of
us
are
aware
that,
like
when
you
want
to
go,
apply
a
filter
to
your
infrastructure.
G
Not
the
contents
of
the
binary,
because
that
isn't
helpful.
We
could
show
them
the
configuration
snippet
just
for
how
they
would
apply
that
filter
to
their
infrastructure.
G
The
the
the
issue
with
doing
that
is
like
well,
then
each
road
does
no
longer
represents
a
single
binary.
It
represents
a
binary
and
associated
configuration,
so
it
represents
two
things
and
that
can
be
fine,
but
but
we
just
we've
been
kind
of.
What
do
you
say?
We've
been
indecisive
on
that.
G
The
other
approach
is
continue
to
leave
the
filters
ui
as
being
only
four
binaries,
one
binary
per
page
and
maybe
even
remove
the
edit
button,
maybe
because
we're
not
really
looking
for
them
to
edit
the
binary
and
instead
when
they,
when
it's
time
for
them
to
go,
apply
it
to
their
infrastructure.
G
They
need
to
navigate
to
a
different
user
interface,
potentially
like
a
patterns
interface,
where
they
would
say
like.
Okay,
I
want
to
make
a
super
small
pattern.
This
pattern
is
only
going
to
describe
the
configuration
for
this.
You
know
for
a
given
filter,
and
so
there
will
be
there's
clean
separation
between
the
binary
and
the
configuration
and
the
configuration
is
done
through
a
pattern.
G
That's
that's
another
approach
I
for
me.
I
think
the
challenge
of
that
approach
isn't
is
less
technical.
It's
more
psychological
in
terms
of
like
conflating
like
what
the
heck
does.
The
word
pattern
mean
then
like,
if
I,
as
a
user,
go,
create
a
pattern
that
I've
just
kind
of
made
it
up
and
I'm
applying
it
to
one
of
my
envoy
filters.
G
G
Like
okay,
people
can
still
do
that.
People
will
still
apply
configuration
to
their
webassembly
filters
using
a
pattern.
They'll
still
do
that,
so
that
the
pattern's
ui
is
looking
good.
You
know
it's
coming
along,
like
that's
that's
good,
but
separately.
Let's
say
that
someone
isn't
trying
to
use
a
pattern
to
apply
their
filter.
They
just
they're
running
as
an
example,
and
so,
if
you
navigate
to
lifecycle
and
to
if
you
have
an
adapter
running
to
one
of
one
of
the
that
it
would
be
from
potentially
from
within
that
life
cycle
inter
user
interface.
G
Here,
where
someone
where
we
would
change
this
like
like,
where
some
it
would
say,
oh
apply
a
filter,
they
would.
There
would
be
a
pick
list
of
filters
because
they
have
you
know
10
in
their
tables
or
whatever
they'd
pick
from
one
of
the
existing
filters
that
they've
uploaded,
and
it
would
be
in
this
moment
where,
where
we
would
ask
them
to
confirm
any
specific
configuration
that
they
would
like
to
pass
along.
G
G
On
the
back
end,
I
think
it
still
begs
the
question
of
like
when
you're
dealing
with
a
filter
when
measuring
is
managing
a
filter.
Does
it
not
also
have
a
secondary
artifact
the
configuration
artifact
adjacent
to
it?
Does
it
like
not
also
want
to
track
that
same
thing,
and
I
don't,
I
think,
that's
a
question
for
a
few
folks
to
think
on
and
make
some
assertions
on
like
states
and
beliefs
so
karst.
G
It
would
be
a
good
thing,
probably
for
us
to
put
into
the
meeting
minutes
to
say,
like
you
know,
do
before
next
time
we
meet
is
perspective.
You
know
a.
What
do
you
call
it
a
proposal
for
an
ultimate
proposal
for
what
that
is.
G
G
What
user
experience
we
want
to
try
to
be
consistent
with
these
user
experiences
if
we
can,
if
to
the
extent
that
it
makes
sense?
So,
if
someone's
interacting
with
an
application
again,
it's
a
one
file
per
row
in
the
table.
It's
a
yaml
file.
G
Now
they
can
edit
it
in
the
web
browser,
because
that
makes
sense,
because
it's
text,
okay,
fine,
they
can
potentially
click
to
apply
it
from
right.
There
like
we
might
let
people
continue
to
click
to
apply
their
webassembly
filter
from
the
webassembly
table,
but
we
would
ask
them
subsequent
questions
like
what
mesh
did
you
want
to
apply
this
to
and
what
configuration
did
you
want
to
supply
with
it.
A
So
yeah,
okay,
so
one
more
question
is
so
whatever
hair
is
like
these
test
filters
are,
are
not
valid
vessel
filters
right
because
they
should
be
binaries
and
they
can't
be.
You
know
edited
right.
G
I
mean
like
yeah.
This
is
where
people
have
gotten
confused.
I
think,
like
a
bunch
of
people
got
confused
on
right,
the
the
for
now
it
should
only
be
binaries.
A
Yeah
because
I
don't
have
a
cluster
okay,
but
yeah
yeah.
Actually
so
one
of
the
things
that
we
went
through
once
earlier
was
that
filter
from
user
side
of
a
point
of
view
would
be
a
pattern,
a
pattern
which
is
very
specific
to
a
filter
and
they
can
upload
assets
and
by
assets
I
mean
wasn't
binary
and
and
the
endpoint
was
supposed
to
work
in
the
way
that
when
you
approach
you
get
the
endpoint
and
that
is
automatically
substituted
in
the
in
the
in
the
pattern.
A
So,
basically,
when
you,
when
you
would
be
when
you'd
be
clicking
on
edit
you'd,
be
actually
having
a
yaml,
which
is
the
pattern
which
is
the
pattern
file,
but
is
it
that
you
have
that
it
points
to
was
the
one
which
you
actually
uploaded
and
the
api
returned
that
this
is
the
endpoint
where
you
can
actually
reach
out
for
so
that
is
one
of
the
things
that
we
went
through
once
earlier.
A
So,
let's
move
on
to
the
okay,
yeah,
good,
okay,
so,
basically
just
last
or
just
very
last
thing
just
to
differentiate
between
the
three
configuration
items
like
filters,
application
patterns,
so
pattern
should
should
we
should
be
able
to
configure
anything
with
the
patterns.
An
application
should
only
be
able
to
like
we
should
be
only
viewing
those
things
or
those
custom
resources
which
are
specific
to
the
application
configuration
and
in
filters
yeah.
The
same
holds
for
this
tool
right
so
just
become
specific
to
the
things
mentioned
here.
Right.
A
Just
asking
for
a
thin
level
difference
between
these
three.
A
D
G
I'm
going
to
let
lukas
take
a
crack,
yeah
yeah,
it's
a
great
question.
We've
I
mean
it's
a
great
question
and
we
need
to
make
it
much
more
intuitively
clear.
Hopefully,
right
now
we
can.
A
Yeah,
so
actually,
right
now
as
like
it
is,
it
is
the
fact
that
all
of
them
are
yaml.
So
that's
not
what
differentiates
filters
and
patterns
in
applications,
and
it
is
also
true
that
filters
and
applications
use
a
yaml
which
looks
like
a
patent
file,
which
is
a
pattern
file,
do
does
its
thing,
but
the
difference
from
user
point
of
view
is
that
when
you
write
an
application,
when
you
write
an
application,
it's
an
application,
not
an
application
pattern
file.
A
So
when
you
write
an
application,
what
you
are
actually
referring
to
referring
to
is
a
application
is
a
workload.
So
let's
say
you
have
a
application
book
info
because
that's
a
popular
sample
application.
Let's
say
you
have
an
application
book
info,
so
there
are
two
things.
The
first
thing
is
that
mystery
measure
has
a
construct,
a
reserved
construct
for
provisioning
applications,
which
does
a
lot
of
things
automatically
for
you.
So
that
is
something
that
applications
is
all
about.
A
That
is,
you
can
directly
use
that
construct
to
provision
a
workload
for
you,
and
it
is
not
a
pattern
in
the
sense
that
you
are
not
defining
best
practices
in
there.
Definitely
you
can
actually
define
some
best
practice,
because
we
do
enforce
a
few
things
from
our
side,
but
that
is
not
what
application
construct
is
for.
It
is
for
you,
the
user,
to
provision
an
application
of
workload
into
your
environment,
so
this
this
is
a.
This
is
a
right
now
as
a
visually
sharing.
A
This
is
the
pattern
file
and
it
is
trying
to
provision
an
application
for
you,
which
is
actually
provisioning
collection
of
items.
For
you,
this
is
a
pattern
of
file.
The
same
pattern
file
would
be
available
in
application
also,
so
the
difference
is
actually
that,
for
from
the
user
point
of
view,
you'd
be
able
to
you'd
be
able
to
see
application
as
a
different
construct
and
not
as
a
pattern,
which
is
a
very
generic
thing.
A
You,
you
can't
do
almost
anything
in
your
cluster
using
patterns,
you
can
enforce
best
practices
using
patterns,
so
actually
that
is,
it
is
not
a
implementation
difference,
because
both
of
them
are
exactly
same
from
implementation,
point
of
view,
application
and
patterns,
but
it's
to
move
from
the
user
experience
point
of
view,
that
is,
applications
are
supposed
to
deliver
only
applications.
That
is
when
you're
you
you're
using
applications.
A
You
are
actually
talking
only
about
applications
and
not
configuring,
your
let's
say,
let's
say
you're,
not
configuring,
your
namespaces,
that's
one
thing
so
yeah,
that's
the
difference.
The
filters
filters
are
actually
a
lot
different
from
application
and
patterns
alone,
because
filters
is
a
collect
like
it's
a
more
than
patterns
in
sense
that
it
has
assets
as
well,
that
is,
it
will
involve
one
or
more
than
one
web
assembly
filters,
which
you
can
obviously
refer
to
in
your
patent
file,
so
filters
in
this
configuration
section.
A
It
refers
to
two
items:
versum
binary
collection
as
well,
plus
our
patent
file,
which
can
provision
those
those
things
for
you.
That
is
actually
the
high
level.
Basically,
that
is
what
differentiates
these
three
it's
more
of
intuition
than
it's.
The.
A
D
Wow
so
then
an
application
is
just
like
some
workload
with,
let's
say
the
default
configuration,
so
this
allows
the
user
to
just
do
like
something
quick
and
then
when,
when
he
uses
a
pattern
that
that'll
help
him
defer
differentiate
when
this
is
something
that
is
like
a
best
known
pattern
or
best
known
configuration
of
specific
workload,
that's
right
right.
D
G
Yeah
yeah
that
that
any
so
we
we
definitely
need
an
object
model
to
help
people
to
just
relationally
understand
how
these
things
interact
with
each
other.
To
put
it
concisely,
I
would
say
that
if
you
have
an
application,
it
might
have
a
web
assembly
filter
like
you
might
deploy
your
application
like
a
like
a
wordpress
instance
that
in
the
application
it's
described
that
there's
apache
mysql
and
whatever
else
goes
in
there,
and
you
know
it's
a
kubernetes
manifest.
G
You
know
more
or
less
for
an
app
that
you
just
want
to
apply
to
kubernetes
is
in
a
lot
of,
like
that's
a
good
analogy
to
have,
and
then,
but
if
you
wanted
to
rate
limit
lee
from
the
user,
lead
that
signed
in
from
commenting
so
so
quickly,
you
might
apply
a
filter
to
that
application
that
prevents
the
user
named
lee
from
doing
certain
number
of
comments
per
minute
or
whatever,
and
so
the
pattern
is
a
higher
level
construct.
It
might
be
that
it
is
what
it
is
intended
for.
G
What
you
had
said,
mario,
which
is
like
applying
best
practice,
behavior
like
applying
a
template
to
your
applications
generally
like
part
of
the
concept,
is
that
a
pattern
can
cut
across
applications.
You
might
describe
one
or
more
applications
inside
of
a
pattern.
A
pattern
is
a
much
larger.
Is
an
umbrella
is
a
larger.
G
So
this
pattern
has
five
applications,
and
then
I
want
to
put
like
this
many
filters
on
these
apps
all
described
inside
the
pattern,
and
it
starts
to
get
conflated
like
th,
where
the
line
gets
drawn
between
like
a
pattern,
is
this
overarching
thing
you
can
describe
all
of
that
infrastructure
with
inside
of
okay
granted?
You
can
do
that,
but
how
we
were
intending
for
people
to
use
it
was
more
like.
G
Is
there
a
best
practice
of
limiting
every
user
to
two
comments
per
minute
like
good,
then,
let's
codify
that
capture
it
in
a
pattern
and
then
and
then
have
the
you
know
this
list
of
like
these
best
practices,
kind
of
available
to
people
and
and
and
we're
we
like,
are
abuse
we're
making
it
hard
for
people
to
understand
what
a
pattern
is
supposed
to
do,
because
we
keep
using
it
to
do
other
stuff
like
capture
all
to
not
just
capture
best
practice,
and
so
we've
gotta.
G
D
Yeah
like
restrict
how
it's
used
so
to
avoid
confusions
right,
I'm
thinking.
I
agree
with
that
and,
for
example,
if,
if
a
user
uploads
an
application
with
that
application,
like
is
there
is
there
let's
say:
is
there
a
relationship
or
or
could
could
they
use
like
they
could
go
to
the
patterns
ui
and
do
something
with
that
application,
like?
Is
that
the
intent
yeah
yeah.
G
C
G
Yeah
yep,
exactly
which
isn't
it
just
makes
it
dif
it's
like.
Well,
maybe
you
should
just
have
patterns
if
you're
not
going
to
limit
if
you're
not
going
to
curate
the
user
experience
it's
like.
Why
don't
we
just
have
patterns
because
they
can
do
everything
right.
So
it
was
just
this
issue's
pattern
saying
oh
okay.
Well
then,
but
then
it's
like
too
much
to
digest
and
understand
like
what
and
so.
G
G
G
G
And
then
we
might
yeah
for
good
future
agenda.
Maybe
it
might
be
that
mario
and
bobby
have
it's
not
dates
but
yeah.
Let's
work
on
the
agenda
after
the
call,
I
suppose,
if
anyone
knows
what
the
future
agenda
is
already,
you
know
please
drop
it
in,
but
other
than
that,
I
suppose
that's
a
wrap,
yep.
A
Yeah
so
let's
meet
on
the
next
fall,
that
is
on
wednesday.
It's
a.