►
From YouTube: CNCF Storage WG Meeting - 2018-08-08
Description
Join us for Kubernetes Forums Seoul, Sydney, Bengaluru and Delhi - learn more at kubecon.io
Don't miss KubeCon + CloudNativeCon 2020 events in Amsterdam March 30 - April 2, Shanghai July 28-30 and Boston November 17-20! Learn more at kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects
A
Go
ahead,
alright,
so
let
me
just
let
me
see
if
I
could
do
a
little
bit
of
Philips
background,
while
we're
waiting
on
him
to
actually
show
up
so
I.
Don't
know
if
he's
explained
any
of
this,
but
let
me
let
me
try
for
him
the.
A
The
is
the
primary
reason
I'm
here
and
I'm.
What
I'm
going
to
be
talking
about
is
Storage
Management,
a
brand
new
storage
management
standard
coming
out
a
little
bit
that
we've
been
working
on
for
a
couple
of
years
and
I'll
be
giving
a
bunch
of
background
and
showing
some
a
bunch
of
what
that
looks
like
and
some
of
the
tools
and
things
around
that
primary
rationale,
for
that
is,
is
that
you
know
you
guys
have
been
working
on.
You
know
the
CSI
layer
and
well,
that
gives
you
kind
of
access
to
standardization
for
creating
containers.
A
But
that's
okay
and
I'm.
Also
the
chair,
the
technical
work
group
in
San
Jose
as
the
storage
networking
Industry
Association,
it's
been
around
for
twenty
some
years
now
we
develop
standards
in
the
storage
space.
We
partner
with
a
desktop
are
the
DM
TF,
which
develops
standards
for
largely
server
networking
and
other
parts
of
the
the
ecosystem.
For
you
know,
and
and
management,
and
so
standard
disclaimer
slide
everything
subject
to
change
without
notice
everything
you
want
to
see
and
find
around
what
I'm
gonna
be
talking
about
neon
org,
slash
swordfish.
A
So
what
swordfish
is
we
have
had
storage
management
standards
for
a
long
time,
they've
really
been
focused
on
traditional
storage
management
and
enterprise
data
centers,
and
so
what
we've
started
to
do-
and
we
started
this
three
to
three
years
ago
now.
So
this
is
really
something
that
the
standard
has
been
developed
and
we're
just
starting
adoption.
I'd
like
to
highlight
you
know
where
we
are
you're
not
going
to
find
a
lot
of
swordfish
deployments
out
there.
Where
you
start
to
see
is
a
lot
of
people
that
have
you
know
PLC's
and
things
like
that.
A
We
have
actually
this
week
at
flash
memory
summit,
the
first
you
know
first
heping
implementation
being
announced,
and
but
what
what
swordfish
is,
is
kind
of
a
new
standard.
That's
actually
shifting
away
from
just
focused
on
enterprise
data
centers
towards
something
that
we're
expanding
to
be
more
well
I
hate
the
term
but
more
modern,
but
and
also
something
that
we
can
put
on
on
on
storage
devices
and
infrastructure
that
goes
into
broader
environments,
so
not
just
not
just
San,
but
infrastructure
that
goes
into
converged,
hyper-converged
hyper
scale,
you
you
name
it
right.
A
So
what
I'm
going
to
do
is
you
know
just
really
kind
of
give
you
an
intro
to
the
two
swordfish,
the
concepts
you
know
what
kinds
of
things
it
covers
and
also
talked
a
lot
about.
You
know
the
tools
in
the
ecosystem,
so
if
you
can
actually
go
play
with
to
get
a
sense
of
it
not
going
to
go
in-depth,
we
can
come
back
and
if
anybody's
interested
in
that
and
talk
more
about
that
at
another
time,
so
you
know
what
would
I've
actually
talked
a
little
bit
about
this
already.
What
were
the
drivers?
A
You
know
there
were
drivers
about.
You
know
what
were
things
we
did
wrong
with
the
previous
ones.
They
were
very
vendor
centric.
We've
we've
shifted
to
make
swordfish
very
client
centric,
very
customer
centric,
this
time
so
very
use
case
centric
in
terms
of
how
we
built
the
API.
It
doesn't
include
every
function
from
every
vendor
or
every
possible
attribute
from
every
product.
And
again
you
know:
we've
also
moved
to
a
more
DevOps.
Centric
storage
is
not
necessarily
managed
by
storage.
A
You
know
dedicated
storage
managers
anymore,
so
we
try
to
take
that
into
account
the
so.
What
did
we
do?
What
we,
what
we
actually
did
here
was
we
took,
we
didn't
start
from
scratch.
We
find
that's
kind
of
a
silly
approach
and
takes
a
long
time.
We
started
from
an
existing
base
of
knowledge,
one
of
the
things
we
did,
and
this
has
been
it's
not
a
you
know,
a
property
based
system.
It
we
moved
to
a
class
of
service
based
provisioning
and
monitoring
API.
A
A
And
you
know:
how
do
we
do
that
so
again,
not
starting
from
scratch?
The
DM,
TF
and
server
folks
have
been
looking
at
some
system,
similar
types
of
challenges,
so
in
the
server
management
space
they
had
a
whole
proliferation
of
management
standards
that
largely
were
being
used
by
the
server
vendors
to
you
know
for
proprietary.
You
know
and
server
base
vendor
based
products,
Spanish
ad
and
then
IPMI
and
IMI
has
a
whole
set
of
challenges
itself.
A
So
you
know,
redfish
was
had
started
as
a
consortium
among
the
server
vendors,
but
it
had
a
whole
bunch
of
stuff
we
need.
And
frankly,
when
you
build
a
lot
of
storage
management,
a
lot
of
storage
systems
are
built
using
the
same
components
who
used
to
build
servers.
So
we
had
a
lot
of
the
stuff
we
wanted.
So
we
said
well
we'll
just
build
on
top
of
that,
we're
going
to
reuse,
literally
reuse.
Everything
swordfish
is
an
extension.
A
A
We
may
restrict
particular
pieces
of
it,
but
we
do
not
fundamentally
change
the
components.
Okay,
and
so
this
is
one
that
I
thought
you
guys
might
also
find
really
useful.
Since
you
know,
if
you
don't
have
any
exposure
to
this
kind
of
stuff,
you
know
seeing
you
know
who's.
This
is
a
list
of
who
is
currently
actively
participating
between
the
two
groups.
There
have
actually
been
a
whole
bunch
of
other
companies
kind
of
coming
and
going
from
working
on
this
stuff
at
various
points.
This
is
the
kind
of
the
current
list.
A
A
This
back,
there
have
been
I
would
say,
probably
I,
I'm
going
to
say
at
least
twenty
or
thirty
more
companies
that
have
actually
been
members
and
participating
and
contributing
that
have
been
on
this
list
at
some
points
that
have
dropped
off
or
and
there
when
I
was
creating
this
list
yesterday,
I
think
I
added
about
six
or
seven
new
companies
from
the
last
time.
I
updated
this
list
about
three
months
ago.
So
there's
a
lot
of
interest.
There's
a
lot
of
companies
that
have
been
participating.
A
A
Let's
see
there,
somebody
else
have
had
implementations,
one
more
I'm
spacing
have
had
implementation
since
about
2016
and
are
iterating
on
those.
So
there's
quite
a
bit
of
momentum
in
the
market
towards
this.
They
started
with
simple
implementations
and
have
been
driving
those
forward
I'm
talking
kind
of
fast,
that's
partially,
because
I've
had
a
fair
amount
of
caffeine.
This
morning,
partially
that's
just
my
normal
speed
but
feel
free
to
you
know
you
know
Brizzy
and
zoom
or
whatever.
A
So
swordfish
includes
you
know:
I've
already
mentioned
block
file
and
we
will
cover
object.
We
have
objects
drive
in
here
now.
It
will
be
really
easy
to
extend
to
object.
We
just
haven't
had
anyone
any
companies
step
up
to
say
we
will
do
the
detailed
modeling
for
that,
but
we
fully
intend
to
cover
object.
A
We
have
a
lot
of
interest
in
an
object,
but
not
to
the
extent
that
anyone
has
stepped
up
and
said
we'll
we'll
do
that
modeling
for
you
so
block
as
I
mentioned
provisioning
with
class
of
service
controls,
volume,
mapping
and
masking
replication,
you
know
capacity
and
health
metrics
pretty
much
everything
you'd
expect
in
a
complete.
You
know
full
a
full
API
set
and
file
system.
The
way
we
did
file
systems
is
actually
really
I.
Think
really
nice.
A
We
basically
took
the
block
and
said
it's
going
to
be
exactly
like
that,
except
with
just
two
new
schema.
On
top,
so
we
add
the
file
system
and
file
share,
so
it
is
identical
infrastructure
there's,
no
deviations.
It's
not
it's
not
a
divergent
model
at
all.
It
just
you'd
layer,
file,
system
and
file
share
on
top
of
it.
A
A
So
because
otherwise
the
boxes
are
really
small.
So
how
does,
though,
the
whole
thing
structured?
So,
as
I
mentioned,
we
we
start
with
redfish
and
there's
different
ways
to
do
rest.
The
this
model
uses
a
fixed
route
of
everything,
starts
with
flash
redfish,
slash,
B
1,
and
we
call
this
the
service
route
and
so
in
the
service
route,
a
server
is
broken
down
and
there's
actually
it's
gotten
a
little
more
complex
over
time,
but
that
basically
works
breaks
down
into
the
collections
which
are
think
of
these.
A
A
The
system
is
the
logical
view
of
the
system
and
the
chassis
is
the
physical
view
of
the
system.
You'll
see
some
things
in
there
they're
like.
Why
is
that
they're?
Just
how
a
committee
decided
it?
So
you
know,
that's
keep
that
in
mind
and
so
and
then
there's
a
set
of
services
over
here
so
session
service
account
service
event,
service
log
service,
there's
also
things
for
schemas.
There's
been
some
bunch
of
enhancements
around
tasks,
job
services,
privilege,
mapping
and
things
like
that.
A
So
you'll
see
a
whole
bunch
of
other
services
there
and
are
in
it
in
the
versions
today.
This
is
just
kind
of
a
relatively
simple
representation
and
then,
for
each
instance,
you'll
see
you
know,
collections
of
things
like
processors
and
my
things
got
truncated
here
for
some
reason:
processors,
disks
Nix.
Oh
the
kinds
of
things
you'd
expect
to
see
represented
in
a
in
a
system
and
then
as
chassis.
The
decision
was
made
to
make
you
know
power
and
thermal
collections
and
information
down
in
here,
so
that's
kind
of
how
a
systems
modeled.
A
A
This
is
really
kind
of
how
you
would
model
a
lot
of
things
like
an
external
storage
system
or
even
the
software-defined
storage,
where
you
have
all
of
this
stuff
down
here
would
be
you
know
the
physical
infrastructure
or
the
logical
infrastructure
that
you
would
host
your
host,
your
sort
stores
or
your
storage
system
on,
and
then
these
two
pieces,
the
purple
stuff,
is
all
of
the
new
sort,
fish
part
and
so
the
storage
system,
these
really
break
down
into
a
storage
system
and
a
storage
service.
So
a
storage
system
is
really
a
logical
system.
A
This
might
be
a
physical
controller
or
or
a
virtual
controller,
and
it's
modeled.
So
the
same
way
you
have
that
processor
down
here.
This
is
actually
a
logical
instance
of
a
system.
So,
instead
of
a
processor,
just
you
have
a
controller
and
disconnects
and
I'm
getting
a
notice
that
my
internet
connection
is
unstable.
So
let
me
know
if
I
I
start
seeing
a
problem
or
not,
and
then
but
really
the
core
of
swordfish
is
in
this
storage
service.
A
This
is
where
we
have
all
of
our
classes
of
service
that
we
talked
about
that
I've
mentioned
briefly
and
and
things
like
storage
pools
and
volumes
or
files
or
replicas
or
endpoints,
and
you
know,
volume
you
know
and
all
of
these
things,
which
is
really
when
you
go
to
manage
your
storage,
the
core
of
it,
and
so
again
these
are
collections.
So
you
can
have
multiple
instances
of
these
same
way.
A
You
can
have
multiple
controllers
and
I
said
I
mentioned
two
configurations
like
I
said
this
would
be
you
know
typical
external
storage,
or
this
could
be.
You
know
software
to
find
all
that
kind
of
thing.
I'm
waiting
at
my
screen,
which
you
can't
see
the
additional
one,
would
be
well
what
about
something
like
server
attached
or
JBoss,
or
something
like
that.
Well,
we
have
another
model
and
we
call
this.
A
The
integrated
service
configuration-
and
this
might
be
one
where
you
might
have
a
system
with
a
storage
controller,
and
then
in
that
it
you
know,
plugs
directly
into
a
system,
and
then
you
instantiate
a
storage
service
from
that,
and
so
then
we
have
this.
Basically,
this
alternate
model,
and
so
it's
a
stanch
it's
a
little
bit
more
simply,
but
where
you
have
kind
of
a
physical,
this
simpler
physical
storage
controller
model,
but
then
you
still
have
exactly
that
same
the
ability
to
instantiate
those
same
storage
services,
and
so
you
know
from
a
client
perspective.
A
You
know
in
either
model
they
may
or
may
not
be
interested
in
any
of
the
storage
system
or
source
controller.
Depending
on
what
their
use
cases
are.
They
may
only
ever
be
looking
at
the
storage
services,
but
these
are
you
can
see.
These
are
exactly
that
same
that
same
storage
services.
Okay,
any
questions
on
either
of
that.
Any
of
that
so
far.
A
A
A
Okay,
so
if
I
want
to
actually
look
at,
you
know
what
swordfish
things
might
actually
look
like,
we,
we
poke
the
the
twigs,
both
redfish
and
swordfish,
work
with
mock-ups,
and
we
publish
our
mock-ups.
These
are
all
just
static.
We
publish
our
a
bunch
at
swordfish,
mock-ups,
calm
and
so
you'll
see
them
at
swordfish.
Mock-Ups,
slash,
redfish,
b1,
someone
I'm
going
to
do
is
actually
switch
over.
My
slides
head
actually
has
a
few
samples
in
here
too,
but
what
I
was
going
to
do
since
a
lot
of
times?
A
So
if
we
go
over
here
and
it's
kind
of
tiny,
you
know
if
you
just
go
to
flush
right,
fish,
less,
be
one.
Here's,
basically,
what
a
service
route
might
look
like
you
guys
this
one,
so
you
can
see
you'll,
see
slash
systems
and
storage
systems,
storage
systems,
we'll
just
alias
to
the
sub
set
of
things
and
in
systems
that
are
store
systems.
This
is
kind
of
a
weird.
A
All
right,
no
text
that
copyright,
so
if
we
navigate
down
through
you,
can
either
kind
of
just
type
them
all
directly.
You
know
and
navigate
around
this
way
or
you
can
use
your
favorite
rest
client,
and
you
can
see
these
around
so
or
you
can
use
you
know
go
over
here
and
you
know
you
just
use
your
favorite
rest
clients.
The
mock-ups
are.
A
Alright
I'll
go
the
other
way
since
it's
clearly
working
over
here,
not
there,
but
we
can
just
kind
of
wander
around
through,
as
with
any
REST
API,
you
don't
actually
need
to
know
the
schema.
So
this
is
that
large
configuration
and
you
can
see
all
of
these
various
pieces.
So
what
I'm
actually
going
to
do
is
I'm
going
to
go
back
over
and
wander
through
the
ISC
configuration.
A
This
is
basically
a
server
attached,
storage
configuration,
and
this
is
the
storage
service
connected
to
it.
So
you
can
see
it
actually
shows
that
I
have
you
know,
classes
a
service,
defined
storage,
pools
volumes
and
drives
down
here
that
you
know
it
talks
about
capabilities.
What
these
capabilities
are
is
just
defines
what
capabilities
are
defined
in
this
service,
that
I
can
use
to
create
class
lines
of
service
and
then
eventually
classes
a
service.
A
A
I
have
two
classes
of
service.
What
what
I've
actually
got
configured
on
this
system
is
all
I
use.
Is
it's
a
very
fairly
simple
configuration?
What
I
use
for
classes
of
service
is
basically
I,
just
automatically
sort
my
pools
based
on
drive
types.
That's
all
I
did
in
this
particular
mock-up.
So
if
I
go
down
to
my
storage,
pools
it
basically
sorts
by
SAS
or
SATA
and
I've
named
them
that
way,
so
I've
got
a
fast.
A
You
know
a
cesspool
and
r5
raid5,
cesspool
and
SATA
pool
so
I've
used
underline
capabilities
of
my
system
automatically
configured
it
so
that
I
can
so
that
I
can
configure
which,
which
you
know
automatically
segregate
my
system.
So
you
know
that's
a
look.
There's,
no,
there's
a
lot
of
abilities
that
we've
got
mapped
into
classes
service.
This
is
one
that
to
me
was
just
fairly
obvious
is
like
you
can
take
something
that
you
know
the
system
is
already
capable
of
some.
You
know
some
policy
or
property.
A
A
A
Capacity
consumed
nope,
there's
no
space
left
in
this
pool,
so
I
can't
create
another
volume
there.
Maybe
the
other
pool
has
some
and
why
look
I
can
you
know
I
can
do
some
quick,
math
here
and
say
this
one
actually
has
some
space,
so
here's
I
can
use
this
pool
to
create
another
volume.
So
that's
how
you
could
actually
just
navigate
around,
depending
on
what
you're
trying
to
do
and
that's
just
kind
of
a
real
quick.
A
You
know
view
of
how
you
can
you
know
without
knowing
anything
about
the
system
you
could
move
around
and
actually
try
and
try
and
figure
out
something
really
quick
to
do.
Okay,
so
that's
that's
a
little
bit
about
about
swordfish
and
the
API,
even
a
little
bit
about
the
classes
of
service.
So
let
me
pop
back
out
of
that.
Any
questions
on
that
or
anything
you
guys
want
to
see.
I
can
tootle
around
a
little
bit
in
here.
If
there's
anything
specific,
you
want
to
take
a
look
at
it.
A
B
Shall
have
a
question
so
my
reason
is
back,
it's
not
clear
to
me
what
are
required
and
what
I'm
not
required.
So
you
for
anything.
Yes,.
A
Okay,
so
that's
actually
I
will
perfect
lead-in
to
my
next
section
here.
So
let
me
go
down
here.
So
one
of
the
things
we're
adding
in
there's
actually
multiple
places,
if
you,
if
you
just
look
at
the
schema,
there's
actually
very
little
required
and
and
the
spec
adds
a
little
bit
more
on
to
that,
but
the
way
the
real
way
to
figure
out
what
you,
actually,
what
you
actually
need
to
implement
is
through
what
we
call,
what
we're
calling
profiles
and
we're
we're
just
getting
to
this.
A
So
the
profiles
are
sets
of
required
functionality
based
on
features.
So
what
a
client
will
actually
do
is
say
you
know
what
what
features
do
you
support
and
we'll
advert
you
know,
applications
were
up,
implementations
will
advertise
features,
they'll,
say:
I,
support,
block
discovery,
events,
performance,
provisioning
and
you
know
basically
be
guaranteeing
that
and
then
the
actual
there's
there's
a
whole
profile.
Language
will
say
you
know
in
order
to
say
that
you
do
that.
Let
me
just
give
like
a
rooted.
This
discovery
example
that
basically
translates
to
for
that.
A
What
that
means
is
that
for
every
object,
you
support
debt
of
not
just
the
object,
but
every
property
on
that
object
and
then
for
those
configurations,
I
just
talked
about
for
HSC
or
the
IFC
configuration.
That
means
there's
a
specific
set
of
objects
that
you
will
support,
and
so
you
support
get
on.
A
You
know
a
storage
service,
a
storage
pool
volume,
level,
blah
down
the
list,
and
so
there's
some
set
of
those
that
you
not
only
have
to
have
you
know
if
you
have
that
object.
You
have
to
support
this
so,
like
you
have
to
have
a
volume
collection.
Now
it
doesn't
mean
you
have
to
have
any
volumes
created
yet,
but
you
have
to
support
having
them.
You
have
to
support
the
ability
to
create
them
that
makes
sense
and
then
so
for
basic
provisioning.
You
have
to
support,
doing
posts
and
deletes
on
that
volume
collection.
A
For
so,
if
you
say,
I
support
basic
provisioning
on
block,
you
have
to
support
post
and
elite
on
a
blonde
blonde.
The
volume
collections
you
have
to
support
being
able
to
create
you
know
so,
there's
a
hierarchy
there,
but
that's
that's
how
that's
how
we
both
advertise,
that
and
and
that,
so
the
client
could
come
in
and
say
what
do
you
support?
A
What
is
this?
What
is
this
implementation
support
and
it
says
I
support
basic
provisioning
for
block.
Then
you
know
that
that's
going
to
mean
that
the
implementation
is
guaranteeing
that
you'll
be
able
to
allocate
volumes
and
so
there's
a
whole.
You
know
hierarchy
of
stuff
that
the
client
that
the
implementation
actually
doing
behind
the
scenes,
but
that's
that's
how
you
basically.
A
What
we've
this
is
something
we
learnt:
we've
we've
gotten
a
lot
of
feedback
from
our
clients
over
the
years.
Sm
is
had
profiles
as
well
and
would
advertise
them,
but
I
think
the
count
was
a
hundred
and
eighty
some
profiles
that
they
would
advertise,
and
so
what
we're
trying
to
do
is
move
to
this
much
simpler
model.
That
says
we
advertise
right
now.
You
can
see
my
current
proposal,
and
this
is
the
proposed
that
I
should
I
should
put
a
disclaimer
on
this.
A
This
is
the
proposal
we're
about
a
month
away
from
having
having
a
whip.
Go
out.
Working
progress
go
out
that
defines
all
of
this.
That
says
what
we
will
advertise.
You
know
this
matrix
of
blah.
You
know
these
services
with
these
fees
features
I'm
willing
to
start
it
at
this
list
of
about
eight.
It
will
probably
grow
from
there
and
then
you
know
this
maps
to
you
know
the
details
of
the
you
know:
exact
objects
for
the
various
configurations.
A
Hope
so
yeah
we're
we've
been
Philip.
How
long
have
we
been
discussing
the
profiles
and
approach
since
about
January
and
I?
Think
we?
We
hope.
We
hope
that
we're
we're
putting
together
some
some
presentations
and
some
alignment
around
it.
Now
that
we
we
should
have
the
whip
of
the
concepts
and
everything
we're
trying
to
get
that
done
this
month
and
have
that
out
before
SGC
and
then
we'll
need
to
be
developing
the
tools
to
to
validate
all
of
that.
C
B
C
B
C
So
the
classes
of
classes
of
services,
what
would
be
used
for
determining
storage
scheduling,
right,
trying
to
figure
out
placement
and-
and
you
know
what
what
the
services
that
our
customers
asking
for
on
a
provision
request
right,
whereas
profiles
are
just
identifying,
you
know
what
features
and
capabilities
the
device
is
capable
of
handling
right.
There's
a
slight
difference
between
the
two
okay.
A
Okay,
yes,
the
class
of
service
stuff
is
all
has
been
defined
for
quite
a
while.
The
the
profiles
we
have,
the
the
profile
language
and
then
it's
the
feature
set,
is
we're
trying
to
lock
down
right
now
in
the
feature
set
and
then
map
between
the
future
said
and
the
profile
definition.
So
the
profile
definition
will
be
kind
of
the
provider
side
and
the
features
I.
The
future
definition
side
will
be
what
we
advertise
to
the
clients
and
that's
really
separate
from
the
class
of
service
stuff,
yeah.
C
And
I
think
that's.
The
distinction
is
that
the
class
of
service
stuff
is
really
around.
You
know
if,
if
I
got
a
CSI
request
for
a
particular
volume
of
a
particular
set
of
characteristics,
I
would
use
the
class
of
service
to
figure
out.
You
know
where
I'm
gonna
place
that,
whereas
the
profile
is
kind
of
identifying
what
this
particular
swordfish
implementation
is
capable
of
doing
right
am
I,
correct.
A
A
A
Okay,
let's
see
so
the
other
thing
I
wanted
to
kind
of
show
is
a
little
bit
about
the
tools
and
infrastructure.
I
mean
I,
showed
the
mock-ups
right,
so
we
have
the
mock-up
site.
The
other
thing
I
wanted
to
kind
of
show
us
a
little
bit
about
some
of
the
stuff
we
have
developed
so
folks
can
go
and
play
because
that's
really
what
we
all
want
to
do
right.
So
one
of
the
things
we
have
so
that
you
can
actually
go
play
with
sort
fishes.
We
have
a
swordfish
emulator.
A
So
the
and
these
are
we
have
four
basic
set
of
tools
here,
so
one
of
which
is
the
emulator.
You
can
get
that
at
github
on
our
open
source,
github
site.
It
extends
the
redfish
emulator.
The
redfish
emulator
is
not
fully
dynamic,
but
the
starfish
emulator
actually
is
so
I
have
an
instance
of
the
emulator
here
and
I'm
it.
You
can
basically
do
put
the
patches
posts
and
everything
it's
not
intelligent.
A
It's
not
going
to
be
able
like
a
real
system,
but
you
can,
you
know,
manipulate
it
quite
quite
a
bit
and
one
of
the
things
we've.
Actually
we
actually
have
going
on
is
we
have
a
researcher
down
at
Texas
Tech
who
has
taken
and
is
building
a
virtual
data
center
in
containers,
and
they
are?
We
they'll
have
that
on
display
at
SDC
and
we
hope
to
have
an
instances
that
stood
up
soon
in
our
Tech
Center
and
our
this
Nia
techs
are
as
well
but
they're
hoping
to
build
an
emulated
scale
out.
A
Data
center
with
you
know,
large
scale
storage
system,
so
they'll
have
both
ISC
configurations
as
well
as
HSC
style
systems
and
have
some
you
know,
small,
a
bunch
of
small
configurations
as
well
as
some
extremely
large
emulated
storage
configurations.
So
some
with
you
know,
multi-thousand
volume
multi.
You
know
hundreds
of
thousands
of
drives
thousands
of
volumes,
kinds
of
systems
in
containers,
so
simulating
a
you
know
very
large
data
center
data
centers
all
built
using
the
emulators,
and
so
that's
that's
available
works
reasonably
well.
We've
been
finding
and
fixing
bugs,
but
it
is
available.
A
We
also
have
the
swordfish
web
client,
which
I
had
started
on
my
system
and
now
I
don't
see
the
thing
for
so
give
me
one
second
I
will
and
the
other
one
that
I
wanted
to
show.
Is
we
have
these
two
sample
integrations
we
built
just
to
give
people
kind
of
a
sense
of
the
things
you
could
do,
and
so
one
of
the
ones
going
to
show
I'm
just
going
to
show
the
power
bi
one,
because
I
have
that
up
and
running
on
my
system.
We
basically
built
two
different
dashboards.
A
A
Sam
cam
start
I'm,
sorry
charting
the
basic
web
plan
up
well,
I'm,
not
it
the
power
bi.
Basically,
this
isn't
sorry.
I
don't
have
this
loaded
completely.
This
is
the
working
pain,
but
the
power
bi
dashboard
kind
of
a
point-in-time
snapshot.
So
what
we
built
here
was
basically
a
this.
This
view
basically
shows
kind
of
a
what
what
you
might
want
to
look
at
from
a
point
in
time.
So
this
one
basically
built
talking
to
emulators.
We
have
all
the
documentation.
So
it's
how
you
can
either
recreate
this
one.
A
You
can
basically
bring
this
one
up
and
just
change
it
or
you
can
documentation,
tells
you
how
to
recreate
it
completely.
What
this
one
does
is.
It
was
talking
to
an
emulator
that
had
four
storage
services
on
it
and
you
know
just
a
snapshot
view
of
you
know:
what's
the
consumption
capacity
consumption
across
them,
and
then
it
has
these
sub
dashboards
of
the
various
storage
services,
and
so
if
we
go
look
at
one
of
those
sub
dashboards,
what
you
get
here
is
you
know,
kind
of
a
drill
down
into
that.
So
you've
got
here's.
A
The
number
of
storage
pools
and
file
systems,
and
this
one
because
this
was
file
service-
some
consumption,
you
know-
could
utilization
across
the
file
systems
and
storage,
pools
this
again
more
capacity
information,
and
then
you
can
actually
go
drill
down
into
into
that.
And
then
one
of
the
things
that
swordfish
has
is
a
threshold
user,
several
thresholds,
and
so
this
actually
shows
these.
This
one
had
them
set
at
60
and
90.
A
You
can
so
it
it
has
an
overlay
of
these,
so
you
can
just
kind
of
see
where
these
are
across
this
particular
this
across
this
particular
files
file
system
has
hit
either
abuse,
but
this
one
has
weird
data
on
it:
loaded,
weirdly
and
but
you
can
see
you
know
if
it
hit
one
in
the
middle,
it
would
show
the
overlay
there
in
data
dog.
What
we
actually
have
is
the.
A
It's
a
trending
over
time,
so
we've
used
the
same
kind
of
data.
This
is
just
a
point
in
time.
Snapshot
see
you've.
Actually,
we've
actually
done
is
built
up
some
some
trending
over
time.
You
know
capacity
triggers
so
and
integrations
that
people
can
use
out-of-the-box
and
their
sample
code
for
all
of
these
online.
A
A
So
I
can
modify
properties.
Let
me
go
into
it
actual
objects
and
modify
its
properties.
So
I
go
down
here
and
I.
Can
you
know
rename
things
so
it's
a
basic
client
just
sorts
things
out,
but
makes
it
a
little
bit
easier
to
look
at
look
at
systems
rather
than
navigating
to
rest
clients.
These
are
just
kind
of
tools
to
help
people
get
started
and
play
around
with
with
the
systems.