►
From YouTube: DASH Workgroup Community Meeting July 27 2022
Description
Slide deck and demo for showing the bmv2 build-test workflow & CI by Keysight
A
First
thing
what
I
wanted
to
do
unless
there
is
something
pressing
is
hand
it
over
and
allow
30
or
so
minutes
for
keysight
to
talk
about
the
latest
happenings
during
the
week.
B
So
last
week
I
did
a
sneak
preview
of
the
very
first
inklings
of
the
scythe
server
framework
working
where
we
actually
built
everything
and
connected
to
the
behavioral
model,
with
the
cythrif
server
and
in
the
last
week
of
pretty
much
sewn
up
all
the
framework,
and
we
have
the
ability
to
run
pi
tests
or
ptf
tests,
and
I
wanted
to
kind
of
review
that
and
actually
do
a
bit
of
a
update
on
the
whole
behavioral
model
testing
since
the
beginning
of
june.
When
we
first
talked
about
it
so
I'll
share
my
screen.
B
So
here
here
are
the
major
updates,
since
june
8th,
when
I
first
presented
like
our
aspirational
roadmap
of
how
we're
going
to
get
get
to
scip
testing,
and
so
this
this
is
what's
actually
been
done.
Since
then,
you
can
pretty
much
do
a
build
and
test
with
three
commands
and
you
don't
have
to
know
what's
going
on
under
the
hood,
but
I've
tried
to
make
it
easy
for
test
developers
to
get
under
the
hood
and
write
test
cases
as
well.
B
So
if
we
just
review
this
list,
we
already
had
p4
code,
compiling
and
libside
was
already
built
from
from
the
p4
code
was
auto
generated.
I
did
add
some
enhancements
to
allow
to
actually
interact
with
the
scytheriff
server.
You
need
certain
kind
of
initialization
commands
like
site,
api,
query
and
side.
Git
switch
attributes
things
like
that,
so
I
put
in
some
skeletal
code
enough
to
get
this
past
this
step.
B
B
That's
the
psi
paradigm,
so
we
had
to
add
enough
code
in
there,
but
there's
still
work
to
be
done
and
that's
that'll
be
on
the
task
list
which
I'll
review
later
so
we're
building
the
scythrip
server
and
client
using
the
auto
generation
framework
that
intel
submitted
to
ocp
last
fall
and
had
and
pretty
much
has
been
in
development
and
in
use
since
then.
B
So
we
have
that
integrated
and
there's
a
few
issues.
I
needed
to
file
the
side
project
and
prs
to
get
past
a
couple
of
little
hurdles,
but
it
was
very
easy
to
overcome,
and
so
those
there's
some
pr's
pending
right
now,
I'm
using
a
dev
branch
of
psy,
I
created
a
docker
image
that
has
the
scythetrip
client
and
what
that
means
is.
B
So
the
frameworks
are
integrated,
all
the
tools
and
libraries
and
also
in
this
sci
client,
sci-threat,
client,
the
entire
sci
ptf
framework
and
all
the
test
cases
from
the
side.
Repo
are
actually
buried
into
that
or
embedded
into
that
image.
So
you
really
have
all
the
resources
you
need
to
write
tests,
both
upstream
tests
that
are
already
there
plus
ones
that
you
want
to
add
and
I'll
make
some
comments
in
a
while
about
how
we're
going
to
eventually
use
the
dash
branch
of
psy
and
then
get
that
merged
into
here
as
well.
B
B
I
wrote
a
few
example:
our
tests
for
both
ptf
and
pi
test,
so
people
can
see
what
the
structure
is
like
and
what
you
can
do
is
take
that
as
a
starting
point
and
start
creating
your
own
text
and
elaborate,
but
the
kind
of
the
start
and
stop
the
skeleton.
Is
there
lots
of
readmes
doctor
file,
streamlining
which
we
had
a
pr
last
week,
which
we
did
accept?
B
I
think
last
maybe
wednesday
after
the
meeting,
so
the
docker
files
are
smaller
and
I've
tried
to
make
it
so
you
don't
actually
need
to
install
any
libraries
on
your
on
your
development
environment.
Previously
you
had
to
do
python
and
pip
and
snappy,
and
things
like
that
now
it's
all
embedded
inside
the
scitrip
client
container.
B
So
if
I
did
this
right,
you
really
don't
have
to
contaminate
your
host
environment,
which
is
ideal.
You
don't
have
to
install
stuff,
you
don't
even
need
virtual
enb
from
python
or
anything
it's
just
all
inside
the
containers
christina
and
I
have
worked
with
the
microsoft
it
team
to
get
an
azure
container
registry
created
for
our
use,
we're
not
using
it
yet.
B
So
that's
an
upcoming
task,
where
these
docker
files,
these
images
that
are
living
right
now
in
my
own
docker
hub,
we'll
move
them
to
azure
and
have
a
proper
home
for
everything
and
then
there's
there's
a
few
gaps.
We
found
that
the
workarounds
are
there
and
working
and
also
people
sort
of
behind
the
scenes.
I
reached
out
and
got
several
friendly
brave
souls
to
try
out
these
dev
branches
and
it's
always
really
help
because
you
immediately
find
out
things
you
assumed
because
it
works
in
your
environment
and
it
really
doesn't
work
for
someone
else
smoothly.
B
B
B
But
the
big
thing
is
these:
all
these
containers
all
work
and
the
yellow
ones
are
the
ones
that
you
use
to
build
stuff
by
typing,
make
all
it
just
builds
everything
you
don't
have
to
worry
about
it,
and
then
at
runtime
you
would
run
the
switch
you'd
run
the
scithrift
server
and
then
the
scythetrip
client
is
what
you
can
run
to
do.
Tests
and
this
side
through
client
contains
all
the
goodies.
You
need.
B
So
it's
all
copied
into
this
container,
so
you've
got
a
container.
It's
got
everything
you
need
in
it
to
run
tests
and
you
don't
have
to
contaminate
your
host
environment
and
you
can
just
type
a
command
and
it
will
run
all
these
tests
I'll
elaborate
it
a
little
bit
going
forward
where
you
can
tell
it
which
tests
you
want
to
run
right
now,
just
runs
them
all.
B
C
Chris
yeah,
just
a
quick,
aren't,
scappy
and
snappy
are
two
competing
things
and
do
you
want
do
you
need
both
of
them
or
is
it
just?
You
mentioned
that
you
have
snappy
for
the
you
know,
for
for
traffic
generation
and
integration
with
dixia
and
so
forth.
But
what
is
cappy
here.
B
Scappy
is
what's
used
throughout
the
ptf
framework,
so
ptf
packet
test
framework,
which
was
actually
created
by
barefoot
many
years
ago,
now
intel
it's
basically
pi
unit,
test
framework,
plus
scappy
plus
tons
of
helper
libraries
that
make
it
really
easy
to
run
the
kinds
of
tests
when
you're
testing
data
planes
and
there's
a
rich
body
of
tests
like
a
couple
thousand
test
cases
and
the
sonic
or
the
psy
ptf
test.
B
Repo
is
completely
based
on
that
and
it's
great
for
writing
tests
that
are
very
straightforward,
where
you
can
say,
create
an
ethernet
packet
with
this
contents
and
that
contents
send
it
into
port
one
receive
it
on
port
two
dissect
it
compare
the
contents
test,
pass
or
fail
that's
kind
of
the
paradigm,
and
so
there's
a
lot
of
people
who
know
how
to
use
it
and
there's
a
lot
of
test
cases.
So
we'll
continue
to
use
it
and
intel
is
going
to
be.
B
B
Snappy
has
kind
of
a
different
role
in
it
and
it's
a
client
library
that
can
run
software
or
hardware
traffic
generators
and
it's
very
good
at
running
tests
that
are
that
have
flows
and
scale,
so
it's
very
expressive
to
say,
create
a
thousand
flows
with
the
ethernet
address,
incrementing
like
so,
and
you
and
with
just
a
few
simple
commands.
You
can't
do
that
in
scappy.
B
So
that's
one
of
the
differences.
Another
difference
is,
you
can
run
these
same
configurations
in
a
software
traffic
generator,
which
is
hcsc.
You've
actually
run
these
same
tests
on
a
hardware
traffic
generator
at
line
rate,
so
these
are
kind
of
complementary
paradigms
and
they
they
they
work
very
well.
Both
of
them
are
valid,
so
we're
going
to
support
both
and
not
you
know
not
try
to
dictate,
but
in
the
there
will
be
tests
where
it
doesn't
make
sense
to
try
to
do
them
as
scappy
like
we
want
to
do
extreme
flow
scales,
etc.
C
C
B
Yeah
and
of
course,
you
know
we're
we're
in
love
with
snappy
and
and
and
xcsc,
because
that
that's
our
product,
but
we're
not
gonna,
play
favorites
in
the
community
and
we're
gonna,
let
it
be
a
meritocracy
right,
whatever
tool
works
for
the
job,
let
people
use
it
and
you
know,
I
think,
over
time,
we'll
we'll
find
out
which
tool
works
best
in
which
situation,
I
think
they'll
there's
a
place
for
both.
C
B
B
Let
me
stop
a
minute
when,
when
it
copies
that
in
that
means,
this
container
has
everything
in
it.
You
could
actually
run
it
on
a
different
device
than
the
behavioral
model.
This
could
also
be
the
basis
for
talking
to
a
hardware
device
right
running
on
a
host
that
this
could
run
on
a
house.
Your
hardware
device
might
be
a
dpu,
so
we're
we're
building
in
the
way
to
have
a
self-contained
test.
B
So
you
can
also
mount
the
the
test
directory
on
your
host
in
your
in
your
code,
development
environment,
into
this
container
under
a
test
dev
directory,
and
you
can
run
tests
from
either
so
you
could
run
tests
that
are
already
kind
of.
I
call
production
tests
already
copied
into
the
container
or
you
could
run
have
this
container
running,
live
and
and
be
using
test
and
changing
these
tests
in
real
time
live
and
see
that
file
directory
on
your
host
and
add
it
in
real
time
and
run
tests
and
debug.
B
B
Do
people
understand
how
docker
can
mount
file
system
from
your
host
into
the
into
the
running
container?
It's
like
a
symbolic
link.
Almost
you
can
see
everything
in
your
host.
If
you
want
so
that's
kind
of
a
mouthful,
let
me
see
what
my
next
slide
says.
B
B
You
just
need
docker
compose
to
run
the
htc
tests,
not
just
not
the
ptf,
but
I'll
show
how
to
install
that
clone.
The
repo
check
out
the
branch
which
is
usually
going
to
be
main
for
most
people,
but
people
who
people
who
are
brave
souls
will
check
out
my
dev
branches
and
from
my
repo
and
my
fork
and
do
the
same
sequence,
this
one
command,
initialize
psi,
then
just
a
few
commands
right
go
into
the
directory.
B
So
let
me
let
me
go
back
we're
going
to
assume
I
already
did
make
clean
and
make
all
so
it's
I
don't
know
five
or
ten
minutes
to
build
everything,
and
so
I'll
go
back
to
here.
I'm
gonna
run
the
switch
okay,
that's
it!
The
bmv2
is
running
waiting
for
p4
runtime
commands
on
this
port.
B
B
B
B
On
a
real
hardware-
that's
not
before
in
time,
for
example
like
outside,
so
what
you
would
have
so
here's
what
would
happen
you
would
if
this
was.
Let's
say
you
replaced.
Let
me
zoom
in
a
bit
see
how
good
I
do
on
that
real
hardware.
You
would
have
at
this
line
here.
This
would
be
all
this
stuff
would
be
your
real
hardware
and
you
wouldn't
have
a
soft
switch.
B
You
wouldn't
have
this
adapter
right.
You'd
have
libside
talking
to
your
own
sdk,
so
replace
everything
to
the
to
the
right
of
this
cursor
here
with
your
stuff,
you'd
have
libside
you'd,
be
able
to
then
compile
it
against
the
scythe
server
yourself,
and
this
would
be
running
on
your
hardware,
so
everything
this
would
be
all
the
vendor
stuff,
and
this
would
be.
The
scyther
client
would
still
work
the
same
client
because
it's
using
the
same
commands
it
doesn't
know
if
this
is
hardware
software
and
then
you'd
have
a
real
traffic
generator.
B
And
my
leg,
exactly-
and
one
thing
I'd
like
to
do
is-
is
try
to
make
tweaks
and
adjustments
to
this,
to
make
it
even
easier
for
third
parties
to
compile
against
their
tools.
So
I
want
to
work
on
one
of
the
next
steps
I
want
to
do
and
I
can
work.
You
know
we
can
work
behind
the
scenes
right.
It
doesn't
have
to
be
in
the
community.
We
can.
We
can
collaborate
to
integrate
this
framework
with
your
own
framework.
B
The
the
hope
is
that
you
can
import
the
dash
repo
into
your
own
development
environment
and
use
that
as
a
git
sub
module,
for
example,
and
tie
your
own
infrastructure
into
it
and
integrate
them.
So
you
can
use
the
pieces
out
of
here
that
you
want
and
and
and
then
substitute
in
your
your
own
solutions
for
other
parts.
B
A
Add
just
a
little
bit
suresh,
the
scitrif
server
is
auto
generated
with
the
scift
auto
generated
framework,
and
the
lip
side
will
be
yours
and,
and
it
will
run
on
the
hardware.
B
Yeah
there
is
yeah,
there's
a
documented
process
that
already
got
upstream
to
sai
that
reshma
and
and
her
colleagues
contributed
the
talks
about
doing
this,
and
so
this
container
is
built
using
the
instructions
that
were
in
that
document,
and
you
know
with
modifications
to
suit
the
dot
of
the
dash
project.
B
What
I,
what
intel-
and
I
hope
to
do,
is
talk
about
contributing
a
docker
container,
docker
file
and
and
maybe
help
and
documentation,
I'm
doing
this
in
the
sci
repo,
so
that's
easier
for
people,
because
right
now
it's
kind
of
a
recipe
where
you
copy
this
file,
do
this
command,
etc.
B
What
we'll
do
is
we'll
try
to
make
that
even
easier
where
you
just
say:
here's
my
library
location
make
and
it
just
builds
it
all
for
you.
So
I'd
be
happy
to
work
with
people.
You
know
also
behind
the
scenes
to
try
to
take
some
of
this
know-how
and
incorporate
it
into
your
workflow,
but
we'll
try
to
make
some
of
these
components
even
more
general
purpose
for
people.
B
B
B
I've
just
created
this
this
container
here.
The
reason
it
was
so
fast
is
because
everything's
already
built
except
copying,
a
few
things
into
the
container
from
your
environment.
There's
a
there's,
a
base-
docker,
that's
already
pre-built-
it's
built
in
python-
has
copied
all
these
baseline
things.
So
it's
pretty
fast
to
remake
that
container.
B
What
this
is
going
to
do
is
running
pi
tests
and
ptf
test
is
running
both
sets
of
suites
because
there's
going
to
be
complementary
there,
it's
done,
there's
four
simple,
just
a
few
simple
tests
that
are
in
the
repo
as
starters,
but
it's
already
run
them
as
sent
packets
through
the
pipeline.
You
may
recognize
this
output
from
the
original
hello
world
hcsc
test.
It's
now
part
of
this
test
suite,
so
we've
got
a
bunch
of
tests
in
there
and
I'll
just
show
you
where
these
tests
live.
B
I
know
this
is
probably
tiny,
but
under
dash
pipeline
test,
there's
a
libsive
directory
that
has
the
c
plus
plus
tests.
Remember
this
initial
v-net
out
test
that
marion
provided
it's
now
in
here.
I
moved
it
around
a
little
bit
and
then
there's
a
scythe
thrift
directory
with
ptf
tests
and
pi
tests
in
it.
B
So
here's
some
basic
ptf
tests.
If
we
look
example
here,
you
know,
here's
some
python
code
now
there's
a
little
work
to
be
done,
which
I've
already
talked
to
intel
about,
but
we
need.
We
need
help
in
implementing
a
few
more
callbacks
in
the
lib
side
for
the
bmv2.
In
order
to
fully
support
ptf
and
right
now,
I
have
to
inherit
the
classes
from
this
thrift.
Interplays
data
plane
that's
kind
of
a
generic
ptf
test.
In
order
to
take
advantage
of
the
whole
framework.
B
B
So
I
wanted
to
pause
again
to
find
out
if
there's
any
questions
about
this
workflow,
so
the
workflow
could
be.
You
know,
you
start
the
switch.
You
start
the
server,
then
you
can
run
tests.
You
can
add
to
the
test.
You
can
edit
the
test
and
rerun
them
without
shutting
all
the
stuff
down.
So
it's
fairly
interactive.
B
B
All
it's
doing
is
connecting
to
the
port,
making
sure
there's
a
connection
on
port
9092.
So
it's
kind
of
nice
to
see
you
want
to
kind
of
work.
Your
way
up
right.
You
want
to
have
a
baby
step.
Okay,
this
the
thrift
sessions
established.
Then
here's
a
v-net
test
where
I
create
some
entries
and
send
packets
and.
B
Yeah
I'll
show
you
the
code
for
this
and
then
here's
one
where
we
we
do
a
xcc
test,
where
we
spin
up
the
traffic
generator
and
then
test.
This
echo
the
report
right
and
then
it's
sending
a
thousand
packets.
So
this
test
continuity
to
the
switch
that
the
switch
is
passing
packets
and
that
the
traffic
generator
works.
You
know
there's
some
reality
check
here.
B
And
then
here's
here's
another
one
that
let's
see.
B
This
is
where
it's
connecting
to
the
switch
and
getting
switch
attribute,
which
is
kind
of
dummied
out
right
now.
This
is
one
of
the
workarounds
where
we
we
don't
actually
send
attributes
back
to
the
test
script
or
to
the
framework
it's
faked
out.
So
we
need
to
work
on
that
and
add
some
some
code,
so
it's
kind
of
a
quick
survey,
but
it's
running
various
tests.
Okay-
and
you
know
this
kind
of
code.
C
So
a
couple
of
questions
chris
one
is
earlier:
you
showed
that
you
know
that
you're
going
to
mount
a
directory
from
host
right
yeah,
so
in
which
step
are
we
doing
that.
B
Good
question
like
cheat
up
okay,
so
this
just
ran
tests
that
were
copied
into
the
container
when
I
said,
make
docker
side,
thrift,
clamp,
okay,
so
they're
kind
of
in
here
permanent,
let's
say
production,
although
it
only
took
two
seconds
to
build
it,
so
you
just
rebuild
it
every
time
you
change
a
test,
but
let's,
let's
do
this?
One
I'll
show
you
a
couple
different
examples.
B
First,
if
you
just
put
dev
in
front
of
this-
and
this
is
another
make
target
dev
test
what
this
does
is
playing
around
with
it
before
the
meeting.
I
hope
I
didn't
break
it.
Okay,
it's
running
now
it
looks
the
same
right,
but
this
time
I
swear
in
port
that
it
was
running
tests
out
of
the
host
directory
and
the
way
I
can
tell
is
you
you'll
probably
see
the
yeah
okay.
So
if
you
know
docker
commands
what
this
saying
is
run
the
docker
this
this
we're
running
this
local
dash
cycle
client.
B
This
is
the
docker
container
that
you
build
notice.
It's
got
this
local
repo.
I
just
did
that
to
make
it
clear
that
it's
built
in
your
local
environment.
It's
not
being
it's
not
being
built
or
pulled
from
docker
hub,
I'm
mounting
I'm
using
the
workspace
test,
dev,
that's
the
that's
the
file
or
the
directory
that
it
will
look
like
inside
the
container
now
mounting
my
local
directory.
B
C
B
B
Make
run
run
scithrip,
client
bash.
What
that
does
is
it
runs
the
site
through
client
and
just
gives
you
a
bash
session
so
now
you're
in
the
client,
as
if
it
were
just.
You
know,
ubuntu
running
for
you
you're
now
running
inside
this
environment,
and
I'm
gonna
show
it's
in
the
test:
dev
directory.
Okay.
So
let's
do
an
ls.
B
B
B
B
It
doesn't
have
that
hello
file,
that's
the
copied
contents
before
when
I
built
that
container.
So
these
are
the
static
tests
I
like
to
call
them
production
tests,
they're
copied
in
the
container
into
the
image
and
build
time.
This
is
like
a
test
directory
a
test
development
directory.
You
can
so
you
can
see
the
test
live,
you
can
edit
them
live.
I
could
I
could
go
in
with
my
bs
code
and
start
writing
tests
and
they'll
appear
in
real
time
inside
this
test,
dev
directory.
B
That
does
that
help
a
little
bit
yes,
and
I
try
to
explain
in
the
readme
briefly,
but
once
someone
sits
down
goes
through
this
and
starts
internalizing,
it
you'll
see
how
handy
it
is
because
when
I
was
writing
my
my
example
our
test,
I
just
kept
this
bash
session
open
and
just
kept
rerunning
that
one
test
over
and
over.
B
So
let
me.
B
Yeah
I'll
show
you
an
example
of
interactively
working
on
this
stuff,
so
I'm
going
to
go
into
the
scithrift
ptf
directory.
Okay.
So
let's
look
what's
in
there
there's
two
directories:
there's
the
thrift
directory
and
the
vnet
directory
and
those
contain
some
test:
suites.
Okay,
so
let's
go
into
nina
I'll.
Just
do
it
from
here,
so
I'll
show
you
a
command
to
invoke
ptf
test
without
running
it
without
doing
a
mate
command.
B
This
is
like
getting
down
to
a
real
ptf
developer,
where
you
know
the
commands,
so
I'm
telling
it
to
run
ptf
tell
the
test
directory
is
the
current
one.
You
need
to
tell
it
where
the
side
libra,
where
the
client
libraries
are
and
have
it
conveniently
mounted
to
the
this
directory
inside
the
container.
Tell
it
your
interfaces
if
that
works?
Okay,
so
I
just
ran
a
test
inside
this
v-net
directory
the
host.
Now
I
could,
let's
see
if
I
can
do
this
without
choking
that
I
didn't
rehearse
this
okay,
so
bear
with
me.
B
B
So
I
think,
as
as
time
goes
on,
we'll
find
wrinkles
and
bumps.
You
know,
that's
not
perfect.
I
was
doing
some
things
just
before
the
meeting
that
made
me
realize
there's
a
couple
of
rough
edges,
so
this
is
a
work
in
progress
and
I'm
sure,
as
people
start
doing,
I
just
saw
a
chat.
B
Yes
sure
think
of
something,
so
I
think
of
probably
enough
for
the
demo.
Unless
anyone
has
any
other
questions,
you
know
there's
a
lot
here
to
digest,
but
I
think
it's
a
promising
start.
B
Let's
see
what
did
I?
Oh?
I
wanted
to.
Let
me
zoom
my
screen
out.
Okay,
the
ci
pipeline.
You
can
see
this
was
just
captured
last
night.
These
are
these
workflows
and
I'll.
Actually,
actually,
let
me
go
to
actually
to
the
real
github
okay,
so
this
is
the
poll
request
with
all
this
stuff
sitting
up
here.
B
The
actions
pipeline.
You
see
every
time
someone
does
a
pull
request.
Mukesh
did
some
last
night,
it's
running
the
pipeline
every
time,
so
you
know
still
doing
this
compile
as
soon
as
we
do.
This
pull
request.
They'll
actually
be
running
unit
tests.
Against
my
you
know,
traffic
test
now
right
now,
they're
kind
of
dummy
and
placeholders.
B
So
we
need
to
come
up
with
real
tests,
and
you
know
this
is
just
the
start,
but
now
we've
got
a
framework.
So
there's
that
and
for
example,
the
most
interesting
one
is
the
ci.
Let
me
find
it.
B
We
I
build
these
dockers
when
we
do
a
pull
request,
but
you
don't
need
it's
kind
of
just
a
make
sure
we
didn't
break
anything.
You
shouldn't
have
to
pay
much
attention
to
those,
but
here's
here's
the
pipeline
for
building
and
testing
serious
pipeline,
it
should
say
dash
pipeline.
So
we
do
need
to
make
sure
that's
correct.
B
So
it's
doing
all
those
compiles
building
lib
size,
creating
the
server
creating
this,
the
local
client
side,
throughput
docker,
it's
building
the
the
c
plus
plus
test
running
the
switch
testing,
just
the
side
library,
which
was
the
original
test
that
marion
provided.
B
Great
good
question.
D
Yeah
hi
quest
regarding
the
ci
pipeline.
There
are
pull
requests
that
change
behavioral
model
and
I
tried
them
myself
locally,
and
I
saw
that
sci
api
generation
was
broken
broken
in
a
way
that
metadata
is
no
longer
properly
generated.
D
So
where
do
we
stand
on
that?
Did
we
include
metadata
compilation
already
into
ci
pipeline
or
not?
Yes,
it's
included.
Yes,.
B
So
which
branch
you
looked
at
it
might
have
been
something.
D
B
B
Yeah,
the
metadata,
I
think,
is
when
I
had
to
start
generating.
I
think
it
was
in
this
this
particular
revision,
because
I
needed
it
for
the
cyber
server
so
give
this
a
shot.
For
example,
if
you
can
like
pull
this
in
this
branch
and
then
maybe
cherry
pick,
those
other
poll
requests
in
or
something.
But
let
me
know
if
it
works
or
not,
because
we're
at
this
kind
of
crossover
point
here
where
a
lot
of
things
are
coming
together
and
we
have
to
kind
of
dance
carefully.
B
So
we
don't
step
in
each
other's
toes,
but
I
think
once
we
get
over
this
next
set
of
various
pull
requests
and
get
them
all
resolved,
we'll
be
in
good
shape.
But
you
know
just
let
me
know
if
something's
broken.
B
Yeah,
so
you
know
here's
the
pipeline,
here's
some
ptf
tests
right
this
is
live.
I
mean
not
live
was
last
night,
but
this
is
the
real
deal
right.
It's
running
these
ptf
tests
in
the
pipeline's
running,
pi
tests,
big
cc,
you
can
see
so
it's
happening
see.
I
showed
that
this
was
just
I
put
this
in
the
slide
deck
so
I'll
store
I'll
upload
this.
So
we
just
have
kind
of
a
you
know,
a
capsule
time,
capsule.
B
I
tried
to
put
some
not
everyone's
familiar
with:
writing
scytheriff
server
tests
I'll
go
over
the
two
news
in
a
second.
B
A
D
I
have
a
question
expanding
on
a
question
from
earlier.
We
have
the
one
I
picked.
D
Is
the
mv2
model
ready
to
run
a
full
end
to
end
test,
and
I
assume
the
answer
is
no,
but
the
question
is
what's
needed
extra
to
make
it
actually
work
and
run
one
test
end
to
end
that
actually
works
on
real
harder
with
all
the
I
know,
routes
being
up,
sending
the
vxlan
packet
doing
the
vxlan
doing
the
from
vpc
vni
one
moving
it
to
another
vni
having
the
route
inside.
D
B
D
B
B
Great,
I
just
wanted
to
mention.
B
There's
this
read
me
on
the
side,
thrift-
and
I
I
talked
about
a
lot
of
the
you
know
things
I
showed
you
but
there's
another
section
here
if
you're
not
conv,
if
you're
not
familiar
with
this
stuff,
as
I
try
to
show
the
directory
layout
and
where
to
find
all
the
resources
and
what's
really
important
is
you
need
to
know
what
all
the
api
calls
all
the
all
the
function
signatures
all
the
constants
for
the
scythe
grip
test,
they're
in
these
files
and
they'll
be
in
your
workspace,
and
I
I
kind
of
went
through
and
like
retrospective
and
tried
to
summarize
how
I
found
stuff,
and
so,
if
I
need
to
do
a
test
like
this,
how
did
I
find
these
things?
B
B
B
The
last
thing
is,
is
there's
a
lot
of
to
do's
and
I've
got
my
name
next
to
a
few
marion's
name
next
to
a
few
intel
next
to
a
few,
but
we
need
someone
to
help
finish
out
libside
to
get
things
like
switch
attributes
so
that
we
can
actually
run
ptf
tests
properly.
B
You
know,
then,
we
need
to
write
some
test
cases
like
for
vna.
I
would
say
those
are
the
two
main
things
I
want
to
point
out.
B
So
reshma
do
we
know
we
know
if,
if
you
folks,
you
and
your
team
want
to
try
to
do
this
part,
so
the
ptf
test
can
be
properly
supported,
something
you
guys
want
to
sign
up
for.
Are
we
looking
for
volunteers.
A
So
the
api
query,
which
is
required
in
this
site
below
the
ptf
server
that
runs
on
the
device
under
test.
We
need
an
api
that
will
give
us
the
information
on
the
attributes.
The
capabilities
supported
on
the
device
like
the
number
of
ports,
for
example
right.
A
That's
the
part,
we
will
definitely
be
contributing
to
it's
already
there.
So
yeah.
A
Yeah
as
we
have
as
we
have
the
code
in
the
private
repo
under
dash,
we
will
add
it.
There.
B
B
So
the
next
thing
is
really
just
to
well.
Where
was
I
going
to
show
you?
B
As
merchant
pointed
out,
we
need
to
implement
some
real
test
cases,
so
anyone
ideally
can
step
in
given
what
I've
shown
even
without
resolving
these
attributes,
because
I've
got
a
workaround
right.
You
can
just
kind
of
ignore
that
for
now
and
we'll
just
know
well,
we
know
it
has
two
ports.
We
don't
care
what
number
of
route
entries
we
don't
have
to
support
all
that,
let's
just
write
a
test
and
make
some
assumptions
later,
we'll
make
it
perfect
and-
and
you
know,
metadata
and
everything,
but
we
just
need
some
real
tests.
B
The
outlines
are
there:
we
can
just
drop
and
start
writing
test
cases.
So
if
anyone
wants
to
start
doing
that,
that
would
be
great.
A
So
either
pick
up
a
work
item
from
the
list
here
or
email
you
to
ask
about
one
of
them
and
how.
B
B
D
B
But
we'll
leave
at
that.
Maybe
we'll
talk
more
about
the
data
plan.
Implementation
in
the
behavioral
model
meeting
you
know
get
to
nuances.
I
don't
think
we
want
to
deep
dive
into
all
that,
but
I'm
glad
marion's
sounded
pretty.
You
know
positive
about
what
we
can
do.
Yeah
probably
have
that
okay
side,
thrift
demo
is
done
too
early.
A
That's
great
I'll
mark
it
done
in
my
list
as
well
right
and
I'm
going
to
put
in
the
chat
window
here,
a
list
of
the
prs
that
we
just
have
overall
in
case
anyone
wants
to
go
update
theirs,
but
no,
that's
great!
Chris!
That's
awesome!
I
think
you
know
we've
been
50
minutes
and
we
could
probably
guess
back
10
minutes
of
time
unless
anyone
else
has
a
burning
question
and
let's
see
here.
D
My
request,
I
don't
have
a
burning
question
christina,
but
I
I
do
think
that
this
is
the
kind
of
stuff
that
now
that
it's
getting
to
the
point-
maybe
not
this
particular
week,
but
soon
we
should
have
a
workshop
so
that
people
can
come
in.