►
Description
Presented by: Yuval Lifshitz
Full schedule: https://pad.ceph.com/p/ceph-month-june-2021
A
So
what
do
we
do
with
lua
in
with
lua
and
seth?
I
always
like
to
start
from
this
awesome
slide
from
sage
saying
what
is
seth
and
one
of
his
definitions
is
seth
is
an
open
source
and
free
tool
and
so
on,
and
I
would
like
to
and
run
in
command
hunter
and
so
on.
This
is
a
great
slide,
but
I
would
like
to
dive
a
little
deeper
into
those
definitions.
A
It's
freaking
lock-in,
so
bring
your
own
device
and
it's
free
to
change.
So
this
is
the
the
essence
as
being
an
open
source,
but
there's
a
little
slightly
a
small
disclaimer
here,
because
ceph
is
also
a
2.5
million
lines
of
code
of
c
plus,
plus
with
lots
of
moving
parts,
lots
of
game
and
lots
of
dependency
and
well.
Although
anyone
in
theory
can
go
on
hop
on
on
the
github
repo
and
make
their
own
modifications
and
enhancements
and
so
on
to
the
project,
they
usually
don't
do
that.
A
So
some
of
the
users
of
ceph
are
big
corporations
that
have
advanced
development
tools,
develop
development
teams
and
they
actually
do
do
this
work,
but
not
all
of
them
and
not
all
of
them
has
professional
super
flat
developers
and
not
all
of
them
are
actually
daring
to
make
those
changes
so
to
try
and
and
kind
of
pave
the
way
for
these
guys
to
participate
more
and
allow
them
to
do
more
tweaks
into
ceph.
We
also
do
things
that
really
opens
seth
to
the
world,
not
just
open
source
but
really
open
staff.
A
What
do
we
do
then?
So
a
couple
of
things-
and
this
is
those
are
all
things
that
already
in
in
cef
and
and
radio
skate
when
the
other
things
and
we
have
object
classes
or
what
we
call
cls.
Those
are
c
plus
plus
code,
but
those
in
in
confined
environment
that
you
can
inject
into
the
osd
and
run
them
there
and
that's
going
to
be
much
easier
than
actually
changing
the
code
of
the
osd
and
especially
it's
built
for
all
kind
of
enhancements
and
tweaking
and
so
on.
But
this
is
still
simple.
A
You
can
also
inject
lua,
and
this
is
something
already
existing.
So
you
can
inject
lua
object
classes
to
run
inside
the
cls,
and
this
also
opens
up
a
whole
bunch
of
applications
and
capability.
There's
a
great
talk.
You
can
check
it
out
on
youtube
from
no
watkins
about
how
to
do
the
the
lu
object
classes.
A
So
why
is
it
important?
Well,
we
provide
infrastructure
to
do
storage,
but
the
people
that
interact
with
us
their
applications
and
quite
often
we
cannot
envision
upfront
everything
that
those
applications
need,
and
sometimes
they
need
very
special
integration
points
or
special
behaviors
that
we
cannot
provide,
or
it
will
take
us
lots
of
time
to
provide
and
or
we
don't
even
want
to
provide
because
they're
like
ad
hoc
integrations
and
so
on
and
behaviors
that
we
don't
really
want
to
change.
A
So
why
did
I
choose
lua?
It's
a
mature
and
powerful
language.
So
it's
not
like
a
toy
language.
It's
been
there
for
a
long
while
and
has
lots
of
libraries,
and
you
can
do
lots
of
stuff
with
it.
It's
easier
to
learn,
and
this
is
because
well
maybe
not
many
people
know
lua
as
language,
but
the
learning
curve
is
very,
very
steep.
I
mean
very,
very
easy,
so
it
will
take
you
very
small
amount
of
time
to
actually
get
a
grasp
of
the
language
and
do
stuff
in
it.
A
It's
lightweight,
which
means
that
you
can
spin
a
lua
vm
without
with
almost
no
cost,
which
means
that
if
you
want
to
handle
different
contacts
at
the
same
time,
you
don't
need
to
have
complex,
locking
and
concurrency
mechanism.
They
just
spin
multiple,
lower
vms
and
hvm
handles
their
own
contacts,
their
own
request,
their
own
flow
of
things
that
they
need
to
handle,
and
this
doesn't
have
a
lot
of
overhead,
so
you
can
spin
them
up,
kill
them
and
have
many
of
them,
and
that
would
not
impact
your
overall
performance
significantly.
A
It
has
very
efficient
integration
with
cnc
plus
plus.
This
was
the
actual
intent
of
it
and
the
the
idea
is:
there's
no
complex
marshalling
and
new
margining
when
communicating
between
lua
and
c
or
c,
plus,
plus
everything
is
either
basic
types
or
just
pointers
to
structs.
So
this
is
not
a
reason,
and
it's
already
nsf
it's
in
the
object
classes,
it's
in
the
in
in
cfs
and
and
in
in
other
places,
early
reason.
Why?
Not
because
it's
not
a
very
common
language,
but
it's
easy
to
learn.
A
So
I
didn't
feel
that
this
is
a
good
enough
reason
for
not
using
it
key
concept
in
what
we're
trying
to
achieve
here.
So
the
our
users
are
not
programmers.
This
coming
back
to
the
first
thing
that
we
don't
want
this
the
whole
thing
to
be
complex.
We
want
to
expose
simple
apis
that
anyone
that
really
used
to
to
write
something
like
python
code
or
something
like
that
can
easily
grasp
and
use
want
to
enhance.
A
We
want
to
hide
the
internal
structures
and
keep
the
api
consistent.
So,
even
if
the
underlying
c
plus
code
changes,
the
apis
are
the
same
and
the
apis
should
reflect
something
that
is
meaningful
for
the
business
purposes
and
not
necessarily
our
internal
structures,
zero
copy
everything,
all
the
complex
structures
that
we're
exposing
is
all
pointers
that
we're
exposing.
We
don't
copy
anything
and
zero
install,
which
means
that
we
are
providing
already
built-in
hooks
into
the
lure
packaging.
So,
if
you're
dependent
with
other
loot
packages,
we
already
have
the
mechanisms
to
do
that.
A
A
My
clients
don't
send
some
metadata
that
I
need-
and
I
need
this
metadata
to
have
some
specific
value
under
some
conditions,
for
the
rest
of
my
mechanisms
to
work,
and
if
I
cannot
change
the
clients
and
let's
say
I'm
a
support
engineer,
then
I
have
a
problem,
and
here
is
an
example
of
how
luke
can
preach
this
club
this
problem,
so
I
write
a
simple
line
of
code.
It
runs
in
the
context
of
the
request.
We
have
different
context,
but
this
is
just
one
example.
A
A
So
as
you
see
you
don't
need
to
create
local
variables,
you
don't
need
to
new
or
allocate
or
do
anything
it's
just
there.
The
request
is
just
there
existing
in
the
context,
so
it's
easy
to
understand
what
we're
dealing
with
and
you
don't
need
to
do
any
boilerplate
coding
in
order
to
get
the
request.
A
A
The
as
I
said,
everything
is
just
pointer
under
the
hood
now
when
you,
when
you
want
to
modify
stuff,
as
in
this
example,
lua
has
those
mechanisms.
So
here
again
I'm
not
copying
anything
except
the
string,
my
value
into
this
new
metadata
field.
Under
the
hood,
there
are
already
data
structures
that
hold
those
maps
and
so
on,
but
I
don't
need
to
copy
them
around.
I
just
need
to
traverse
the
point
of
traverse,
destructs
and
then
put
the
value
in
just
just
copying
this
value
into
the
right
place.
A
And
the
syntax
like
just
makes
sense,
so
anything
that
makes
sense
to
be
a
map
has
a
syntax
that
looks
like
a
map
where
you
have
brackets
and,
and
you
can
look
up
via
strings
and
other
things,
don't
have
this
syntax.
So
once
you
look
at
the
reference
manual,
then
you
should
immediately
understand
how
things
work
without
understanding
anything
about
the
underlying
data
structures.
A
Next
steps.
So
we
want
to
expose
the
content
of
the
data
emoji
in
lua.
That
would
allow
a
lot
of
applications
and
integrations
and
all
kind
of
things
that
that
could
work
there.
That
could
be
like
compression
options
or
breaking
objects
into
smaller
objects
through
some
logics
and
so
on
and
so
forth.
A
In
this
case,
the
nats
message,
bus
endpoint,
that
we're
gonna
expose
through
lua,
because
it
doesn't
justify
us
to
add
this
as
a
proper
endpoint
in
c
plus
plus,
but
for
the
purpose
of
an
anaholic
integration
or
demonstration.
It
is
ideal
and
of
course
the
whole
thing
is
opening
up
the
the
options.
So
any
ideas
for
use
cases
and
requirements
that
we
can
achieve
by
this
low
integration
almost
more
than
welcome.