►
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
Hello,
everyone
and
welcome
to
the
distribution
team
demo
for
december
2nd
I'm
just
going
to
share
my
screen
here
start
with
so
early
in
the
week.
We
didn't
have
a
demo
volunteer,
so
I'm
just
going
to
use
this
time
to
show
a
little
bit
of
you
know:
debugging
tools
and
tricks
related
to
the
rails,
console
and
kind
of
specific
to
things
that
we
often
might
end
up
doing
in
distribution.
A
So
that's
kind
of
the
two
things
we'll
often
do
in
the
rails
console
is
use
it
to
confirm
that
a
setting
that's
been
applied
through
omnibus
and
through
the
charts
has
actually
made
it
into
the
code
base
in
a
way
that
it
can
actually
be
checked
within
the
running
application
and
the
other
is
when
that's
not
working
trying
to
debug.
Why
that's
not
working!
So
that's
that's
kind
of
the
an
often
case
for
for
that.
A
But
when
you
load
the
console,
there's
a
couple
things
that
are
kind
of
loaded,
the
in
scope
at
the
time
and
there
it's
these
console
methods
and
you
get
these
five
methods
by
default.
That
kind
of
help
you
set
up
the
environment
as
if
it
was
something
happening
in
the
real
live
rails
application.
So
when
you
load
the
console,
it's
your
own
rails
instance.
A
But
what
it's
missing
is
it's
not
it's
not
you
know
running
a
web
server,
it's
not
you
know
receiving
any
requests
or
traffic,
and
so
a
lot
of
the
code
in
the
application
is
relying
on
expecting.
You
know
there
to
be
a
session,
potentially
with
a
current
user
coming
from
the
browser
for
there
to
be
application,
controller,
that's
actually
being
accessed
at
the
moment,
for
example,
and
for
you
know
the
app
to
be
fully
loaded.
A
A
I'll
just
bring
it
over
here
is
that
we
were
trying
to
test
a
new
setting
for
adding
a
google
tag
manager
id
to
the
application,
so
the
id
had
to
be
added
through
omnis
and
charts,
and
then
we
wanted
to
confirm
that
that
setting
was
being
actually
making
it
all
the
way
through
to
to
the
application
in
a
way
that
is
actually
being
used.
So
in
the
application,
one
of
the
main
sections
that
it's
called
that
we're
using
for
debugging
is
in
the
off
helper.
A
A
A
A
A
A
We
were
specifically
testing
the
the
nonce
earlier
well,
actually
yeah
we'll
supposed
to
still
doing
the
knots.
So
that's
this
one.
The
image
I'm
in
is
a
merger
quest
still
working
products.
So
one
of
the
things
that
is
open
to
fixing
it
is
that
this
example
template
was
a
little
bit
wrong.
It
was
missing
the
extra
prefix
in
there
and
we're
not
actually
going
to
have
this
do
anything.
So
I'm
just
going
to
leave
the
default
text
as
just
just
to
have
it
enabled.
A
A
A
And
then
coming
over
here
and
running
our
console
again
when
we're
testing
this
in
the
charts
we
just
used
self-signed
certificates,
as
they
just
kind
of
auto,
get
set
up.
If
you
turn
off
cert
manager
in
the
chart,
it's
like
a
couple
minutes
more
work.
They
do
the
same
thing
for
on
the
bus
and
I
didn't
bother
doing
that
for
this
demo
so
doing
this
instead,
but
you
could
set
up
a
self-signed
certificate
instead
of
having
to
modify
the
code
to
get
around
that.
A
In
the
rails
code
base,
the
casing
is
wrong
and
always
has
been
so
off.
This
config
object.
You
can
index
any
of
the
get
lab
yml
settings,
so
we
know
ours
is
under
so
this
setting
happens
to
go
under
the
extras
under
extra,
so
we
can
see
it
got
set
in
there
as
well,
so
we
we
know
that
the
setting
made
it
through
from
omnibus
into
into
the
rails
application.
Often
this
is
you
know
for
a
lot
of
our
settings.
A
This
might
be
the
extent
of
what
we
have
to
test
for
omnibus
just
to
know
that
it
made
it
in.
You
know
it's
it's
kind
of
up
to
the
rails,
application
for
the
mr.
We
were
looking
at
that
made
this
change.
We
were
also
wanting
to
make
sure
that
it
made
it
into
the
ui
and
that
this
tag
actually
got
rendered
and
we
could
find
it
on
the
sign
up
page.
A
A
A
And
you
know
it
was
calling
into
extra
config,
which
is
provided
by
a
completely
separate
helper.
So
that's
you
know.
When
you
run
into
this
when
you're
dealing
with
helpers,
often
they
are
calling
things
from
other
helpers
and
we
on
on
kind
of
a
side
tangent.
Here
we
ended
up
in
this.
This
else
condition
which
is
fine,
but
we
can
also.
A
A
A
In
the
page
where
you're
on
you
saw
there
was
this
this
helper
method
in
the
console.
So
that's
one
of
the
ways
you
can
load
the
helper.
So
if
you
call
helper
it
gives
you
an
and
kind
of
a
scope
of
all
all
of
the
helpers
for
view
helpers
yeah.
It
gives
you
this
action
view,
so
we
can
actually
call
any
helper
off
of
it.
A
So,
instead
of
calling
off
helper
dot,
the
method
we're
looking
for,
you
can
just
call
helper
and
it
will
often
have
access
to
all
of
the
helpers
being
loaded
in
this
case
it
won't.
But
that's
because
this
is
will
be
an
example
of
something
even
a
little
bit
more
complicated,
so
we're
calling
it
off
of
helper
that
now
loaded
it
as
a
helper
with
all
of
the
other
helpers
and
now
had
extra
config.
A
So
we
no
longer
get
that
issue,
but
you
see
we
run
into
a
different
issue:
undefined
method,
current
user.
So
current
user
is
a
helper,
but
it's
not
one
that
we've
built
into
the
gitlab
rails
application.
It's
one
provided
by
a
gem
called
device
which
handles
our
sessions
and
logins
and
signups
and
stuff
like
that
and
the
way
it
does
it
is,
it
doesn't
add
its
helpers
until
controller
is
actually
loaded.
A
So
when
a
controller
is
loaded
that
extends
from
a
device
controller,
it
has
like
a
hook
that
during
load
action,
it
injects
this
current
user
helper.
So
we
actually
haven't
had
any
load
action
like
we're
in
a
console.
We
haven't
loaded
any
controller.
We
haven't
loaded
up
a
request
or
anything
like
that,
so
this
helper
was
never
ever
added,
so
it
doesn't
exist
and
we're
having
a
hard
time
testing
this
helper.
A
So
there's
a
couple
things
you
can
do
so
we
could
explicitly
load
the
device
helpers
and
there's
a
couple
ways
we
could
do
that
we
could
trigger.
We
could
just
trigger
the
load
event,
which
is
like
it's
like
this
isn't
important,
because
we're
actually
gonna
do
this,
but
it's
like
call
on
load
and
then
this
is
an
action
controller.
A
And
that
happens
to
be
the
thing
that
device
is
listening
for
is
the
onload
events
for
action
controllers,
and
we
could
we
could
load
that
up.
But
if,
if
you
do
that-
and
you
call
us
again,
what
will
happen
is
it'll
still
err.
It
just
won't.
Err
on
this
method,
it'll
err
on
the
fact
that
it
can't
actually
get
the
current
user,
because
we're
missing
a
request
and
that's
where
users
come
from.
You
know
on
the
request,
object
session,
ids
and
that
will
be
missing.
A
So
this
this
is
kind
of
the
really.
What
I
was
trying
to
get
at
in
in
this
call
is.
The
next
thing
is
when
we
have
a
piece
of
code
we're
trying
to
debug
and
it's
expecting
to
be
run
in
the
rails
environment
that
actually
is
running.
You
know
a
web
server
and
requests,
and
you
know,
is
loaded
in
a
controller
and
has
a
route
and
and
all
these
things
like,
how
do
we
test
that,
and
so
the
the
answer
to
that
is
this
app
helper
in
the
console.
A
A
A
And
controller
objects
so
you'll
notice.
These
aren't
returning
like
method
not
found,
but
they
are
nil.
So
the
helper
methods
actually
also
chain
off
of
controllers,
but
we
don't
have
a
controller,
but
that'll
come
here
in
a
second,
so
we
don't
have
any
of
this
stuff,
but
we
have
the.
We
now
have
the
kind
of
the
vehicle
that
normally
has
that
information,
the
application.
A
So
how
do
we
make
it?
Have
that
information?
Well,
you
you
just
tell
it
to
actually
do
a
request.
So
in
the
application
you
can
simply
do
a
get
request
that
won't.
It
isn't
actually
like
going
over
the
network
or
anything
like
that.
It's
like
within
the
routes
and
context
of
the
running
application
without
using
you
know,
an
http
stack
just
running
the
code
that
at
the
rails
app
standpoint.
That
would
happen
if
one
did
come
in,
so
it
doesn't
actually
matter
for
this
test.
A
A
App
request
is
now
populated
and
quite
interestingly,
if
we
do
controller
it's,
we
actually
have
a
controller
populated
for
the
controller
that
responded
to
that
request.
So
now,
like
everything
in
the
application,
is
populated,
there's
even
a
view
because,
like
the
view
that
was
rendered
has
been
populated,
so
kind
of
everything
has
been
populated,
and
the
final
thing
we
can
do
is,
as
I
mentioned
before,
the
controller
method
has
the
helpers
scope,
which
gives
us
an
action
view
that
is
scoped
to
all
the
helpers.
A
A
So
when
you're
dealing
with
a
helper
that,
like
you're,
trying
to
debug,
why
it's
not
enabled
or
why
it's
not
doing
what
it's
doing.
You
might
run
into
these
sorts
of
problems
where
it's
a
little
bit
difficult
to
validate
that
the
you
know
the
simple
view
helper
is
actually
working
the
way
you
want,
because
you're
running
into
difficulties
that
it's
expecting
a
it's.
You
know
expecting
to
not
be
what
we
saw.
It's
it's
not
expecting
to
be
loaded
in
isolation.
It's
a
helper.
It's
expected
to
be.
You
know.
B
A
A
Sometimes
it'll
work
fine
like
for
these
methods.
Here
you
see,
you
know
they
explicitly
call
other.
You
know
static
methods
on
other
classes,
that
you
know
these
might
have
their
own
issues,
but
likely
not
based
on
the
you
know
way.
They're
called
they
probably
would
have
been
fine,
but
anything
that
is
now
relying
on
helpers
like
we
know
that
anything
with
a
current
user,
for
example,
is
relying
on
their
being.
A
C
A
I
don't
know
that
this
is.
This
is
documented
anywhere,
so
this
is
yeah.
This
is
kind
of
it's.
It's
documented
in
like
ruby
on
rails
documentation
and
we
probably
call
out
generally
to
it,
but
I
don't
think
it's
called
that
specifically,
and
it
would
be
interesting
to
call
it
out
for
us
because
you
know
a
we're,
not
always
in
the
in
the
rails
code
base.
A
C
A
A
Dimitri
might
have
run
into
different
issues,
but
for
whatever
reason
we
wanted
to
validate
separate
from
the
ui
and
debug.
What
was
like
holding
us
up
like
did.
We
forget
to
you,
know,
make
it
a
dot-com
instance.
Did
we
forget
to
enable
the
feature
flag
type
thing?
So
that's
why
we
we
dove
deeper
in
this
case
so
yeah
often
you'll.
You
know
when
things
are
working
well,
you're
likely
just
be
checking
for
distribution
you're
off
and
just
be
checking
that
it
made
into
the
application.