►
From YouTube: A model-based AsyncAPI code generator for IoT environments by Abel Gómez | #asyncapiconf
Description
This talk was part of AsyncAPI Online Conference:
- AsyncAPI Initiative website - https://www.asyncapi.com/
- You can also watch this talk as part of full conference recording with audience questions in the LiveChat - https://youtu.be/oMSzGc5bDr4?t=3253
TALK ABSTRACT
In the new Internet of Things (IoT) era, our everyday objects have evolved in the so-called cyber-physical systems (CPS). The use and deployment of CPS has especially penetrated the industry, giving rise to the Industry 4.0 or Industrial IoT (IIoT). Typically, architectures in IIot environments are distributed and asynchronous, communication being guided by events such as the publication of (and corresponding subscription to) messages.
In this talk, we present AsyncAPI toolkit, our proposal relying on AsyncAPI to automate the design and implementation of these architectures using model-based techniques. AsyncAPI toolkit provides a set of editors and Eclipse-based tools which allow defining JSON-based specifications of message-driven APIs using AsyncAPI. From these specifications, the prototype is able to generate the Java code supporting the creation and serialization of JSON-based message payloads according to the modeled AsyncAPI, including nested JSON objects, as well as the necessary code to publish and subscribe to different topics. The initial prototype that implements this proposal as an open-source project is available at https://github.com/SOM-Research/asyncapi-toolkit.
SLIDES:
https://www.slideshare.net/abgolla/a-modeling-editor-and-code-generator-for-asyncapi-232935258
A
Hello,
everybody
welcome
to
my
talk
about
our
a
sink
API
based
code
generator
for
IOT
environments,
call
and
sink
API
toolkit.
Before
going
into
the
details
of
our
tool.
Let
me
explain
the
first
in
which
context
with
it
I
decided
to
build
this
to
date
and
what
kind
of
problems
we
are
trying
to
short.
As
we
already
know.
Nowadays,
there
are
more
and
more
devices
whose
hardware
and
software
are
inherently
interplay.
These
are
the
so
called
cyber
physical
systems.
A
This
cyber
physical
systems
play
an
important
role
in
the
Internet
of
Things
or
IOT
IOT
advocates
for
the
connection
of
everyday
objects
to
the
Internet,
resulting
in
complex
architectures
of
interrelated
computing
devices,
with
the
ability
to
share
data
among
them
without
requiring
human
interaction,
but
most
of
the
times
these
devices
do
not
have
high
competing
or
storage
capabilities
and
most
of
the
data
they
acquired.
He
sent
over
the
Internet
to
other
devices,
all
services
which
can
store
process
or
analyze
them.
A
Given
these
limitations.
Typically,
this
architectures
follow-up,
publish/subscribe
approach,
where
devices
or
services
interested
in
a
specific
topic
subscribed
to
it.
When
a
cyber
physical
system
produces
information
on
that
topic,
it
is
published
and
a
broker
is
team
in
charge
of
delivering
it
to
date
to
the
interested
parties.
A
But
although
this
kind
of
marketed
to
serve
various
callable
unfaltering-
and
they
are
not
completely
problem
free
due
to
its
discrete
in
nature,
it
is
really
hard
to
maintain
consistency.
Consistency
problems
mostly
appear
in
two
forms.
First
devices
in
the
network
may
publish
or
subscribe
to
the
ground
topics
does
not
delivering
or
not
receiving
important
information,
and
second,
there
can
be
deviations
in
the
message
format.
As
a
consequence,
a
subscriber
may
receive
information
in
a
way
it
is
not
prepared
to
parts,
thus
losing
information,
only
or
even
calcium,
runtime
errors
or
crashes.
A
One
way
to
alleviate
this
problem
is
to
have
a
single
source
of
truth
in
our
architecture.
This
single
source
of
truth
will
contain
all
the
information
to
run.
Our
infrastructure
example
of
shots
of
information
are
the
addresses
of
the
different
hosts
providing
core
services,
which
are
the
topics
that
can
be
published
or
subscribed
in
the
architecture
or
even
which
is
the
exact
form
and
format
of
the
messages
that
can
be
shared
among
peers.
A
And
here,
as
we
all
know,
is
where
a
sync
API
emerges
as
the
perfect
solution
that
can
serve
as
the
basis
to
specify
this
single
source
of
truth.
A
sync
API
provides
us
with
that
specification
to
define
all
these
needing
information
and
more.
However,
at
the
moment
we
test
this
problem.
A
sink
API
was
still
on
its
first
versions
and
if
there
were
sized
still
a
lack
of
to
support
for
the
specification,
so
we
decided
to
contribute
to
the
community
an
open
source
tool
to
automatically
generate
code
based
on
a
saint's
API
specifications.
A
For
this
and
based
on
our
own
experience
on
model
driven
engineering,
we
use
the
Eclipse
IDE
and
the
extracts
framework.
For
those
who
don't
know,
X
text
expects
is
a
framework
for
the
development
of
domain-specific
languages
with
X
text,
you
define
your
language
using
a
grammar
language
and,
as
a
result,
you
get
a
full
infrastructure,
including
parser,
linker
type,
checker
compiler,
as
well
as
a
meeting
support
for
Eclipse,
and
we
call
our
tool
st.
API
to
get.
This
figure
shows
how
our
tool
was
designed
and
its
main
work
in
principle.
A
First
and
based
on
the
syncope,
a
guess
specification
we
manually
created
and
if
an
X
text
grammar
for
it
based
on
this
grammar,
the
X
text
framework
is
able
to
obtain
a
meta
model
of
the
language
from
this
metamodel.
The
expects
framework
generates
all
the
infrastructure
that
give
support
for
a
same
API.
We
decide
we
specified
our
code
generators,
taking
advantage
of
all
the
infrastructure
that
was
generated
by
X
text
when
a
developer
wants
to
generate
the
code
for
a
specification.
A
The
only
thing
he
or
she
has
to
do
is
to
coat
it
in
the
provided,
as
in
KPI
editor.
A
model
of
the
asynch
API
is
automatically
created
from
this
textile
specification
and
also
automatically
the
final
code.
Supporting
your
API
is
generated
in
the
idea,
so
now,
let's
see
how
what
the
tool
looks
like
and
let's
grab
it
with
it.
A
The
first
thing
you
have
to
do
to
use
our
tool
is
to
just
install
it
on
top
of
our
clean
Eclipse
installation.
So
you
only
need
to
get
the
URL
from
our
github
repository
copy
it
and
install
it
now.
Here,
I
have
already
asked
and
it
lives
with
everything
installed.
But
the
only
thing,
as
I
said,
is
just
to
go
to
stand,
use
over
paste
here.
The
URL
and
everything
will
be
listed.
A
The
easiest
way
to
start
using
our
tool
is
just
use
the
new
project
wizard
so
go
into
the
async
API
project.
You
have
several
templates.
You
can
choose
to
create
your
new
API
specification.
You
can
start
by
an
empty
I,
think
API
period,
but
first
I
will
use
an
example
of
the
streetlights
example
that
we
can
find
in
the
st.
API.
Is
that
so
when
a
new
project
is
created?
A
Basically,
what
we
obtain
is
an
example,
Java
file
with
the
main
method
and
the
fact
with
the
specification,
and
they
folder
with
all
the
source
code
is
automatically
generated.
This
is
the
street
lights
API.
So
here
we
see
that
we
have
the
specification
of
the
or
the
name
of
the
API,
a
set
of
servers
in
this
case,
I
forgot
to
launch
the
broker,
so
I
will
launch
a
look
for
the
rest
of
the
demo
and
also
we
have
a
list
of
topics.
A
These
are
the
topics
that
are
the
different
channels
that
have
been
specified
in
our
API.
Here,
for
example,
we
have
this
topic.
The
lighting
is
large
measure
that
has
this
street
light
ID
parameter,
and
we
have
here
the
operations
for
the
police
and
subscribe.
We
see
here.
We
see
here
that
the
message
that
is
polished
on
which
we
subscribe
is
this
light
measure
that
is
specified
here
below
this
LED
national
message,
and
here
we
have
the
link
to
the
payload.
That
is
this
payload
here,
the
payload.
A
It's
an
object
with
humans
property,
which
is
an
inter
and
assented
that
here
we
specify
that
it's
a
string.
So
we
see
that
from
this
specification
we
have
this
generated
code.
For
example,
if
we
see
the
lightning
measure
topic,
we
have
a
package
for
it
with
the
classes
for
the
pollution
for
the
SUBSCRIBE
operation.
If
we
look
at
the
publish,
measured
class,
we
see
here
that
we
have
the
make
the
methods
for
perishing
here,
for
example,
for
the
SUBSCRIBE.
A
We
have
live
methods
for
subscribing
and
we
also
see
in
the
publish
that
we
can
pass
a
payload
that
it's
this
light,
measured
payload
that
it's
specified
in
the
schemas
package,
which
is
this
class
here
that
measure
here
we
have
the
methods
to
get
the
information
from
payload,
and
we
also
have
this
builder
that
implements
a
fluent
API
for
creating
new
instances
of
the
payload.
So,
let's
see
what
the
generated
code
or
how
the
generated
code
is
used
for
this.
We
have
this
main
example
class,
which
is
the
main
class
first.
A
Here
we
have
the
method
for
subscribing.
So
here
we
have
the
lambda
that
receives
speedometers
the
parameters
of
the
of
the
message
and
the
message
is
itself
so
here
we
see
that
once
we
received
a
message,
we
can
dive
indicate
the
lumens
from
from
the
object
and
the
center.
So
when
we
receive
a
new
message,
the
only
thing
we
do
is
just
printing
on
the
standard
error.
The
information
about
the
message-
and
here
we
have
the
code
that
creates
the
payloads
and
finally
cents
here
in
the
Polish-
publishes
the
dis
message.
A
So
as
we
can
see
in
the
payload
builder,
we
from
the
from
the
message
class,
we
can
obtain
a
builder
and
I
believe.
With
this
builder,
we
can
start
setting
the
information,
for
example,
using
the
method
with
lumens
setting
it
at
10
with
center,
we
specify
the
local
date
time,
etc.
So,
when
we
publish
it,
this
is
sent
to
the
broker
and
it's
delivered
and
it's
receiving
the
SUBSCRIBE
method.
We
can
directly
run
this
code,
so
run
it
as
a
java
application.
A
A
Okay.
When
we
save
the
code
automatically,
we
have
changed
the
method
for
setting
this
property
of
the
message.
So
now
we
see
that,
for
example,
we
are
receiving
an
error
with
in
with
Center,
because
it
is
no
longer
we
expecting
an
integral,
but
it's
expect
a
string,
but
it's
been
expecting
an
integral.
So
maybe
this
is
because
we
are
going
to
send
here
the
epoch
time.
So,
if
we
change
this,
this
will
work
again.
A
A
A
Basically,
what
we
have
done
here
is
yes,
/
specify,
which
are
they
complex
data
that
we
are
going
to
send
in
the
messages.
For
example,
here
we
have
one
sensor
with
a
name
that
contains
a
set
of
events
that
are
of
an
animated
type,
and
this
events
contain
a
timestamp,
in
this
case,
it's
important
to
see
that
the
sensor
can
contain
any
number
of
events.
So
when
we
have
complex
data
models,
we
can
model
them
and
by
annotating
some
information.
For
example,
we
can
see
the
sensor
here
and
go
to
the
properties.
A
A
A
sync
API
specification-
and
here
also
have
some
example
code
that
we
can
we
can
see,
is
basically
the
same
holds
very
similar
to
the
one
we
have
you
see,
but
in
this
case,
for
example,
we
can
see
that
since
we
can
add
many
atoms,
so
we
have
a
method
to
create
the
events
and
to
add
them.
So,
for
example,
we
cannot
say
there
are
events.
A
A
Sorry,
I
move
this
wrong.
Okay,
so
now
this
can
be
executed
and
runs
perfectly
like
the
other
example.
So
here
we
see
that
the
messages
are
sent
and
everything
is
working.
Fine,
that's
that's
all
here
you
have
the
link
to
our
tool
to
our
repository
so
feel
free
to
download
it
test.
It
leave
your
comments
thanks
for
watching
and
listening,
and
thank
you
very
much.