►
From YouTube: zbus Fearless IPC for embedded Linux is finally here
Description
D-Bus is a popular IPC mechanism used by various services on most desktop and many embedded Linux systems in the wild. It is heavily used by even the most essential services, such as systemd. Unfortunately, in the Rust world, there is only one D-Bus crate that is in a usable state and most users are not happy about it for various reasons, most notably that it depends on a notoriously bad C library. zbus, was created out of this demand for a pure Rust API that makes D-Bus easy and simple. With both elegance and efficiency as the top goals, the development of of zbus has been a much greater challenge than original anticipated but slowly they were all overcome.
Recently, zbus has actually started to take a good shape, with the foundational code already released and zbus nearing it’s first release. In this talk, I’ll go through all major challenges faced during the development of zbus and the solutions chosen, and give an overview of how one can make use of zbus.
A
Hello,
can
you
hear
me
there
we
go
yeah
now
we
can
hear
you
cool
great
welcome,
thanks
for
having
me
yeah
and
thanks
for
joining
on
such
short
notice.
We
had
a
speaker
fall
ill,
unfortunately,
and
I'm
so
glad
we
were
able
to
have
you
join
us.
So
thank
you
so
much
on
short
notice
for
putting
this
together.
I
think
with
three
days
notice,
so
super
super
huge
thanks
from
us
for
putting
this
talk
together
so
quickly.
B
B
B
B
We
have
a
great
goal
for
creating
a
generic
solution
for
edge
to
cloud
machine
vision,
solution
check
out
our
website
lumia.com
for
more
details,
if
you're
interested
in
that
and
we're
doing
a
lot
in
rust
by
the
way
so-
and
I
have
my
background-
is
in
free
and
open
source
software
both
desktop
and
embedded.
Mostly,
I'm
not,
I
don't
know
anything
about
web
stuff.
So
when
I
need
to
do
anything
web,
I'm
I'm
lost
but
desktop
and
embedded.
B
These
are
things
I
know
and
I
have
a
lot
of
experience
with
them
and
flying
I'm
into
flying.
I
have
licenses
and
stuff,
and
I
have
I
love
cats.
I
have
three
cats
now
so
a
bit
of
background
story
for
the
talk.
I
I
have
a
service
called
geoclue
and
I
wanted
to
oxidize
it
right
for
for
multiple
reasons:
it's
what
it
is.
It's
a
geolocation
service
and
it
uses
dbus
for
for
ipc
and
it's
written
in
c.
A
B
B
Yeah,
it's
back!
Okay,
sorry
about
that.
Okay!
So,
as
I
said,
it's
used
by
many
projects,
especially
on
linux,
systemd
uses
it
heavily
by
genome
and
kd
uses
it,
and
there
was
also
an
attempt
to
put
it
in
the
kernel
itself.
So
it's
that
important,
at
least
for
linux.
So
I
was
like
okay.
I
need
to
use
dbus
because
my
service
is
a
debus
service,
so
I
created
a
create
for
it.
Sorry
I
I
thought
like
there
must
be
a
crate
for
it
right.
B
B
So
I
was
like,
let's,
let's,
let's
look
at
what
it's
involved
right
and
and
we
can
see-
and
I
look
at
I-
I
pull
out
the
spec
and
I
checked
and
and
on
low
level,
it's
just
message
passing
and
and
there's
a
wire
format
for
for
that
and
to
encapsulate
your
different
types
of
data
into
forever
device
and
it's
also
called
g
variant.
Although
g
variant
is
actually
a
different
version
of
it,
it
has
tiny
differences
to
to
debus
wire
format,
but
those
differences
actually
mean
a
lot.
B
So
it's
it's
not
like
easy
to
switch
anyway.
We'll
talk
a
bit
more
about
that
later,
but
it's
it's.
This
format
is
used
a
lot
and
g
variant
is
used
outside
dbus
for
for
easy
database,
storage
and
stuff,
and
it's
it's
actually
more
efficient
than
the
device
itself,
the
deepest
format
itself
and
what
it
describes.
B
This
fact
is
that
the
different
data
types
and
and
their
encodings
and
their
padding
and
stuff-
and
they
map
very
nicely
to
rust,
rust
types
right,
so
that
was
that
was
really
encouraging
and
on
the
high
level,
it's
just
a
bit
of
object-oriented
programming
without
any
inheritance
or
any
of
the
other
controversial
parts
of
object-oriented
programming.
So
it
has
simply
objects
which
are
just
instances
which
provide
the
actual
api
different
kinds
of
api
on
them,
and
they
the
the
way
they
provide.
The
api
is
through
something
called
interfaces.
B
The
interface
provides
you,
the
the
methods,
I'm
putting
out
some
example
from
a
real-world
examples
in
there
they're
just
like
programming
languages,
methods
right
in
programming,
languages,
libraries
and
signal
signal
is
just
a
method
call,
but
it's
a
broadcast.
So
it's
it's
like
an
event,
a
broadcast
and
properties
which
is
just
you
know,
fields
in
a
struct,
for
example.
Just
just
like
that,
so
I
was
like.
Actually
it's
not
that
really
hard.
B
So
I
was
like
let's,
let's
just
do
it
right
so
so
I
started
this
project
called
bebus,
cool
name
right,
so
so
yeah
and
but
before
I
start,
I
have
to
come
up
with
goals
first
and
then
I
have
a
bit
of
focus
on
what
what
to
focus
on
what
are
the
priorities
and
stuff
and
the
goals
are
true.
One
is
easy:
the
device
rs
wasn't
easy
to
use.
It
wasn't
easy
to
even
find
out
how
to
use
it.
B
So
that's
was
the
top
goal
to
have
it
as
easy
as
possible
and
also
efficient
device.
Rs
is
pretty
efficient,
but
I
think
it's
uses,
as
I
said,
lib
debuss,
so
it's
limited
by
how
efficient
can
it
be
because
of
that?
As
far
as
I
know,
but
in
any
case
let's
say
that
libra
stars
is
extremely
efficient,
so
I
wanted
to
have
the
same
goal
as
well,
but
first
things.
First,
I
wanted
to.
It
was
a
I
wanted
to
write
a
pure
rust,
debuss
library
from
scratch.
B
So
the
first
thing
is:
if
you
go
from
a
bottom-up
approach,
you
have
to
first
implement
api
for
the
wire
protocol
and
the
encoding
of
data
and
stuff,
and
for
that
I
created
like
a
separate,
create
called
z-variant
and
because
the
point
is
that
in
future
I
will
also
support
g
variant
format
and,
as
I
said,
that
is
used
also
outside
dbs.
So
people
will
find
this
useful
to
be
used
outside
of
device
spent.
Several
months
tried
different
approaches
and
there
was
like
failures
on
many
many
things
like.
B
I
would
have
like
a
lot
of
progress
and
then
I'll
realize.
Oh,
this
particular
thing
doesn't
work
and
I'll
mention
one
of
those
later
the
biggest
problem
that
I
had
and
a
lot
of
fun
with
lifetimes,
because,
as
I
said,
efficiency
was
a
goal
and
also
fighting
with
ebay
spec
itself.
So
some
of
the
things
were
not
like
specified
very
clearly
that
requirements,
so
it
was
a
bit
of
a
fight.
Unfortunately,
you
can
easily
test
it.
B
As
I
said,
it's
used
so
much
that
you
have
a
lot
of
test
cases
out
there,
so
you
can
make
calls
and
find
out
like
if
you're
doing
it
the
right
way.
But
finally,
we
had
a
1.0
release
that
was
beginning
of
this
year.
I'm
sorry
dry
throat
and
much
like
there
was
a
lot
of
celebrations,
but
then
I
realized
that
I
I'm
not
dealing
with
empty
areas
like
it's
impossible
with
the
api
that
I
created
to
to
do
empty
arrays.
B
So
I
have
to
rethink
what
about
certain
that
was
actually
one
of
the
first
bugs
that
was
filed
on
on
zebus.
This
was
about
fire,
you
know
choosing
saturday,
and
that
was
a
good
question
and
I
actually
looked
at
sergey
from
the
beginning
like
when
I
just
started
off,
but
the
thing
is
like,
as
I
said
like
I
I
was
not
familiar
with.
I
was
familiar
with
d
bus
as
a
user,
but
not
the
spec
itself.
B
So
I
was
already
fighting
with
this
pack
and
I
was
learning
a
lot
of
new
things
and
I
wasn't
that
experienced
with
rust,
especially
when
writing
a
crate
and
especially
efficiency,
is
the
goal
and
all
these
goals.
So
I
was
already.
I
was
already
having
a
very
hard
goal,
and
I
was
doing
this
all
in
my
spare
time,
so
I
didn't
want
to
learn
nausea
as
well
as
a
user.
B
Certainly
it's
pretty
easy,
but
as
an
implementer
of
the
serializers
and
deserializers,
it's
not
super
trivial,
so
I
didn't
want
to
get
into
that
and
also
it's
not.
It
hasn't
been
the
best
for
binary,
so
binary
protocol.
So
that
was
also
the
reason
but
anyway,
since
that
I
I
ca,
I
didn't
succeed
in
coming
with
a
good
api.
I
was
like
okay,
let's,
let's
give
it
a
go,
so
I
spent
a
few
more
months
on
this.
B
I
was
able
to
do
it
and
we
we
had
to
have
a
bit
of
a
like
the
serializer
and
dcalyzer
api.
We
have
is
not
the
most
usual.
You
have
to
pass
one
more
requirement
for
it.
Let's
we'll
talk
about
that
in
the
example
code
and
so
yeah.
This
is
the
serde
server-based
new
api,
which
is
the
the
2.0
oh,
and
please
ignore
the
last
line.
B
It
looks
very
normal,
but
you
will
see
that
one
of
the
differences
that
you
are
passing
a
context
which
we
need
because
it
could
be
different
formats
like,
as
I
said
like
in
future,
we
will
have
the
variant,
so
you
need
to
specify
which
format
and
also
the
byte
encoding.
So
that's
not
implicit
in
diversity.
It's
it's
not
in
the
in
the
protocol
that,
in
the
on
the
on
the
wire,
it's
not
specified
what
proto,
what
byte
order
is
being
used.
B
B
I'm
sorry
the
data
you're
passing
for
and
for
encoding
it
doesn't
have
to
just
implement
serialize
or
deserialize
traits
of
certain,
but
it
also
has
to
implement
one
more
trait,
which
is
a
very
simple
trait,
but
you
have
to
provide
it
because
dbus
uses
something
called
a
signature.
Each
data
that
is
that
goes
on
dbus
has
a
signature
which
is
a
string
describing
the
data
types
and
yeah.
I
cannot
serialize
and
decelerate
without
that.
B
So
that
is
why
you
have
one
more
requirement,
but
we
provide
a
macro
to
to
implement
that.
So
you
don't
have
to
worry
about
that.
So
for
most
types
you
just
use
the
macro
and
we
will
do
the
handling
for
you.
So
it
says
in
general
it's
as
simple.
As
usual
said
the
workflow
I
am
I'm
hoping
you
agree.
So
back
to
t
was
right.
The
progress
were
very
slow.
I
was
so
busy
like
the
time
I
had.
B
I
was
spending
all
on
all
of
it
in
c
variant
itself,
so
the
dbus
was
just
about
sending
a
method
call
and
stuff,
and
that
was
it
and
around
the
same
time
I
found
out
that
there's
a
lot
of
new
people
writing
divas
crates.
It
became
a
fashion
a
few
months
ago
and
I
was
really
surprising
and
I
didn't
I
don't
know
what
happened.
I
don't
know
if
they
saw
my
talks
or
or
what
but
people
got
inspired.
B
B
Who
knows,
but
all
I'm
saying
is
that
if
you
come
up,
if
you
want
to
work
on
dbus,
please
first
consider
helping
me
out
on
zebus
and
if
you
don't
like
the
approach
or
whatever,
and
we
can
talk
right,
if
you
don't
like
the
approach,
you
can
tell
us
what
you
don't
like
about
yeah.
Maybe
we
can
change
it
to
how
you
like
it,
and
then
we
can
help
each
other
out,
if
not,
of
course,
you're
free
to
do
whatever
you
want
yeah.
B
So
that's
a
bit
of
a
request,
but
talking
of
helping
me
out
a
an
old
friend
a
few
months
ago
that
came
to
a
rescue,
his
name
is
mark
andrew.
We
go
way
back.
We
have
been
colleagues
multiple
times.
We
have
worked
on
same
projects
multiple
times.
It's
it's
our
destiny,
to
work
on
working
with
each
other,
so
yeah
he
needed
divas
for
something
in
rust.
B
We
also
had
a
lot
of
disagreements
like
when
I
say
a
lot.
I
mean
a
loss,
but
mainly
they
were
about
owned
versus
unowned
and
his
use
cases
don't
require
unowned,
deserialization
and
stuff,
and
that's
typically
hard
to
implement,
like
that
was
one
of
the
challenges
for
me
and
zero
in
any
way
to
to
to
encode.
But
I
want
this
crate
to
be
useful.
B
Not
just
on
the
desktop,
but
also
on
embedded
systems
out
there,
so
I
want
to
I
wanted
to
be,
as
I
said,
efficient
and
you
have
to
provide
an
un
owned,
deserialization
and
stuff.
If
you
wanted
to
be
as
efficient
as
possible,
so
yeah,
we
had
disagreements
on
that,
but
ultimately
we
figured
it
out,
and
now
we
have
all
essential
api
all
already
in
place
the
z
bus
create,
and
how
does
it
look
like?
B
Let's
see,
let's
start
from
the
bottom,
like
we
have
low
level
high
level
api,
the
low
level
api
is
also
already
very
simple.
If
you
look
at
it,
you
just
create
a
connection
in
dbs.
You
have
like
typically
two
main
connections
available
on
your
machine.
One
is
the
system,
one
which
is
for
global,
and
one
is
the
session
one
which
is
per
user
usually,
and
you
create
the
connection
to
that.
B
You
just
then
say
which,
which
service
you
want
to
call
a
method
on
which
which
object
you
want
want
it
on
and
which
interface
it
is
and
which
the
name
and
all
the
arguments.
And
then
you
get
back
the
arguments
right
and
then
you
can
parse
it.
As
you
can
see,
this
is
actually
a
real
world
example.
You
can
use
it
to
light
up
the
brighten
up
the
screen
of
your
of
your
laptop.
B
If
you
want
to
try
it
out
and
it's
also
an
examples
directory
and
and
are
created
in
our
repo,
so
you
can
use
it
pretty
easy
already,
as
you
can
see,
but
that
was
a
very
simple
interface.
So,
but
when
you're
dealing
with
a
complex
interface,
we
have
to
do
a
bit
better
and
we
have
to
provide
a
better
api.
So
we
go
to
the
high
level
api
that
we
provide
also-
and
we
use
macros
with
that.
B
We
have
a
separate,
of
course,
create
for
macros,
as
you
normally
have
to
zbus
macros,
but
we
re-export
it.
So
you
don't
have
to
worry
about
that.
You
can
and
we
recommend
that
you
use
the
macros.
You
don't
use
the
api
directly
without
macros,
it's
it's
cumbersome,
it's
complicated,
so
yeah
just
just
use
the
macros
to
declare.
So
this
is
the
client
side.
You
declare
the
interface
like
just
like
a
trade
and
once
again
ignore
the
last
line.
B
Sorry,
and
this
will
display
a
notification
on
your
desktop
linux
based
desktops
up
there
and
server
side
is
also
very
simple.
You
create
an
implementation,
just
like
you
implement
a
type
and
you
use
the
macros
to
to
tell
it
which
interface
it
is.
You
can
also
declare
the
default
object,
path
and
stuff
and
then
to
use
it,
you
just
create
something:
we
call
object
server
and
then
you
can.
B
You
can
host
multiple
interfaces
on
the
same
object
as
actually
I
didn't
say
it,
but
each
object
can
have,
can
support
multiple
interfaces
and
they
are
dynamic.
So
an
object
can
have
like
an
interface
at
a
specific
time
and
then,
after
a
while
it
yeah
it
doesn't
so
it's
called
pretty
dynamic.
But
in
any
case,
we
you
declare
it
here
that
okay,
now
from
now
on
you,
you
have
this
interface
and
you
just
serve
it.
B
You
just
you
can
loop
it
and
we
we
handle
all
the
incoming
messages
in
this
loop,
still
not
easy
enough.
If
you
think
we
also
provide
xml.
So
the
debug
interface
pro
has
a
specification
like
for
for
describing
your
api
in
a
language
neutral
way
and
that's
xml
spec.
So
we
provide
you
a
way
to
translate
and
you
can
introspect
services
right.
You
can
ask
them
like
give
me
your
a
description
and
it
gives
you
the
xml.
So
we
automatically
do
that
for
you.
B
So
if
you
implement
the
service
through
our
macros,
we
will
deal
with
the
introspection
request
from
the
client
for
you.
So
you
don't
need
to
worry
about
that
and
also
we
have
a
helper
to
for
when
the
first
time
you
we
want
to
create,
for
example,
the
client
code,
you
you
don't
want
to
do
it
all
manually.
You
first
want
to
use
this
helper
to
create
the
code
for
you
and
then
you
can
adjust
as
you
as
you
want,
but
yeah.
B
It
helps
you
out
to
create
the
code
and
the
first
time
and
we
have
a
book-
it's
not
a
big
book
but
for
now
at
least
it's
a
small
one,
but
we
have
like
right
sample
examples
and
I
help
you
go
through
the
api
step
by
and
yeah
check
it
out
and
let
us
know
if
you,
if
there's
something
missing
or
if
it
can
be
improved
and
it's
in
our
repo.
So
you
can
improve
it
on
the
gitlab.
It's
you
don't
even
need
to
clone
the
repository.
B
B
There
you
go
so
release
or
didn't
happen.
Of
course,
like
a
lot
of
people
have
been
saying
like
yeah,
that
all
sounds
really
awesome
and
I've
been
presenting
around
about
it
and
they're
like
where's
the
release
like
when
can
you
use
it
so,
fortunately,
for
you
and
thanks
to
a
lot
of
thanks
to
mark
andre,
we
are
almost
done.
B
I
just
finished
the
last
set
of
essential
documentation
that
we
need
and
then
there's
one
more
issue
that
we
need
to
address
and
once
that
is
addressed,
we
intend
to
release
either
today
or
tomorrow,
so
stay
tuned
and
we
have
a
twitter
handle
for
zebus
crate.
So
you
can
you
can
get
the
news
from
there
so
we'll
have
1.0.
Finally,
and
that
will
be
awesome
and
everyone
will
be
super
happy,
so
future
plans.
B
As
I
said,
we
need
to
support
g
variant,
the
z
variant
create
without
that
is
not
very
useful.
You
can
use
it
and
if
you
want
to
store
your
information
is
in
an
efficient
way
already
in
a
deepest
format.
Yeah,
you
can
already
use
it,
not
a
problem,
but
people
already
are
using
the
g
variant
format,
so
that
would
make
it
even
more
useful
and
yeah.
B
If
you
want
to
contribute-
and
especially
if
you
are
well
very
familiar
with
async
apis
of
for
us,
then
this
is
a
golden
opportunity
for
you
to
make
a
major
contribution,
and
when
with
that,
we
will
also
provide
some
kind
of
sort
of
loop.
The
event
loop,
where
you
don't
have
to
you,
know
manually,
look
through
the
incoming
messages
and
stuff
so
yeah.
We
really
want
that
to
happen
soon.
B
It's
we're
talking
about
embedded
here.
So
no
std
is
in
the
plans
it's
in
the
goals.
Maybe
we
can
make
it
work.
We
currently
do
quite
a
few
allocations,
but
we
have
to
do
that.
There's
most
of
them.
It's
a
bit
hard
to
get
around,
so
I
don't
know
I
cannot
guarantee
100,
but
at
least
we
can.
We
can
minimize
the
allocation
as
much
as
possible.
We
already
do
and
we
will.
B
B
A
A
B
So
my
specific
use
case,
the
because
of
which
I
started
cbus
is
I
wasn't
using
it
on
on
embedded,
which
is,
as
I
said,
geoclue
service,
but
it's
used
on
embedded
systems,
including
a
safe
os
which
is
used
on
these
phones,
and
I
forgot
the
name
of
the
the
phone
itself,
but
yeah
it's
it's.
It's
used
out
there
and
also
the
old
version
of
geo
glue
is
already
in
in
automotive,
in
the
cars
used
already.
B
B
No,
as
I
said,
zbus
is
not
even
released,
so
I
don't
think
anyone
is
using
it
yet.
But
I
have
been
told
by
many
people
that
this
is
something
they
need
and
I
am
pretty
sure,
after
the
release,
they
will
feel
confident
enough
to
start
using
it
because
we
don't
break
api
after
the
release
and
that's
why
the
release
was
late,
because
we
didn't
want
to
do
that.
A
Makes
a
lot
of
sense.
I
think
we've
got
someone's
typing,
but
I
think
that's
all
of
the
questions
that
we
have
so
thank
you
again.
So
much
see
sean
for
being
here.
We're
gonna
go
to
break
now
for
a
couple
minutes
and
then
we'll
have
our
next
talk.
I
think
45
minutes
past
the
hour.
So
thank
you.
Everyone
for
watching.