►
From YouTube: Demo - libp2p Network Visualization Tool - Juan Benet
Description
Originally recorded during the Berlin Developers Meetings from July 9-13, 2018.
For more info, check out the repos:
https://github.com/filecoin-project/filecoin-network-viz
https://github.com/filecoin-project/filecoin-network-sim are now public!
For more information on IPFS
- visit the project website: https://ipfs.io
- or follow IPFS on Twitter: https://twitter.com/IPFS
Sign up to get IPFS news, including releases, ecosystem updates, and community announcements in your inbox, each Tuesday: http://eepurl.com/gL2Pi5
A
Okay,
sweet
I'm,
gonna
demo:
this
is
the
first-ever
semi-public
demo
of
the
fot
implementation
and
I'm
gonna
demo
it
with
the
lipitor
PE
network
visualization
to
it.
So
the
cold
is
that
most
really
that
network
visualization
toolkit,
but
the
thing
I
have
that
working
with
is
the
Falcone
implementation.
So
I'll
walk
you
through
that.
A
So
fill
net
SIM
phone
network,
simulator
and
visualize
earth.
This
is
a
tool
to
simulate
a
Falco
Network
locally.
It
spawns,
go
ipfs,
sorry,
go
file
going
note
demons
randomly
it
issues
commenced
to
them
via
the
CLI
tool,
then
the
same
issues,
actions
randomly
according
to
the
set
of
program
options.
A
The
sim
supports
connected
into
individual
Falcon
notes
to
issue
commands
manually,
meaning
the
simulation
can
be
going
and
you
can
hook
into
it
and
also
send
commands
the
sim
consumes
all
event
logs
coming
out
of
those
demons
and
transforms
them
into
input
logs
for
a
visualization,
so
I'll
walk
through
how
that
works.
A
little
bit
I'll
give
you
like
a
good
diagram,
I'll
kind
of
show
you
the
demo
first
and
then
I'll
walk
through
how
that
that
tool
works.
The
sim
also
serves
so
the
visualization
is
on
the
well
app.
A
So
this
little
tool
has
a
web
server
and
in
the
future
this
may
run
across
many
machines.
So
the
structure
of
this
is
set
up
so
that
in
interior
we
can
easily
split
up
this
tool
and
have
it
be
running
across
a
bunch
of
machines
and
then
that
aggregates
into
a
single
web
app
that
shows
you
a
visualization
of
large-scale
networks.
So
ideally,
I
would
love
to
see
visualizations
of
dhts.
A
In
the
you
know,
thousands
or
tens
of
thousands
of
nodes
like
see
like
the
entire
cat
Emily
out
like
routing
table
shifting
know
that
might
be
hard,
but
we
can
think
about
how
we
might
do
this
kind
of
stuff
so
effectively.
What
this
simulator
does
is
there's
a
program
that
is
going
to
send
a
set
of
actions
to
these
demons
and
the
program
has
a
bunch
of
options,
so
things
like
the
maximum
number
of
nodes
to
start
certain
timing,
things
whether
or
not
to
censor
in
actions.
A
A
So
the
implementation
is
a
tool.
Much
like
go
IVFs
everybody
familiar
with
us
will
recognize
some
of
the
the
things
here
like
the
lipid
repeat,
swarm
command
and
it
implements
a
full
blockchain
in
IPL
D.
So
it
has
a
dag
command,
just
like
going
PFS.
So
you
can
pull
out
all
the
objects
of
the
file
coin
blockchain
through
the
familiar
I
feel
the
ability
commands
and
you
can
walk
through
the
blockchain
that
way.
So
you
could
pull
out
specific
pieces
and
we'll
see
it
at
a
moment
and
then
that's
the
question.
A
It
has
a
set
of
transactions.
We
call
those
messages.
The
transaction
smart
contracts
model
same
way
of
thinking
about
that
you
can
think
of
actors
and
messages
and
message
passing.
So
we
tend
to
call
them
message
as
an
actress
because
of
a
whole
bunch
of
reasons
around
thinking
about
like
programming
languages
and
so
on.
Anyway.
We
just
renamed
it
for
now.
A
Well,
we'll
see
if
that
name,
sticks
and,
and
so
this
I
could
kind
of
walk
you
through
initializing,
a
daemon
manually
and
so
on,
but
it's
pretty
involved
in
as
much
easier
to
just
show
the
simulator
and
then
I'll
hook
into
one
of
the
knows
and
they're
all
some
commands.
So
what
I'll
do
first
is
I'll
run
this
tool,
it's
kind
of
like
the
basic
parameters,
and
so
what
this
is
doing
is
now.
A
It
first
gave
me
some
links,
so
it
gives
me
a
logging
endpoint,
and
so
this
is
effectively
the
same
kind
of
log
output
that
are
that
both
any
kind
of
Lipnicki
implementation
and
go
every
fess
chair
where
it's
just
a
bunch
of
jason
logs,
but
these
are
transformed
I'll
get
into
that
later.
So
how
that
transformation
happens,
but
they're,
not
the
raw
logs
that
are
coming
out
of
of
go
file
coin.
They
have
been
changed
by
the
simulator
tool
I
get
into.
Why?
A
When
I
explain
how
this
Tool
Works
so
then
it
also
offers
a
couple
of
like
endpoints
for
for
some
visualizations
that
I
haven't
mounted
onto
this.
Then
they
have
there's
a
whole
bunch
of
options
here.
This
will
be
set
by
the
by
the
flags
and
then
here
it's
just
starting
to
add
demons,
and
it
gives
me
a
few
of
the
options.
It
shows
me
the
the
repo
of
where
that
particular
node
is.
It
gives
me
the
wallet
address
for
that
that
node
this
happens
to
be
a
miner,
so
it
has
a
miner
actor
address.
A
A
Let's
see
I
can
do
swarm
pierce
and
you
know
typical
kind
of
stuff.
This
society
fest
should
know.
That's
just
a
p2p.
That's
like
a
look
at
P
thing
will
fix
that,
but
it
also
can
do
things
like
show
me.
The
order
book
and
so
I
can
see
like
the
asks,
and
so
that's
like
a
set
of
orders
that
are
now
in
the
market,
and
so
this
has
been
running
for
a
little
bit
of
time
and
so
like
it
already
generated
a
whole
order
book.
A
We'll
see
it
in
a
moment
and
over
here,
I
just
have
h,
stop
running
so
there's
a
whole
bunch
of
demons
being
just
so
that
you
get
a
sense.
It's
filtering
on
the
word
file
coin,
and
so
that
means
there's
a
bunch
of
demons
running
and
a
bunch
of
commands.
Being
assured
that,
so
that's
just
a
show
that
the
simulator
here
is
creating
a
bunch
of
processes
that
are
running
now.
I'm
gonna
kill
it
and
restart
it
because
we
really
want
to
hook
into
the
visualization
at
the
beginning.
A
A
So
now
we'll
write
it
again
and
we'll
open
the
visualization.
So
this
is
what
them
that
it's
doing
you
can't
see
it.
You
can
barely
see
it.
So
each
one
of
those
things
is
an
action.
So
that's
a
payment
transaction,
that's
a
deal
happening,
there's
a
block
being
mined.
There's
a
note
entering
that's
another
payment
transaction
and
note
another
note
being
another
block
being
mined
more
payments,
and
so
on,
and
here
you
can
see
all
the
bits
and
it
asks
that
miners
are
at
my
nursing.
Clients
are
adding
to
the
market.
A
A
A
By
making
it
look
man
anyway,
so
this
is
transferring
real
files
and
they're
being
pulled
from
a
set
of
a
set
of
test
files
than
I
have.
But
that
means
that
these
notes
are
actually
you
know,
adding
and
transferring
real
files
that
clients
are
sending
their
real
files
to
the
miners
and
having
them
stored.
So
that's
you
know
you
know.
So.
The
whole
idea
of
the
storage
market
is
working
where
clients
are
putting
bids
minor,
supporting
asks
they
get
mashed
into
a
deal.
A
Then,
once
there's
the
deal,
the
client
sends
a
file
to
the
miner
to
store,
and
that's
that's
what
you
saw.
So
we
don't
have
the
equivalent
of
the
retrieval
market
here
shown,
but
it
would
be
kind
of
the
symmetric
set
of
operations
and
down
here
you
can
see
kinda
the
set
of
heartbeats,
and
so
here
you,
if
you
look
kind
of
closely
it's
a
little
bit
hard
to
see.
But
you
see
that
all
of
these
chain
heads
switch
and
converge
because
that's
consensus
happening.
A
A
Oh
one,
more
thing
it
if
I
click,
one
of
these
things,
I
land
on
a
phone
Explorer
which
is
effectively
kind
of
like
a
blockchain
Explorer
tool,
but
it's
built
it
right
in,
and
so
this
is
following
the
chain,
as
it
appears,
I
can
click
into
into
it
and
see
the
this
is
particular
block.
This
is
the
miner.
This
is
the
state
route.
The
state
route
is
the
the
state
of
that
block,
and
so
that
means,
like
all
the
state
transitions
have
been
applied.
That's
all
IPL
D,
so
you
could
like
browse
it
right
now.
A
For
example,
I
see
Ram,
we
have
all
of
the
IPL
the
importers
for
aetherium,
so
we
can
do
the
same
thing
in
the
theorem
as
well,
and
here
is
a
set
of
messages,
so
these
are
like
the
actual
transactions,
and
you
can
see
the
method
invocation,
that's
happening
and
the
parameters
that
are
being
sent
there.
So
in
this
particular
block
we
see
that
we
have
the
ones
that
don't
have
a
method
is
just
sending
money.
A
So
that's
just
a
normal,
like
you
know,
transaction
as
you
wouldn't
on
Bitcoin
a
payment,
here's
adding
an
ask
another
payment
and
so
on.
There
are
no
deals
on
this
one,
and
these
are
kind
of
like
the
outputs
of
each
of
the
each
of
the
messages.
We
can
also
see
the
set
of
actors,
so
this
is
looking
at
the
local
storage
of
the
of
the
chain
in
a
sense,
and
we
can
see
each
one
of
these
actors
is
think
of
it
as
a
smart
contract.
A
It
has
an
address.
It
has
the
SE
ID
of
the
code
that
is
executing
this
actor.
It
has
memory,
which
is
this
memory
is
just
like
the
local
storage
of
the
of
the
actor
or
smart
contract,
and
here,
like
the
functions
as
exporting,
though
you
can,
you
can
call
here.
You
see.
These
are
ego
types.
Those
will
not
be
go
types
in
the
future
and
there's
you
know
a
bunch
of
different
kinds
of
kinds
of
accounts,
for
example
instantiate
one
of
these
actors
for
you
and
maintain
a
set
of
local
estate.
A
So
and
this
this
Explorer
is,
you
know
we
clicked
clicks,
not
particularly
node.
If
the
if
the
network
was
divided
then-
and
we
clicked
on
a
different
one,
then
we
would
see
potentially
different
state.
So
this
the
idea
of
this
visualization
is
that
it
sets
it
up.
So
you
could
explore
the
network
in
the
right
direction.
Now
the
Explorer
is
connecting
directly
to
the
node
and
like
asking
for
things,
and
it
might
in
the
future,
also
write.
A
This
visualization,
though,
is
is
meant
to
only
to
be
read-only
or
at
least
to
have
a
read-only
mode
where
it
works
entirely
off
the
logs,
and
the
idea
for
that
is
that
we
should
be
able
to
take
a
trace
of
a
run
tree
of
a
previous
run
and
store
it,
and
then,
just
from
the
logs
be
able
to
replay
the
entire
thing
to
see
it
and,
ideally
later
on,
maybe
potentially
have
some
playback
controls.
So
we
could.
A
We
could
actually
like
speed
it
up
or
slow
it
down
or
jump
to
a
specific
point,
and
the
idea
of
that
is
that
it
could
help
significantly
with
debugging.
So
right
now
this
seems
super
chaotic
because
there's
a
lot
going
on,
but
you
know
we
can
play
with
this,
and
you
know
instead
of
doing
all
this
stuff,
we
can,
you
know,
turn
off
a
bunch
of
the
of
the
things
that
it's
doing
and
say
like
maybe
do
no
automatic
actions
and
then
actually
manually
script.
A
Some
like
specific
simulation
actions
specific
to
this,
to
this
particular
application,
plus
some
of
the
event
translation.
So
the
event
translation
I
mentioned
that
I
was
going
to
go
into
that's
because
the
event
logs
that
are
coming
out
of
of
the
node
are
specific
to
how
the
go
file
phone
implementation
works.
And
so
that's
you
know
the
event
logs.
There
are
like
whatever
the
developers
want
to
get
out
of
those
logs.
A
Now
that
may
not
be
with
a
visualization
once
and
so
that
translation
is
there
to
make
it
easy
for
each
group
of
developers
to
focus
on
what
they
care
about.
So
the
go
falcon
developers
can
just
think
of
the
events
that
they
want
to
put
into
the
falcore
falcore
node
and
the
visualization
developers
can
think
about
the
events
that
they
want
to
visualize
right.
So
things
like
sending
a
payment
things
like
making
a
deal
and
so
on.
There
might
be
a
one-to-one
correspondence
some
event.
A
That's
similar
to
this,
where
you
know
around
the
ring,
we
just
have
tht
nose
and,
and
what
we
see
is
you
know
like
puts
and
gets-
and
you
know
retrieval
so
it's
putting
gets
on
to
the
DHD
and
we
can
see
these
would
be
kind
of
like
actual,
like
requests
going
through
or
ideally
we
could
also
draw
the
the
connections
between
these
nose
and
see
the
buckets
right.
So
that's
what
kind
of
this
is
headed
now,
of
course,
at
the
HD,
that's
massive.
A
Yeah
I
want
for
this,
but
there
are
ways
of
visualizing
huge
amounts
of
data
well,
and
so
we
could
totally
do
this.
We
could
totally
write
visualizations
that
help
us
debug.
That
help
us
understand
protocols
by
the
way.
Education
is
a
whole
other
thing
here,
where
we
could
script
this
to
go,
follow
a
potentially
user
input
and
tell
somebody
like
teach
somebody
about
a
protocol
by
carefully
scripting
the
events
and
waiting
for
user
input
before
moving
between
them.
A
So
you
could
explain
how
a
DHT
works
through
this
interactive
thing,
just
written
on
top
of
a
normal
event,
trace
of
the
protocol
you
and-
and
you
could
just
craft
that
event
trace
by
just
writing
the
the
event
log
yourself
like.
Maybe
you
record
something,
and
then
you
tuned
it
a
little
bit
for
for
the
right,
pedagogical
effect
right
look.
Maybe
you
reduce
the
amount
of
events
that
are
happening?
Maybe
you
pick
a
specific
interesting
edge
case
to
just
demonstrate
something.
A
So
that's
what
that's
the
kind
of
potential
of
tools
like
this
and
what
I
want
to
go
with
it
where
I
want
to
go
with.
This
is
make
this
general
enough
to
the
point
where
writing
a
visualization
for
a
specific
protocol
could
be
mounted
on
top
of
like
this
very
general
tool
that
does
all
of
the
event
our
radiation
and
the
option
setting
in,
like
all
the
heavy
lifting
of
the
orchestration.
So
as
we,
you
know
some
kind
of
like
modular
plug-in
thing,
but
that's
kind
of
where
this
headed
and
just
to
show
you.
A
Can
run
the
simulator
again
and
look
at
the
different
at
the
blockchain
visualization
and
what
that
does
is
it
shows
me
the
the
chain
a
so.
This
is
the
same
exact
thing:
it's
just
a
different
front-end.
That's
that's
looking
at
different
events
and
then
the
events
that
I'm
interested
in
here
just
the
block
announcements
from
each
node.
So
whenever
a
node
sees
a
block,
it
emits
an
event
and
whenever
a
node
picks
a
block
as
its
head
of
the
chain,
it
also
emits
an
event.
A
A
So
so
the
dark
number
here
that
we
see
in
the
bottom
is
how
many
nodes
have
seen
that
block,
and
the
blue
number
is
how
many
nodes
are
using
that
block
as
the
head
of
the
chain,
and
so
we
can
see
right
away
like
whether
or
not
we're
achieving
consensus
and
this
kind
of
going
fast
but
like
this
is
not
working.
These
things
are
converging
and
staying
so
here,
I
set
a
parameter
and
specifically
to
try
and
cause
it
to
4k.
A
If,
like
perhaps
you
know,
some
some
important
event,
there
is
like
getting
lost.
I
found
a
book
through
this
I
found
a
book
that
one
of
the
events
is
not
being
emitted
by
at
least
one
of
the
nodes
and
I
think
it's
the
node
that
generated
the
block
100%
sure,
but
you
look
at
the
cows.
They
don't
match
up
like
there's,
always
one
less
so
anyway,
it
right
away
like
the
fans
like
that.
A
So
this
is
just
you
know
a
different
front
end
and
you
could
totally
imagine
generating
a
bunch
of
different
front
ends
for
for
a
protocol.
So,
let's
just
see
kind
of
maybe
ipfs
like
a
bit
swap
front
end
to
see
kind
of,
like
your
bits
were
peers
and
how
much
bandwidth
you've
you've
sent
them.
What
the
want
list
is,
you
start
doing
a
bun.
You
know
these
very
focused
applications
just
on
that
protocol
and
mount
it
just
something
topple
the
exact
same
of
entries
right
any
questions
so
far.
A
A
We
we
possibly
could
get
it
to
the
brainy
fast,
but
we
wouldn't
need
to
start
doing
some
of
the
clever
like
maintain
running
too
many
chains
kind
of
a
many
heads
of
the
chain
at
once
and
then
finally,
some
I
are
getting
them
over
time.
That's
how
you
can
scale
through,
but
also
stuff,
like
charting
techniques
that
that
can
get
got
their
ghost
is
pretty
impressive.
Like
the
ghost
paper
claims
you
can
get
to,
you
know
one
or
two
second
lanes
here,
something
like
that
which
I
don't
think
anybody's
deployed
seriously
yeah
in
abortion.
A
Other
questions
is
that
currently
using
IP
TB
or
is
that
something
just
something
similar?
It
is
not
currently
using
epi
TV
it
should.
It
was
just
kinda
like
a
historical
reason.
Why
wait
why
it
didn't
start
it
with
that,
but
it
totally
should
be
a
reason
to
apply
to
be
a
BB.
All
right
sounds
good.
Thank
you.