►
From YouTube: DASH Workgroup Community Meeting 20220406
Description
April 6, 2022 Community Call
A
Can
we
have
a
meeting
on
where
you
demonstrate
that,
because
actually
that's
what
we
were
waiting
for
to
start
generating
test
cases,
because
what
you're
saying
is
that,
even
if
your
model
is
not
perfect,
that's
fine.
If
we
can
compile
it
and
run
against
it,
we
can
now
start
to
generate
test
cases
and-
and
quite
frankly,
that's
the
goal
of
this
group.
So
are
you
saying
it's
at
that
state
where
we
could
start
generating
test
cases
and
using
the
api
and
running
that
against
this
model?.
B
A
B
C
A
D
Sorry
drag
us
down
in
the
details,
sometimes
question:
maybe
you've
already
discussed
this
before
and
if
so,
I'm
happy
to
look
at
it,
but
for
ipv6
support
that
raises
the
questions
of
ipv6
fragment
support,
yes
or
no,
or
and
in
general
ipv6
extension
header
support
in
the
data
plane,
and
we
don't
have
to
answer
it
here.
I
can
raise
a
issue
with
a
question
if
that's
appropriate.
E
Yeah,
christina,
let's
add,
maybe
the
issue
about
the
ip
options
extension
headers,
so
we
can
close
on
this.
I
can.
I
can
tell
you
guys
that
from
our
side
right
now,
we
don't
support
ibv6
extension,
headers
ip
options.
Extension
headers
at
all.
However,
right
now,
as
this
milestone
approaches
for
some
of
the
standards
we
are
actually
thinking
about
starting
using
them,
but
because
of
hardware
optimization,
there
will
be
most
likely
static
in
size,
not
dynamic,
so
we
most
likely
will
have
ability
to
configure.
F
E
Have
some
some
basic
support
potential?
You
should
have
I'm
going
to
show
you
how
hard
it
will
be
in
the
in
the
hardware
model
to
implement
full
support
for
ip
options-
header
that
will
be
the
best.
If
not,
we
can
fall
back
on
what
we
are
doing
in
fpgas,
on
only
allowing
to
support
like
static
size,
ip
option,
headers.
C
E
A
C
G
G
C
G
A
C
H
C
I
I
C
C
G
G
F
C
Yeah
I'll
put
scoping
here,
some
will
be
able
to
choose
it:
okay,
great
and
I'll
fix
it
up
with
a
cool
icon.
Later,
okay
and
then
kind
of
staying
on
the
same
topic
a
little
bit
different
is
you
know
I
created
this
project
here,
just
for
my
own
tracking
and
with
the
testing
tracking
when
we
get
there,
but
the
the
kind
of
the
things
we've
been
talking
about
wanting
to
track
as
we
move
forward.
C
G
A
C
G
G
C
A
Yeah,
just
in
case
you
didn't
get
it,
we
did
issue
the
rfi,
it
is
verified
by
the
way
it
will
be
followed
by
an
rfq,
but
right
now
we
want
the
opinion
of
the
community
before
we
make
our
final
decisions
on
what
the
actual
call
it,
the
orient
smart
switch
will
actually
look
like.
We
have
our
idea,
but
we
want
your
input
and
we
will
be
looking
at
all
the
ideas
before
we
issue
an
rfq
and
we'll
modify
a
different
program.
G
That
would
probably
give
us
some
some
answer
to
some
questions
that
we
had
earlier
and
I
guess
we
were
told
you
know
they
will
show
in
in
the
form
of
some
documents
that
microsoft
is
working
on
and
it
has
been.
You
know
several
weeks
since
we
discussed
that
and
one
of
them
was
to
do
with.
Basically,
you
know
talking
about
this
metering
encounters
and
stats
and
so
forth.
Okay,
there
was
one
dot.
G
Another
one
was
about
talking
about
this
sdn.
You
know
team
which
was
working
on
this.
You
know
northbound
interface,
so
I
just
wanted
to
find
out
if
there
has
been
any
discussion
on
when
that
will
be
available,
or
has
it
already
been
available
that
I
missed
you
know
so
just
just
wanted
to
find
out.
What's
going
on
there
michael's
on
this
call.
E
E
In
two
weeks
from
the
metering
dock,
when
it
gets
to
where
it
goes
to
dash
apis
no
no
bar
facing,
we
have
already
some
schema
that
you're
working
on
there's
json
file
that
you
guys
are
interested.
I
can
briefly
talk
right
now
and
right
now
from
sony
team
prince,
I
believe,
is
converting
those
to
actual
tables
on
the
sonic
side
and
he'll
be
also
creating
the
young
file.
E
G
Yeah,
no,
no
thanks,
michael,
really
appreciate
it.
I
think
one
of
the
things
on
the
dash
api
is,
I
guess
there
was
a
discussion
about
getting
some
sort
of
a
reference
implementation.
Also.
What
was
is
that
in
the
works-
or
you
know,
when
do
you
think
that
we
might
be
able
to
get
our
hands
on
to
that.
G
E
Yes,
so
so
there
will
be
so
the
reference
implementation
from
the
point
of
view
of
the
control
plane,
what
the
control
plane
will
be
doing.
There
will
be
most
likely
kind
of
like
test
case
base
because,
like
at
the
end,
there's
there's,
for
example
young
that
sets
up
some
stuff.
So
basically
is
the
language.
That's
basically
used
to
interact
with
this
right
and
territory
from
the
yank
could
be
as
per
the
json.
E
So
what
we
are
thinking
of
is
actually
the
reference
implementation
from
the
point
of
view
of
different
examples,
of
how
defense
scenarios
will
be
set
up
in
this,
and
I
can
quickly
potentially
could
showcase
you
kind
of
what
is
right
now
in
progress
and
and
the
question,
have
you
guys
look
at
the
routing
behavior?
That
is
right
now
shared
as
the
as
the
draft
or
not
yet
like
this
routing
the
behavior
document.
E
E
So
you
guys
know,
for
example,
what
is
coming.
We
are
working
on
so
one
important
part
from
the
routing
perspective
right
so
routing
for
the
album
we
kind
of
know
what
we
want
to
do.
We
are
still
discussing
how
exactly
you
want
to
fully
handle
inbound
writing
from
the
point
of
view
not
number
one
api,
the
interesting
stuff
about
the
example
customer
customer
setup,
because
we
were
working
already
with
one
of
my
company
to
kind
of
discuss
this
and
we
notice
there.
E
There
were
some
stuff
to
be
adjusted
to
kind
of
support,
all
our
scenarios
right.
So
the
main
thing
is
like
I
can
kind
of
briefly
talk
about
this.
This
document
is
a
draft,
so
you
guys
can
start
reviewing
this
and
comment
also
at
questions
for
this.
So
if
this
is,
for
example,
an
example
v-net,
which
is,
let's
say,
10-1-16
right
and
we'll
have,
for
example,
three
subnets
and
there
will
be
some
mappings
which
will
behave.
For
example,
let's
say
there
will
be
vm1,
vm2,
vm3
and
and
potentially
some
private
link
mappings.
E
So
those
are
different
mappings
in
the
route
table
and,
let's
say
in
a
subnet
tool,
there
will
be,
let's
say
nva,
so
it
kind
of
like
firewall
that
the
customer
can,
for
example,
route
the
traffic
to
right.
Customers
should
be
able
to
set
up
a
route
table
and
the
router
will
be
evaluated
in
a
correct
way,
including
a
full
working
lpm
and
and
they
are
different
step
of
the
of
the
route
table.
So
I
can.
E
There
are
basic
different
examples
mentioned
here.
We
are
still
working
on
potentially
maybe
clarifying
more
about
those
examples.
So
this
is
example,
kind
of
like
made
potentially
big
round
table
that
the
customer
wants
to
wants
to
put
right.
So,
for
example,
maybe
the
customer
will
say,
let's
say
10
1
16,
which
is
our
vignette
space
right.
This
is
basically
inside
dependent
traffic,
which
means
that,
based
on
the
ldn.
E
A
E
E
Okay,
okay,
I
think
it's
being
recorded
right.
So,
for
example
like
when
the
customer
goes
to
specific
ip
address,
let's
say:
10
one
dot,
let's
say
10.1.,
let's
say
one
dot
something
right.
We
know
that
based
on
the
npm,
this
doesn't
hit
this,
but
it
will
hit
this
one
right.
So
in
this
case
it
goes
inside
the
v
net
and
is
using
the
second
level
lookup,
which
is
based
on
the
the
mapping
table
that
you
guys
are
aware
of
right.
If,
for
example,
customer
will
go
to
some
specific
others
like
10.1.0.12.
E
This
much
exactly
this
right,
and
this,
for
example,
is
like
private
endpoint
that
is
planned
as
a
route,
but
the
same
customer
may
go
to
some
specific
address.
Let's
say
from
this
address
space
that
doesn't
match
anything,
but,
for
example,
lpm
will
match
here
and
customer
may
want
to,
for
example,
assign
route
table
saying
like
any
traffic
that
goes
to
this
24
right
route
it
to
a
firewall
which
is
which
is
actually
vm
inside
a
v-net,
and
this
is
the
next
club
of
the
firewall.
E
So
so
this
is
basically
the
firewall
ip
in
the
mapping
address
space
right.
So
it's
basically
final
ip
in
the
mapping
address
space
is
kind
of
one
way
to
kind
of
do
this,
so
so
the
idea
is
that
first,
the
lpm
is
always
being
evaluated
right
and
then
the
lpm
once
the
specific
ip
address,
matches
some
specific
entry
right
dictates
where
the
traffic
should
go
right.
E
Zero
actually
doesn't
go
to
the
internet
directly,
but
it
needs
to
be
first
forwarded
using
a
udr,
so
using
user
defined
route
to
a
next
scope,
which
would
be
the
firewall,
which
means
that
zero
such
zero
can
actually
go
to
firewall,
not
direct
to
the
internet.
So
this
needs
to
be,
for
example,
foreign,
but
the
customer
may
decide
to
okay
he's
trusting
some
specific
traffic,
which
is
let's
say
50
80
is
trusting,
so
you
want
to
accept
this
id
from
going
to
the
firewall,
and
this
should
go
in
this
case,
the
internet.
E
So
without
any
handicaps
or
anything
like
this
right
at
the
same
point,
he
may
decide
as
part
of
this
kind
of
bigger
prefixes
on-prem.
So,
for
example,
let's
say
this
address
and
this
address
and
the
other
addresses
are,
for
example,
on
the
on-premise
network.
So
it
should
be
static.
End
cap
because
here
is
like
dynamic,
end
cap
based
on
the
different
destinations.
E
Here's
more
like
static,
end
cap
with
a
specific
card
called
the
gri
key
to
other
cisco
players
or
different
kind
of
appliances
like
they
do
that
serve
as
express
route
right,
then
later
those
appliances
or
register
or
whatever
that
later
redirects
this
to
on-prem
right.
So
this
is
specific
stuff
right.
The
main
important
part
is
npm
is
always
evaluated
first
right
and
only
lpm,
because
the
customer
has
full
control
of
the
route
table
right,
so
customer
can
fully
define
rpm
right
and
the
customer
can
do
whatever
they
want.
E
So
zero
suggestions
should
not
be
assumed
to
be
going
to
the
internet,
always
because
someone
decides
0
0
to
redirect
to
the
next
scope,
and
this
next
group
can
be
either
a
target
that
is
directly
encoded
as
a
this
gr
key
and
redirected
the
specific
underlay
address,
but
they
may
decide
to
redirect
to
some
overlay
address.
In
this
case,
we
refer
the
v-net
right
if
everything
is
to
be
routed
through
this
right
or
to
specific
destination
and
also
some
specific
destination,
maybe
actual
mapping.
E
So
this
document
talks
about
highlight
how
high
level
how
the
route
table
works.
The
customer
right
now
controls
in
event
with
lots
of
examples,
different
scenarios,
so
our
I
would
encourage
you
guys
to
potentially
take
a
look
at
and
comment
and
based
on
the
comments
you
will
expand
as
much
as
possible.
It's
possible
that
really
said
something
that
was
not.
That
may
not
be
fully
clear
and
so,
for
example,
during
the
talk
which
we
definitely
can,
we
want
to,
in
addition,
also
clarify
the
documents.
So
it's
really
exciting.
E
That
each
card,
for
example,
will
support
or
institutional
support
and
based
on
the
mac
address
there'll
be
some
guide
id.
For
example,
there
will
be
some
potentially
cost
object
that
is
related
to
the
eni,
and
this
cost
object
will
be,
for
example,
define
us
hey.
This
is,
for
example,
how
much
bandwidth
this
eni
only
can
handle
how
much
cps
and
how
many
flows
we
want
to
reserve
for
the
specific
eni
that
customer
can
basically
go
above
right,
so
it's
kind
of
like
a
top
staff.
E
So
even
if
we,
for
example,
have
multiple
dns
that
belongs
to
different
customers
on
one
card
or
one
switch
right,
one
customer
using
a
lot
should
not
be
able
to
start
the
the
others.
That's
why
that's
why
the
cost
object
should
be
always
assigned
to
some
specific
dns
right.
The
enis
can
belong
to
different
vpcs
or
v-nets,
and
we
are
still
closing.
We
will
call
it
like
upc
or
v-net
right.
So
those
are
the
kind
of
stuff
and
they
are
like,
as
I
mentioned,
like
different
actual
stages.
E
They
want
to
have
five
right
now:
five
alcohol
stages
right,
so
each
aqua
stage
for
both
involved
and
outbound,
maybe
separate
table
we
may
use
or
may
not
use
some
of
them,
so
some
maybe
pass
through
the
same
for
the
outbound,
some
specific
icon
tables.
That
can
be
this
right
and
separate,
for
example,
route
tables,
the
one
that
I
just
mentioned,
but
so
far
we
have
decision
of
the
inbound.
E
We
also
will
be
working
on
how
to
handle
the
inbound
route
table
and
also
snap
policies
outside
of
the
scope
for
now
and
also
potential
metering
policy
and
the
interesting
stuff
here.
Vpc
definition
is
mostly
like
hey.
This
is
the
gre
key
or
vxlan
id
some
of
the
spaces,
not
much
use.
What
is
interesting
actually
is
potentially
the.
E
E
G
E
Is
the
same?
This
is
the
same.
So
that's
why
I
was
kind
of
like
I
used
upc,
but
prince
told
me
that
maybe
they
will
switch
to
v-net
because,
like
my
my
point
of
view
was
like,
we
are
at
the
same
point
we're
considering
like
open
flow
and
also
potentially
selling
apis,
and
some
of
those
apis
refer
to
the
vpcs
pc.
Some
of
the
ap
apis
referred
as
the
v-net
here,
I'm
using
vpc,
but
like
unification
of
the
names.
E
E
Or
both
for
both
okay,
so
so
so,
basically,
what
we
are
thinking
from
the
point
of
view
like
smart
for
from
our
point
of
view
this
morning,
needs
to
have
all
the
functionality
of
the
sdn
to
be
able
to
route
the
traffic
right.
Smart
switch
is
more
like
for
a
form
factor
then,
instead
of,
for
example,
buying
multiple
smart
mix
and
putting
as
a
one
chassis
right
with
our
server.
C
E
E
E
With
regards
to
the
outer
end
cap
address,
even
though
the
the
traffic
customer
sees
us
before
to
before
traffic
right,
but
we
will
end
up
this
and
route
on
our
physical
network
using
ipv6
right
as
well.
We
also
support
for
the
customers
to
bring
their
own
ipv6
addresses
inside
their
v-nets,
so
overlay
can
be
also
customer
will
be
communicating
ipv6
through
ipv6
on
the
underlay.
Basically,
is
it's
also
ipv6,
for
example
right.
So
this
is
this.
There
is
additional
scenario
for
the
traveling,
I'm
not
quite
sure
if
this
is
fully
described.
H
A
C
E
So
so,
while
you
need
ipvc
doing
overlay,
you
can
think
from
the
point
of
view,
like
big
customers.
One
one
thing
that
you
guys
are
probably
aware,
like
conca,
is
one
of
our
like
biggest
like
not
biggest,
but
one
of
our
customers
right
the
same
as
walmart,
and
they
basically
for
them.
Azure
is
the
extension
of
their
on-prem
network
right
on
premise
network
and
they
are
hosting
lots
of
vms
in
azure,
as
extension,
doing
some
processing
using
load
balance
in
this
kind
of
style,
but
those
vms
doesn't
have
to
have
internet
connectivity.
E
E
E
E
So
sometimes,
for
example,
even
if,
for
example,
you
are
going
to
this-
we
also
want
to
explicitly
route
to
some
additional
plans,
so
do
another
endicott
on
top
of
it.
So
this
this
is
basically
the
stuff
in
the
mapping
table.
What
is
interesting
and
the
appliance
is
also
defined
as
a
way
kind
of
like
applies
id.
This
is
the
wrong
place
that
you
can
reference,
that's
the
ip
or
the.
E
I'll
talk
slightly
more
about
this.
What's
interesting
is
like
route
table,
so
we
have
route
table,
but
for
this
is
let's
say,
ipv4
out
table,
so
normal
prefixes
are
as
the
lpm
prefixes
right,
and
then
this
is
kind
of
like
similar,
like
here
that
says
that,
for
example,
10.1,
maybe
not
16,
maybe
24.,
I'm
not
quite
sure.
If
this
is
exactly
this
example,
maybe
yeah-
maybe
it's
this
example
right.
This
goes
to
the
vpc.
E
So
whenever
someone
sends
the
traffic
that,
because
first
you
need
to
evaluate
the
lpm
whenever
lpm
hits-
and
it
says
okay,
this
is
the
prefix
that
got
hit
based
on
the
rpm,
because
nothing
else
was
more
specific
right.
Then,
for
that
specific
prefix
we
need
to
use
v-net.
So
the
destination
is
within
a
v-net
right,
and
this
is
the
minute
id.
E
So
this
means,
if
customer
is
going
to
10.1.0
dot,
something
we
basically
go
to
this
table
and
say
10.1,
there's
10
to
1.00,
for
example,
perform
this
kind
of
stuff,
so
basically
do
the
end
gap.
This
is
the
routing
type
provide
this
overlap.
Sieve
deep
and
and
use
on
the
metering
bucket
right,
so
destination
can
be
either
this
dynamic
right
notice
that
we
don't
have
any
specific
ip
addresses
there,
but
whenever
some
address
is
belonging
to
this,
we
just
need
to
look
up
explicit
address
here.
E
That's
one
option
right:
the
other
option
is:
if
you
are
going
to
any
address
in
this
network
right,
then
the
destinations
also
you
need
to
route
it
through
this,
like
kind
of
firewall
going
to
the
firewall
right.
So
the
destination
is
inside
the
like
some
ip
of
your
v-net.
So
this
destination
is
really
the
custom
address
space,
so
overlay
of
this
one.
E
E
The
firewall
right
of
the
specific
ip
with
this
so
sometimes
basically
for
the
vpc
direct
target,
the
the
destination
ip
through,
which
we
are
routing,
is
inside
the
minute.
So
we
need
to
look
up
in
some
cases.
The
destination
ip
is
is
I
don't
have
here,
but
there
is
basically
like
direct
end
cap
to
the
actual
pa
that
pa
is
listed
here
right,
for
example,
this
traffic
is
like,
let's
say,
except
traffic,
so
direct
traffic,
no
end
cap.
It
just
goes
to
the
internet.
There's
some
part
of
the
service
driving
what's
important.
E
We
also
won't
have
ability
they're
not
able
to
drop
the
traffic,
so
we
should
also
be
able
to
say
drop
right.
So
this
is
basically
the
stuff
right
and
we
need
here
is
that
basically
a
static
step?
If
you
want
to
forward
this
traffic
to
on
promise
through
some
like
hardware
appliances
like
this
car
is
this
kind
of
stuff
we
can
say
appliance.
E
This
is
the
appliance
id
and
then
and
then
based
on
this,
for
example,
it
means
that
let's
say
this
is
the
appliance
id
and
means
that
you
need
to
end
up
using
those
kind
of
stuff
right.
So
that's
the
stuff
that
we
are
that
we
right
now
in
driving
development
with
regards
to.
So
this
is
how
azure
works.
We
just
have
much
much
more
complex
way
of
creating
this
policy.
Using
lots
of
layers
can
stab
in
vp,
which
is
very
convoluted.
That's
why
we
kind
of
we
know
how
we
are
using
this.
E
That's
why
we
are
kind
of
simplifying
this
and
prince
from
the
selling
team
is
converting
this
into
actually
young
and
and
and
creating
some
tables
for
reddish.
That
will
be,
for
example,
keeping
the
state
and
one
interesting
stuff.
Is
this
routing
types
here,
roping
typing
pc
this
kind
of
stuff
right,
sometimes
some
some
stuff?
Let's
say,
for
example,
service
tunnel
right.
This
is
not
only
one
single
end
cap,
this
is,
let's
say
doing
one
transposition,
plus
one
income
and
those
kind
of
stuff.
E
That's
why
we
need
to
have
ability
to,
for
example,
configure
those
kind
of
transposition
and,
for
example,
here
service
tunnel
means.
This
is
the
subsection
that
that
we
cannot
propose
that
a
routing
type
is
config,
so
we
driving
types
can
have
right
now
up
to
four
actions
right
and
the
routing
type
direct
action
type
is
direct,
but
writing
type.
For
example,
let's
say
for
the
for
the
service
tunnel.
Let's
say
here
we
have
up
to
like,
for
example,
first
we'll
be
converting
the
packet
for
four
to
six
and
then
doing
static.
E
E
Only
right,
then,
potentially
some
routing
time
will
have
some
specific
id,
so
this
routing
time
will
be,
for
example,
reference
in
the
in
the
route
table
saying
that
hey,
for
example,
where's
the
route
table
here,
let's
say
vpc
is
routing
times,
there's
no
routing
type
right.
So
this
specific
route
table
reference.
Okay,
let's
just
routing
that
with
some
argument
right.
So
in
this
case
the
routing
type
can
be
defined
in
a
way
that
hey
the
order
of
action.
This
will
be
like
16-bit
value
that
potentially
we
can
encode.
E
That
we'll
start
the
end
gap,
four
means
that
basically,
then
then
routing
addition
through
the
appliance
right
and
then
zero
means
no
other
action
right
and
potentially,
from
the
hardware
perspective.
I
was
thinking
from
that
point
of
view
of,
for
example,
doing
the
different
stages
in
kind
of
like
before
or
in
hardware
right.
This
can
be
potentially
done
with
a
packet
pipeline
that
would
have
if
we
are
supporting
up
to
four
actions.
Always
the
packet
pipeline
may
have
like
four
kind
of
kind
of
like
boxes
right.
E
It
goes
to
the
first
box.
First
box
basically
looks
at
the
first
first,
basically
be
the
other
byte
or
sorry.
This
is
like,
like
four
beats
right,
the
other
the
other
another
one
another
one
another
one
right
and
there
will
be
some
static
arguments
which,
which
are
basically
here
right
for
sometimes,
for
example,
like
studying,
encounters
argument,
which
is,
for
example,
vxlan
right.
This
will
be
responsible
for
the
speciem
box,
so
as
it
passes
through
this,
it
basically
looks
at
specific
stuff
and
does
the
stuff
in
the
packet.
E
So
in
this
case,
from
the
hardware
perspective-
and
we
have
predictable
pipeline-
that
always
four
boxes
are
evaluated
with
optionally
sandboxes
not
being
hit
right,
and
this
configuration
of
what
in
each
box
is
doing
depending
on
the
routing
type.
So
potentially
that's
that's
one
of
the
example
implementation
of
how
to
do
this.
Potentially
in
hiring
a
pipeline,
I'm
open
for
suggestions.
We
actually
never
deal
with
doing
hardware
and-
and
I
would
say
before-
anything's-
let's
say
in
microsoft-
so
I'm
not
really
sure.
E
We
could
potentially
define
the
community
just
saying
that
hey
service
tunnel-
and
there
is
one
big
box
on
the
service
now
right,
but
it
means
that
if
we
define
different
kind
of
way
of
routing
like
in
addition,
let's
say
you
need
to
do
at
the
balance
which
is
not
here
right.
Then,
if
you
guys
give
us
only
the
service
standard
that
works
in
a
specific
way
right.
E
That
only
does
this,
and
this
then,
every
time
we
need
to
go
to
every
single
hardware
vendor
to
say:
hey,
let's
implement
also
this
additional
stuff
right,
and
this
gives
us
ability
to
actually
ask
you
guys
to
implement
the
basic
types
which
is,
for
example,
let's
say:
none
go
direct
studying
in
cap
of
or
map
routing
and
cap,
which
means
that
basically,
first
we
we
do
this
kind
of
like
lookup
right
and
the
map
routing
request.
Kind
of
this
is
the
only
special
stuff
right.
E
This
means
that
if
something
has
a
map
end
cap
right
means
that
first,
we
need
to
really
look
up
the
specific
mapping
that
is
in
the
map
end
cap,
which
is,
which
is,
let's
say,
bpc
direct
right
with
the
split
system
and
and
only
then
vpc
direct,
basically
says
that
use
this
one
actually
like
static
and
can
be
extended
with
a
specific
idea
right.
So
this
is
hardcoded
there
is.
I
understand
there
is
lots
of
today.
E
This
is
how
our
networking
works,
and
apart
from
this
json,
which
kind
of
referencing
implementation.
I
think
this
is
what
you
guys
were
asking
for.
We
will
publish
this
one
thing
that
you
guys
should
be
aware
that
it's
not
the
final
version,
some
stuff
can
change
and
we
are
open
for
any
suggestion
of
how
to
make
it
harder
optimal.
What
we
should
optimize
is
the
specific
type
of
routing
actions
sufficient.
Should
we
name
it?
Should
we
potentially
add
to
an
expand
to
it?
E
That's
why
I
kind
of
propose
here
for-
and
this
can
potentially
be
streamlined
using
this
pipelining
method-
would
still
allow
some
configurations
like
like
be
able
to
specify
kind
of
the
route
table
that
they
do
this
and
those
are
the
four
things
in
the
pipeline
plus
some
specific
arguments
to
do
this
right.
So
that's,
basically,
this.
E
So
I
would
say
right
now
that
we
discussed
this
and
with
all
the
like
asterisks,
for
you
guys
that
this
is
not
it
fully
closed
and
potentially
can
still
change.
And
if
you
are
okay
with
this,
I
think
we
can
even
upload
it
right
now
right,
but
we
are
still
discussing
some
stuff,
so
potentially
some
stuff
will
change
right
like,
for
example,
the
aja
groups
like
aj
group,
for
example.
Some
group
is
active
versus
standby.
E
We
need
some
more
details
on
this,
I'm
not
quite
sure
if
how
bgp
settings
define,
because
I'm
not
really
full
specialize
on
bgp,
so
maybe,
for
example,
this
section
will
change
this
kind
of
stuff,
so
there
are
lots
of
gotchas
in
this
document.
So
I
want
to
make
sure
that
you
guys
know
that
this
is
not
the
final
final
clause.
G
G
E
E
So,
depending
on
the
action
right
so,
for
example,
in
the
action
it's
for
example,
static,
encap
through
the
appliance
right,
this
doesn't
use
mapping
table
they.
Just
this
just
basically
says
that,
for
example,
this
mapping
and
encapsulated
appliance
means
that
let's
say
this
one
right,
if
you
are
going
for
some
address
that
will
hit
this
npm
entry
right
then
go
through
this
appliance
this
id
right
and
this
appliance
has
like
28
and
it
basically
statically
end
up
with
this
outer
header
right
with
vxlan.
E
So
there
is
no
mapping,
but
at
the
same
point,
if
you
hit
something
that
says
vpc,
then
yeah,
then
you
are
going
to
the
for
example.
Here
right,
then
any
others
that
you're
going
to
here.
You
need
to
look
up
in
this
vpc
and
then
this
kind
of
dynamic
stuff.
So
here
is
this
lookup
right
versus
vpc
direct
is
like
any
others
that
you
are
going
here.
E
Right
so
this
is
this,
and
the
mapping
metering
package
is
basically
some
bucket,
which
is
identifier
which,
for
example,
when
the
flow
gets
created,
the
flow
should
associate
to
the
bucket
so
every
time
what
packets
goes
through.
This
flow,
both
unbound
right,
it's
basically
this
and
I
and
unfortunately
I
think
we
are
over
time
and
actually
yeah.