►
From YouTube: Elsa Workflows Community Meeting 4 ( 2022-04-12 )
Description
# April 12, 2022
## Topics
- Steering Committee Elections 2022
- Voting started. Please cast your vote here: https://pollunit.com/en/polls/elsa-workflows-steering-committee-election-2022
- 48 people voted so far
- April 30th - election results.
- Status
- Elsa 2:
- CRON UI
- Composite Activity timer
- Elsa 3
- Proto Actor
- Working on Break activity
- Demos
- Elsa 2: SwaggerGen support for HTTP Endpoint
- Questions / feedback: support for providing documentation about e.g. response type and other Swagger-specific info.
- Elsa 2: Running a cluster locally using Rider.
- Elsa 2: Testing workflows
- What happens if the workflow has more than 1 starting activity / triggers?
- Right now, it takes the first one.
- Ability to provide test values as input for triggers?
- Breakpoints - maybe makes sense only if it allows you to change values at runtime?
Next time?
- Elsa 2: demo from Mohammed?
- Elsa 2: securing HTTP Endpoint / Server / Dashboard Auth
A
A
Right
yeah,
thank
you.
So
if
I
enter
interpret
this
number
correctly,
48
people
have
voted.
Please
cast
your
vote
here.
48
people
voted
so
far.
This
was
configured.
Everyone
gets
five
votes,
you
can
vote
cast
a
maximum
of
three
votes
per
candidate
and
voting
happens
anonymously
and,
up
to
this
point
even
I
can't
see
how
many
votes
individual
candidates
that
will
become
clear
the
end
of
this
month,
the
30th
of
april.
That's
when
we'll
see
the
election
results,
anyone
and
everyone
who's
watching
this
video.
A
B
A
A
I
will
show
sure
no
worries
next
time
will
be
great,
so
I
I
made
a
few
notes
for
some
ideas
for
a
quick
demo.
Today
I
know
france,
you
opted
maybe
talk
a
little
bit
about
securing
hp,
endpoints
and
the
you
know
the
api
controllers
in
general
of
elsa.
I
didn't
have
time
to
prepare
anything
for
that.
Unfortunately,.
A
I
did
make
a
note
here:
swagger
gm
support
for
eight
spins.
I
would
like
to
show
that
that's
a
new
feature
that
got
in
recently
this
one
here.
So
this
is
a
new
feature
and
enhancement
to
the
hp
endpoint
activities,
module
which
allows
your
hp
endpoints,
as
you
add
them
to
your
workflow,
to
be
become
part
of
the
open
api
generated
by
swatch
buckle.
So
let
me
let
me
show
you
how
that
works.
I
have
the
server
running
here
now.
A
Endpoint
documentation
for
the
installed
api
controllers-
that's
this
all
comes
from
elsa,
server.api
and,
of
course,
your
own
controllers.
If
you
have
them
so,
as
you
can
already
see
it,
it
adds
a
new
category
here
called
workflow
endpoints,
and
this
comes
from
that
new
feature.
Currently,
there's
no
endpoints,
but
let's,
let's
add
one.
A
This
is
the
fully
the
assembly
qualified
type
name.
Now,
if
everything
went
well,
I
refresh
the
space.
It
should
now
show
the
schema,
and
this
is
correct.
So
this
model
I
just
entered
it
has
a
single
field
message
and
it's
displayed
here
and
this
this
is
a
bug.
It
shouldn't
display
this
request
body
forget
it
still
need
some
policy.
The
the
basic
functionality
is
there
to
be
clear.
It's
actually
not
added
to
the
package
itself,
it's
an
add-on
package
or
it's
an
additional
packets.
A
B
A
B
A
A
So
when
you
want
to
enable
this
feature,
first
is
of
course
installing
the
packets
and
then
you
need
to
add
your
swagger
services
here,
I'm
using
add
elsa
swagger,
but
you
don't
have
to
internally
it
just
installs
a
it's,
also
opinionated
configuration
of
swagger.
So
it's
doing
things
like
adding
a
few
examples,
setting
up
the
swagger
dock,
that
kind
of
thing,
but
it's
optional.
You
can
do
this
yourself,
so
you
don't
have
to
use
adhesive
swagger,
but
you
do
have
to
add
this
document
filter
in
order
for
the
hp,
endpoint
integration
to
work.
Do.
A
Mean
oh
yeah,
so
this
is
the
request
buddy,
but
there's
also
the
responses.
I
think
I
may
have
even
added
a
note.
I
didn't
add
a
note,
but
except
for
additional
work
might
be
done
and
that
should
include
being
able
to
control
the
or
document
the
response,
the
possible
response
type.
We
have
to
think
of
good
ways
to
do
this
because,
right
now
there
are
some
things
you
can
configure
on
the
http
endpoint
like
you
can
give
it
a
display
name
in
the
description.
A
This
description
will
actually
show
up
if
it
works,
so
it
doesn't
work.
The
description
should
be
should
be,
should
be
applied
in
publish,
maybe
not
yeah.
Well,
that
could
be
a
bug
or
an
omission,
but
that's
a
one
one
field
that
can
be
used
of
course,
but
in
terms
of
a
response,
the
question
is:
where
would
you
document
it?
Do
we
add
a
field
here
just
for
the
purposes
of
describing
the
response?
A
A
That's
also
a
good
suggestion
to
maybe
not
link
it
to
this
activity,
but
as
a
an
extension
maybe
to
this
general
settings,
yeah
yeah,
exactly
so
just
circling
back
to
status
for
a
bit.
I
know
mohammed's
been
working
on
an
improved
crown
ui,
so
we'll
hopefully
see
that
next
week
I've
been
working
on
elsa
3.,
specifically
on
the
the
proto-actor
runtime
and
for
those
who
haven't
heard
of
proto-actor,
it's
a
very,
very
lean
and
small
footprint
library
that
allows
you
to
implement
better
model.
A
Maybe
some
of
you
have
heard
of
or
microsoft
orleans
microsoft
orleans
is
a
dot
net
library
that
allows
you
to
implement
the
actor
model,
and
what
is
the
active
model
is
simply
put
it's
an
an
object
that
you
have,
which
has
its
own
inbox
and
this
inbox.
You
can
regard
it
as
an
input
queue,
and
when
would
you
use
it,
you
would
use
it
in
a
distributed
environment.
A
So
let's
say
you
have
a
cluster
of
applications
or
nodes
containers
in
a
kubernetes
cluster,
for
example,
and
each
of
these
these
containers
can
have
one
or
many
more
actors
and,
and
they
will
process
this
input
cube.
So
these
queues
contain
messages
or
operations
that
the
actor
can
perform,
and
what
I
want
to
do
for
elsa
is
to
leverage
this
model,
because
I
think
it's
a
great
fit
for
processing
workflow
instances.
So,
as
you
may
know,
with
elsa
2,
you
can
host
it
in
a
in
a
cluster.
A
What
needs
to
be
taken
native
account
is
overwrite
that,
in
the
state,
workflow
instance
should
not
be
updated
from
different
threats.
For
example,
you
could
run
into
issues
where
you
know
with
concurrency.
Let's
say
two
threads
have
are
working
on
the
same
workflow
instance.
Then
one
performs
an
update
and
then
saves
it
to
the
database,
while
the
other
thread
has
it
still
in
memory.
That
now
has
a
stale
copy
in
in
memory
makes
changes
to
it.
A
That
was
written
by
the
other
threat,
simply
put
to
avoid
that
elsa
2
uses
distributed
locking.
So
here
talks
about
a
distributed,
lock
provider
and
basically,
what
that
means
is
as
soon
as
the
engine
wants
to
start
working
on
a
workflow
instance.
It
will
first
try
to
acquire
a
lock
using,
for
example,
a
lock
in
sql
server,
which
is
a
shared
resource,
which
is
why
it
works,
because
any
node
in
the
cluster
will
try
to
acquire
a
the
same
shared
resource
or
a
lock
on
a
shared
resource.
A
B
A
A
You
can
process
a
smaller
number
of
workplaces
when
you
didn't
have
to
lock
and
now
the
actor
model
it
allows
you
to
not
have
to
deal
with
distributed,
locking
because
every
workflow
instance
will
have
its
own
input
queue
and
all
messenger
or
communication
with
the
workflow
instance
goes
through
this
input.
So
you
can
have
many
sources
that
instruct
or
send
instructions
to
the
workflow
instance
to
perform
some
operation.
B
B
Also
because
when
I
looked
at
your
documentation,
I
saw
it
was
an
unlock
thing
for
the
sql
server
and
I
don't
think
that,
because
that's
a
part
of
the
sql
server
itself,
the
login
mechanism
yeah,
and
so
you
can't
have
that
this
was
looking
for
any
database.
Some
might
not
be
able
to
have
that
feature
right.
A
Well,
so
of
course,
if,
if
you're
working
with
elsa
too
and
you
need
distributed
login,
but
you
can't
leverage
the
sql
server,
there's
other
implementations,
so
sql
server
is
just
one
example:
elsa
actually
uses
the
instead.net
packets.
I
called,
I
think
it's
called
distributed.
Locking
this
will
be
locked,
that's
the
name
and
they
have
many
providers.
So
you
could
use
a
blob
on
azure,
even
the
local
file
system,
but
that's
only
useful
single
node
machines,
I
imagine-
or
maybe
network
shares,
I
don't
know-
and
of
course,
etc.
A
A
There
will
be
delivered
to
your
act,
the
only
difference
it
works
with
event,
sourcing
and
snapshots,
pretty
fancy
stuff,
quite
easy
from
the
developers
point
of
view
when
you
develop
the
actor,
but
the
gist
of
this
is
that
all
of
your
state
gets
persisted
in
some
underlying
persistent
store.
That's
pluggable,
and
this
could
be
your
own
database.
It
could
be
kafka,
I
I
don't
know
I've
yet
to
to
dig
into
the
detail.
Yeah.
A
B
B
A
For
virtual
actor,
which
is
a
term
borrowed
from
microsoft
or
orleans,
and
what's
great
about
a
virtual
actor,
it
means
that
as
a
developer,
you
don't
care
about
the
location
of
where
this
actor
is
instantiated.
It
could
be
on
node
one
could
be
a
node
three
or
whatever.
How
many
nodes
you
have
you
don't
care
about
that?
You
don't
even
have
to
care
about
the
actor
being
activated
or
not.
You
just
treat
it
as
if
it's
a
service
or
an
object,
that's
there.
A
The
framework
will
make
sure
of
fading
it
and
also
passivating
the
actor
which
means,
if
the,
if,
let's
say
a
minute
after
the
last
message
was
received
by
some
actor,
it
will
be
removed
from
memory,
not
a
logic.
Logically,
there
will
be
one
word,
for
instance,
screen
per
workflow
instance,
so
you
could
have
many
hundreds
or
thousands
of
them
processing
workflows
all
in
parallel.
A
It's
pretty
awesome,
removing
the
need
for
distributed,
locking
and
ultimately
allowing
the
system
to
scale
enormously,
and
I
know
that
well,
I've
read
stories
about
microsoft
orleans
using
their
system,
for
I
believe
the
game.
Halo
contains
many
objects
and
they
they
leveraged
the
the
actor
model
successfully
yeah.
So
I've
been
getting
into
the
nitty-gritty
details
of
of
that
and
that's
to
to
be
dialed
in
soon
everything
else
is
coming
along
nicely
with
elsa.
A
A
I
have
some
some
arbitrary
logic
that
says
if
the
current
item
is
rust,
so
here
I
have
a
list
that
I
iterate
over
so
three
languages
and
I
want
to
break
as
soon
as
I
encounter
this
value
rust
using
the
break
and
that
what
should
happen
is
as
soon
as
this.
It
should
not
continue
on
with
the
right
line.
Activity.
A
Breakout
is
out
of
this
for
each
loop
and
continue
with
this
one.
Currently,
the
test
fails,
which
makes
sense,
because
this
is
not
yet
implemented.
So
speaking
of
clusters,
I
thought
maybe
it
might
be
helpful
to
to
see
how
would
you
test
your
configuration
in
your
local
machine
because
it
can
be
tricky
to
stand
in
a
production,
environment
or
even
a
test
environment?
What
I
do
I
use
rider
for
that
and
ryder
has
this
nice
feature
called
configurations.
So
here
I
have
a
it's.
It's
like
the
launch
settings
that
you
have
here
in
properties.
A
B
A
I
think
container
name,
and
why
do
I
have
different
container
names
per
node
that
has
to
do
with
messaging?
So
let's
say
I
have
a
domain
event
that
I
want
to
distribute
across
all
of
the
container
instances
in
my
cluster.
Each
node
needs
their
own
input
queue,
because
if
you
don't,
then
it
will
be
a
competing.
A
You
will
have
basically
the
competing
consumer
pattern
in
place
where
the
first
container
or
the
first
node
in
your
cluster
to
pick
up
this
message
will
consume
the
message
and
none
of
the
other
nodes
in
your
cluster
will
be
aware
of
this
message.
So
this
works
great.
If
you
want
to
distribute
work
and
that's
exactly
what
you
want,
but
if
you
want
every
node
in
the
system
to
receive
event,
then
they
need
to
be
listening
on
their
on
their
own
input.
Queue
and
elsa
uses
this
container
name
to
generate
the
input
queue.
A
So
one
nice
aspect
of
having
various
configurations
per
node
and
then
using
the
compound
configuration
here.
You
can
start
all
three
instances
at
the
same
time,
so
here
I
can
say-
and
this
will
then
start
three
instances
of
my
application.
So,
as
you
can
see
here,
there's
now
three
instances:
node
one
listening
on
this
port,
one
two
one,
oh
one,
two
two
and
and
what's
nice
about
this-
is
it
allows
you
to
test
if
you
configure
things
correctly
so,
for
example,
let's
go
to
the
dashboard,
I
have
it
open
here
as
a
separate
writer
instance.
A
Now,
let's
say
I
want
to
connect
to
node
one
of
course,
so
I'm
updating
this
reloading
will
update
the
dashboard.
So
here
we
have
the
dashboard
and
as
you
see
now,
this
is
communicating
with
the
server
listening
at
one
two
one.
Actually,
I
wanted
to
also
show
the
okay.
Let
me
let
me
see
if
I
can
test
it
like
this.
So
now,
let's
say
I'm
changing
the
name
of
this
workflow
definition.
Let's
give
it
a
name
and
publish
this.
A
So
what
what
happens
when
I
publish
a
event
will
be
generated
that
should
be
delivered
across
all
three
nodes
so
that
the
their
cast
gets
invalidated?
Because
what
happens?
If
you
look
at
the
workflow
registry,
this
workflow
registry,
the
items
within
it
are
kept
using
a
local
memory
cast
and
then,
whenever
a
change
gets
made
to
a
workflow
definition,
name
or
anything
else,
changes
in
the
workflow
definition
and
you
publish
it.
A
signal
gets
distributed
across
the
nodes.
Each
node
gets
a
chance
to
invalidate
their
local
memorycast.
A
So
that
means
if
it
works,
and
I
connect
now
to
a
different
server.
So
now
I
this
has
connected
to
a
different
server.
That
means
that
if
I
load
the
database
workflow
provider,
it
should
show
the
updated
name
which
it
did
in
this
case
and
to
be
clear.
Making
requests
from
this
page
to
the
server
does
not
invalidate
the
cast
is
successful.
A
It
will
be
even
better
to
test
if
you
also
launched
three
separate
instances
of
of
this
client,
but
for
that
maybe
you
can
align
not
the
server
cluster
but
the
monolith
cluster,
because
that
is
a
that
that
hosts
both
the
dashboard
and
the
the
workflow
server.
We
can
actually
give
that
a
quick
try.
So
here
we
have
number
one
number
two
and
number
three.
So
let's
take
a
look
at
the
profile
registry
for
each
so
now,
let's,
let's
do
the
same
test.
A
We'll
change
the
name
of
hello
world
hello,
world
one
and
publishing
should
have
invalidated
the
cache.
So,
let's
refresh
the
second
node
and
as
you
can
see
that
in
the
same
goes
for
this
one
also
hello
world.
So
this
is
an
easy
way
to
test
your
distributed.
Setup
testing.
Workflows.
Have
you
guys
tried
this
before?
I
guess
that's
enough,
so
let
me.
B
A
Which
has
a
button
to
execute
your
workflow
and
then
you
can
see
it
run,
step
by
step.
So
this
is
not
a
very
exciting
test,
of
course,
but
it
also
works.
If
you
have
multiple
data
more
so
now,
with
those
in
place,
I
can
go
tap
again
and
then
execute,
and
then
you
see
each
one
switching
back
to
the
server.
You
also
see,
of
course,
the
the
effect
of
this
workflow.
C
B
C
A
C
C
A
Exactly
so,
currently,
that's
not
there's
no
way.
So,
let's
say
you.
Indeed,
you
have
a
trigger
like
http
endpoint.
Let's
call
it
testing
as
you've
correctly
stated.
When
you
now
execute
this,
it
will
actually
wait
for
the
input.
What
you
want
is
a
way
to
actually
have
this
one
continue
and
maybe
provide
fake,
fake
values
like.
C
A
A
Yeah,
I
agree,
but
we
don't
have
it
for
now
so
for
now
you
will
actually
have
to
manually
somehow
invoke
this
so
in
this
case
conveniently
provided
us
with
the
url
to
invoke
so.
Let
me
come
to
a
new
browser,
make
the
request
and
it
should
have
continued
it
didn't
so
not
quite
stable
and
see
with
it.
The
same
goes
for
the
timer
and
message
received
from,
I
believe,
rabbit
and
q
messages,
but
there's
there
might
be
other
other
triggers
that
don't
yet
support
this.
B
B
A
A
It
should
pause
execution
and
then
allow
you
to
inspect
its
well
its
inputs.
That
would
be
yeah.
That
would
be.
That
would
be
huge
to
have,
especially
combined
also
with
a
direct
view
to
the
console.
So
in
the
server
we
have,
we
have
this
console
and
it
would
be
pretty
sweet
if
we
could
stream
this
somehow
to
the
to
the
client
that
you
get
debug
messages
and
and
that
sort
of
thing,
but
that's
that's
far
away
still.
A
Yeah
so
there's,
I
think,
there's
an
issue
for
that
right
now
it's
not
implemented,
but
that's.
That
is
what
we
want.
We
want
to
see
the
journal
when
you
test
here
you,
you
should
be
able
to
view
its
execution
lock,
and
I
have
to
go
to
the
workflow
instance
and
watch
it
from
there.
That's
quite
inconvenient.
So
this
is
this
is
what
you
want
to
see
as
well.
B
B
A
B
A
A
Just
like
that
yeah
all
right,
so
that's
all
I
had
for
now.
Let's
take
one
more
look
at
the
the
git
committee.
If
there's
something
something
else,
that's
worth
mentioning
I'll,
just
mainly
the
three
stuff
in
this
new
feature
all
right.
Well,
then,
can
we
can
cut
this
meeting
short
and
then,
hopefully
we'll
see
still
next
time
and
of
course
anyone
comes
up
with
an
interesting
topic
or
some
demo
that
they
would
like
to
see.
Then
please
make
that
suggestion.