►
From YouTube: Kubernetes SIG Service Catalog 20161129
Description
SIG service-catalog continues discussion of next steps after code drop, as well as design discussion around unbind.
Agenda - https://docs.google.com/document/d/10VsJjstYfnqeQKCgXGgI43kQWnWFSx8JTH7wFh8CmPA/edit
A
All
right,
hello,
everybody
welcome
to
the
October
29
2016
special
edition
of
the
brunette
e-cig
Service
Catalog,
where
we
left
off
our
heroes
were
discussing
the
discussing
directions
forward
and
next
steps.
After
the
the
code
drop
I.
Think
any
of
you
that
have
been
paying
attention
in
the
in
the
github
repo
have
seen.
There's
been
a
lot
of
movement
today.
We've
already
got
some
folks
that
are
acting
on
those
next
steps,
and
so
let
me
let
me
kick
this
conversation
off
by
by
drugging
everybody's
memory.
A
The
last
thing
that
we
discussed
in
yesterday's
meeting
were
some
some
code
moves
of
the
brokers
to
contributors
and
examples.
Two
examples
there
have
been,
as
I
said,
some
other
subsequent
pull
requests
today
that
have
been
along
the
lines
of
making
the
project
structure
more
similar
to
coop
Nettie's,
which
I
think
is
a
good.
You
know
now
I
wonder
from
the
discussion
yesterday.
A
B
A
I
agree:
I.
I
will
put
that
on
the
agenda
up
for
today
and
I
I
think
that
is
a
good
thing,
but
not
especially
in
trinsic
to
yesterday's
conversation.
So
any
any
other
hanging
hanging
chads
from
yesterday
that
we
need
to
to
dress.
C
A
C
Sure
we
I
created
issue
50,
we
had
discussion
in
slack,
there
were
a
bunch
of
alternative
possibilities,
brought
up
I,
think
poll
approve,
I
or
calm,
or
something
was
brought
up.
I
had
never
heard
of
it.
So
I
did
some
research
on
that.
We
had
Garrett
for
github
brought
up,
and
then
we
also
still
have
the
current
situation
where
we
put
LG
tiemz
and
I'm
assuming
vetoes
into
comments
which
is
still
on
the
table.
I
believe
as
a
an
option
I
put
at
the
bottom
of
that
issue.
C
A
A
A
It
can
be
lgtm,
modular
knits
in
a
comment
and
if
we
choose
to
go
with
this
labels
thing
don't
apply
the
label,
but
if
something
needs
to
get
fixed,
it
is
not
lgtm.
In
my
opinion,
unless
there
is
a
explicit
agreement
that
it
can
be
fixed
in
a
follow-up
which
is
something
that
happens
with
some
regularity,
any
thoughts
about
that.
A
D
B
A
Yeah
and
I
actually
don't
think
that
we
were
enforcing
the
timeout
rigidly
today,
I
I'll
be
honest
with
you.
Folks,
I
think
that
the
moves
and
stuff
that
we're
doing
out
are
probably
not
ones
where
veto
is
likely.
I
think
that
it
is
sufficient
to
me
to
have
a
gentle
person's
agreement
amongst
us
all
that
will
act
in
good
faith
and
we'll
use
our
best
judgment
about
when
something
may
be
controversial
and
I
think
you
know
so
to
make
expedient
progress
on
things.
A
Everybody
agrees
on
that
are
below
impact
that
it's
probably
not
especially
necessary,
but
I
think
that
the
you
know
being
a
good
citizen
is
part
of
like
if
there's
a
dimension
of
doubt
I,
and
you
think
there
is
some
ambiguity-
that
it
is
polite
to
let
the
time
lapse.
I.
B
Totally
agree
to
a
favorite
expediency,
in
absence
of
doubt,.
A
One
experience
that
I've
learned
with
Cooper
Nettie's
is
that
it
can
happen
without
warning
that
suddenly
everybody
will
want
to
jump
into
the
pool.
So
if,
if
we
could
get
a
volunteer
to
produce
a
document
I
with
this
information
that
goes
into
the
repo
and
a
pull
request,
I
think
that
would
be
great.
It
sounds
like
we're
we're
very
close
to
agreement,
and
probably
we
can
work
through
any
remaining
nits
in
a
pull
request.
Anybody
disagree.
E
A
Okay,
my
own
my
own,
take
on
this
is
that
lgtm
three
as
a
label
is
meant
as
an
attestation
that
a
specific
person
said
that
it
was
lgtm
I,
think
it
can
have
lgtm
three
and
the
under
the
best
judgment
rationale.
If
it's
not
controversial,
if
no
one
expects
it
to
be
controversial,
it's
probably
okay
to
merge.
If
there's
any
dimension
of
doubt
what
the
timeout
elapsed
be
a
good
citizen
and-
and
you
know
given
give
it
a
day
with
that
said-
I
the.
A
If
we
continue
meeting
more
frequently
than
once
a
week,
probably
much
of
the
work
that
is
done
will
already
have
been
discussed
over
some
type
of
video
chat
or
in
person
me
being
optimistic
about
everybody's
travel
budget
there.
So
for
things
like
that,
it's
probably
it
also
probably
lowers
the
need
to
have
the
the
time
out.
But
again,
this
is.
This
is
an
area
where
good
judgment
and
being
a
good
citizen
are
very
important,
and
we
can.
A
C
C
F
So
rather
focus
on
the
LTM
3.
I'd
still
like
to
understand
the
need
for
the
lgtm
labels
at
all.
I
don't
understand
what
value
they
bring
a
guy.
I
can
understand
a
label
that
says
this
thing's
ready
to
get
merged
and
we're
just
waiting
for
the
time
out,
but
I
don't
understand
the
one
two
and
three
I
gotta
be
honest:
okay,.
A
F
G
F
I
do
think
it's
unnecessary,
I
mean
I,
don't
see
the
difference
between
12
and
ready
to
merge,
wedding,
I'm.
Sorry
I,
don't
understand
the
difference
between
just
to
put
in
a
number
there,
because
it
doesn't
tell
me
anything:
I
can't
query
on
it
for
any
purpose.
Other
than
that
I
can
know
someone
has
lgtm
dip.
It
doesn't
tell
me
whether
I
have
or
not
so
it
doesn't
reduce
the
list
of
things
that
I
need
to
look
at.
If
I
do
query,
I
just
don't
see
the
point.
Ok,.
A
Then
Aaron,
perhaps
you
or
someone
else
from
Deus,
can
explain
the
rationale.
Do
you
do
you
feel
that
there
is
a
value?
Add
for
labels,
/
comments,
I'm
completely
agnostic
on
this
mechanism
for
the
record
I
lat.
D
So
I
do
personally
feel
that
there's
a
value
to
it,
I
know
I'm.
So
at
dais
we've
been
working
this
way
for
a
long
time,
I'm,
certainly
not
advocating
that
we
do
this
just
because
it's
familiar
with
I
do
actually
believe
there's
value
to
it.
A
lot
of
us
have
created
queries
that
we've
bookmarks
that
allow
us
to
look
at
individual
projects
or
across
many
projects,
and
look
very
quickly
and
easily
at
things
that
make
our
attention.
D
Doug
has
made
some
very
good
points
about.
You
know
it
if
we
don't
all
have
our
own
personalized
labels,
you
don't
really
have
a
way
of
saying.
Okay,
find
me
of
the
things
that
I
haven't
already
approved,
and
that's
absolutely
true,
but
you
know
this
is,
I
would
say
I
would
qualify
it
as
good
enough.
You
can
write
a
query
where
you
can.
You
can
look
at
openwork
items
have
not
received
the
required
number
of
lgtm
or
have
not
been
vetoed
or
so
forth
or
so
on.
D
You
can
query
along
those
dimensions
and
you
can
see
in
the
index
you
a
list
of
things
that
might
deserve
your
attention.
So
you
know
as
a
for
instance,
if
you
query-
and
you
know,
50
different
PRS
come
up,
and
one
of
them
has
three
lgtm
and
many
many
others
do
not.
You
might
not
want
to
focus
your
attention
on
the
one
that
has
three
LG
TMS
already.
You
might
want
to
sit
and
spend
your
your
efforts
elsewhere.
D
F
No
because
to
be
honest,
if
there's
one
out
there
that
has
three
lgtm
zacks,
that's
actually
one
that
I
would
focus
on
it,
try
to
look
and
see
why
we
couldn't
push
it
over
the
line.
It
seems
to
me
that
you
get
the
exact
same
effect
by
doing
a
query
that
says,
find
me
a
PR.
That's
you
know
over
a
day
old
and
has
not
been
vetoed.
It
has
a
comment
with
Dell
DTM
in
it
somewhere.
Absolutely
if
you
don't
want
the
exact
same
result,
so
Doug.
D
F
D
Wet
weather,
okay,
so
whether
whether
the
labels
are
there
for
the
sake
of
avoiding
particular
PRS
or
for
targeting
particular
PRS
is
really
kind
of
inconsequential.
The
important
thing
is
that
the
metadata
exists
so
that
you
can
query
along
whatever
dimensions
matter
to
you.
It's
not
it's
not
for
me
to
say
what
what
what
matters
to
you
or
for
you
to
say
what
matters
to
me,
but
as
long
as
metadata
is
there
we
we
can
both
work
as
we
please
yeah.
F
I
know
what
you're
saying
I:
if
that's
what
you'll
want
to
do?
That's
fine,
like
I
said
I
can
live
with
just
that
anything
just
I.
Just
it's
just
extra
work
for
people
to
do
it
because
I
typically
forget
to
do
labels
I'm
constantly
being
reminded
by
the
doctor
guys
to
update
the
labels
appropriately
and
I.
Can
just
tell
you
it's
just
another
thing
that
I
forget
so
liking.
H
E
H
Is
but
we're
talking
about
mechanics
and
I,
haven't
really
heard
or
seen
a
concise
description
of
what
behaviors
or
what?
What
are
we
trying
to
accomplish
with
said
mechanics
like
what
is
the?
What
is
the
thing
we're
trying
to
ensure
does
or
does
not
happen,
and
if
you
can
describe
that
in
English,
then
maybe
we
can
stay
hey.
We
could
solve
this
in
15
different
ways.
H
A
A
But
basically,
I
think
the
the
point
of
this
mechanism
is
to
ensure
that
everybody
has
time
to
review
in
that
the
the
reviewers
or
that
that
each
change
is
reviewed
in
attested
to
its
fitness,
to
go
in
by
at
least
three
people,
but
now
I
I
will
interject
also
into
my
own
sentence
that
I
I
think
that
there
are
that
there
are
other
things
that
have
a
higher
utility
to
address
as
a
group,
and
so
what
I
propose
is
that
we
take
about
30
seconds
if
anybody's
strongly
disagrees
that
this
is
movement
in
the
right
direction.
A
A
Does
anybody
have
any
reservations
that
are
strong
enough,
that
they
think
we
should
fundamentally
reassess
what
has
been
discussed
so
far
I
and
continue
to
spend
time
on
it
here
with
the
knowledge
that,
if
a
need
arises
that
we
can
easily
bring
this
back
up
for
discussion
further
elaboration
for
their
formal
outlining
of
what
we
think
lgtm
is.
H
Well,
you
know
I'm
wondering
if
it's
been
explicitly
stated
that
the
three
LG
TMS
can't
be
from
the
same
organization
right
like
if
three
of
the
Google
guys
all
lgtm,
a
google
PR
that
doesn't
seem
like
the
right
thing
right
or
it
you
know
substitute
any
other
organization.
I
mean.
Is
it
should
they
be?
H
Some
sort
of
the
lgtm
should
be
coming
from
different
entities
or
you
know
you
get
one
vote
per
company
or
like
I,
don't
know,
I
mean
obviously
nobody's
gonna,
try
to
use
anything
but
I'm
I'm
just
trying
to
get
at
what
is
the?
What
is
the
end
goal?
We
want
to
make
sure
that
you
know
we're.
All
in
agreement
is
community
right,
so.
A
That,
yes,
that
is,
that
is
correct.
We
haven't
discussed
the
need
for
different
companies,
I'm
willing
to
give
this
another
five
minutes.
If
we
would
like
to
discuss
that
now,
but
I
will
know
so
far,
I
don't
think,
there's
been
any
situation
where
in
lgtm
has
come
from
more
than
one
person
at
a
particular
company
on
a
particular
issue.
I
think
we've
kind
of
we've
been
informally
doing
that
so
far,
I
would
support
making
it
formal.
If
that's
what
the
group
has
appetite
for.
B
Another
another
point
is:
if
we
are
intuitively
doing
the
right
thing,
do
we
need
a
set
in
stone
process
codified?
That
actually
brings
up
a
lot
of
controversy
because
we're
getting
into
the
legal
speak
and
hands
the
which
is
written
down.
The
intent
gets
gets
hidden
in
the
corner
cases
that
arise
so.
C
A
Okay,
I'm,
sorry,
but
you
appear
to
be
outnumbered,
so
Aaron
I
think
if
you
will,
if
you
will
proceed
as
we've
discussed
here,
if
you
would
like
to
just
make
a
note
in
the
issue
as
to
what
you're
going
to
do,
that
would
be
good
and
I
would
I'm
totally
fine
continuing
to
have
the
governance
like
discussions,
but
we
do
need
to
be
conscientious
about
how
we
allocate
time.
A
Alright
I
hear
no
dissent
new
descent,
all
right.
So
let
me
let
me
share
a
link
in
the
chat
to
an
issue
that
I've
created.
A
A
So
we
in
the
face
to
face
meetings
that
we
have,
we
had
really
good
productive
consensus
around
the
generals.
Shape
of
things
usage
of
the
API
up
through
the
following
someone
adds
a
broker.
The
the
controller
has
a
watch
on
the
broker
resource
goes
and
can
like
it's.
The
B
to
catalog
endpoint
gets
the
service
classes
from
the
broker
/
system
into
the
API
server.
A
service
consumer
says:
hey
I'm,
on
an
instance
of
the
service
class.
They
create
an
instance.
A
Controller
goes
and
calls
the
provision
endpoint
and
controller
updates
the
the
status
of
this
resource
later
service
consumer
says
I
want
to
do
a
binding
against
this
instance
and
we've
gotten
up
through
the
constructive
portion
of
this
right,
like
we've
gotten
to
the
point
from
empty
catalog
to
now,
I've
got
an
application
with
a
binding
and
I.
Think
a
logical
next
step
to
discuss
is
what
happens
when
you
want
to
do
an
unbind,
so
the
the
precedent
that
we
have
for
this
in
Coober
Nettie's
is
in
storage
for
persistent
volumes
and
persistent
volume
claims.
A
This
doesn't
analogize
perfectly
to
the
Service
Catalog
world,
because
once
you
declare
your
intent
to
unbind,
there's
work
that
has
to
be
done.
So
it's
not
as
simple
as
you
delete
a
resource
and
then
it's
gone
and
the
controller
can
figure
that
out
right,
because
the
controller
has
to
ensure
that
if
it
misses
the
delete
event
that
it
can
still
have
a
way
to
understand
that
it
has
to
go
and
do
something
without
keeping
a
local
cache
on
that
persists
across
controller
restarts.
A
A
Right,
so
this
is
my
just
it's
not
all
the
top
of
my
head
impression
of
how
we
could
use
this
pattern
in
a
Service
Catalog,
but
it's
it's
a
possibility.
I've
spent
a
little
time
mulling
over
and
so
this
this
diagram
should
look
familiar
to
everybody
on
this
call.
A
At
this
point,
it's
a
simplified
version,
because
I
think
we've
probably
all
got
this
in
our
heads-
I'm
happy
that
to
add
any
more
detail
if
its
desired,
but
basically
I,
just
I
I've,
written
down
the
material
posts
and
yet
some
cuts
that
are
essential
to
understanding
the
API
flow
that
I've
described
so
far.
Everybody
cool
with
what's
on
this
board,.
A
I'm,
not
here,
no
okay,
so
here's
my
here's,
my
I
would
call
it
a
pitch.
Let's
just
call
it
a
thing:
here's
my
thing
so
going
to
use
green
for
new
stuff
and
we've
already
done
a
post
on
this
binding,
so
the
binding
exists.
The
protocol
that
we've
all
discussed
so
far
has
been
carried
out
where
I
posted
I'm.
A
Case
the
service
consumers
posted
the
binding,
it's
gone
into,
the
API
server,
persisted
and
EDD
controller
has
watch
on
API
server
and
it's
gonna
put
on
the
e2
service
instance
by
names.
Endpoint
on
the
program.
Alright,
and
so
life
is
good.
Life
is
good
and
I
say:
hey
now,
I
want
to
unbind
from
this
thing,
so
analogizing
imperfectly
to
the
current
precedent
that
we
have
for
this,
save
it
to
declare
my
intent
to
do
to
unbind
I.
Do
a
delete.
A
On
this
binding-
and
at
that
point,
what
happens
is
that
the
the
rest
api
says?
Okay,
the
service
consumer
wants
to
delete
this
resource
and
instead
of
going
out
and
carrying
out
the
delete,
we
we
know
that
there
is
some
work
that
has
to
be
done.
A
So
we
need
to
keep
this
this
resource
around
and
put
it
into
a
record
somehow
on
its
status,
that
it's
being
deleted
or
being
unbound
or
being
finalized
name
TBD,
but
that
we're
entering
the
endgame
for
this
resource
so
say,
for
example,
that
the
the
rest
api
records
a
condition
in
this
binding
status.
That
says
this.
This
has
a
deleting
condition.
That's
true,
and
so
what
happens
after
this
is
that
II,
the
API
server
gives
back
at
203
accepted
202.
F
A
A
A
The
controller
has
a
watch
on
this
binding
resource
and
says:
I've
got
an
update
event
for
this
binding
and
I
see.
The
leading
condition
is
true
and
here's
where
I'm
going
to
call
on
Brendan,
because
I
think
he
is
most
familiar
with
the
ins
and
outs
of
the
API.
At
that
point,
controller
will
invoke
on
the
broker
the
unwind
operation.
Brendan.
Do
you
happen
to
know
the
request
and
Method
combination
that
is
to
be
used
with
service
broker
API?
To
do
that?
I
think
it's
just
to
delete.
A
A
Depending
on
what
it
gets
back,
the
controller
can
continue
doing
this
until
it
gets
a
200
back
now
say
they
say
that
this
is
happy
land,
and
this
happens.
You
get
your
200
back
the
first
time.
Life
is
good,
so
what
controllers
going
to
do
is
and
here's
where
we
get
into
kind
of
low
level
stuff.
A
So
like,
let
me
let
me
push
your
frame
onto
the
stack,
did
ization
pattern
and
Cooper
Nettie's
is
applied
in
namespaces,
and
the
way
it's
implemented
is
that
there
is
a
part
of
the
spec
which
is
the
list
of
finalized
errs
that
have
to
run,
and
so.
A
In
this
model,
we'd
have
a
part
of
the
binding
spec
that
was
like
list
of
finalized
errs
and
right
now,
I
can
just
be
a
list
of
lists
of
one
which
is
the
controller
finalizer,
so
the
controller
will
do
an
update
then,
and
here's,
where
is
where
this
like
diagram
is
starting
to
break
down,
will
have
to
decide
on
a
new
diagram
convention.
So
so.
E
Paul,
yes,
we
will
so
this
is
sort
of
kind
of
what
I
was
worried
about
or
I
wanted
us
to
spend
a
little
bit
of
time
talking
about
in
Seattle,
when
I
said
that
we
need
to
have
state
machines,
because
we
are,
we
talked
about
defining
an
API,
but
we
are
not
really
defining
an
API.
You
are
defining
bunch
of
resources
and
then
there's
some
behaviors
that
go
with
them,
and
we
are
going
very
deep
into
delete
here.
E
E
A
Machine
so
the
way
I
agree
with
you
and
I
chose
the
binding
as
an
example.
That's
the
simplest
because
we
don't
have
to
talk
about
cascading
deletes
with
bindings,
since
it's
like
a
leaf
node.
Oh
sure,
so.
I
expect
that
we
can
probably
use
this
to
like
illustrate
some
core
concepts.
And
then
we
need
to
have
discussions
about
every
other
resource
and
I,
like
this
fair.
E
Well,
it's
even
in
the
create
case.
It
needs
to
do
a
couple
of
things.
It
needs
to
call
a
protocol
to
go
ahead
and
create
the
binding
and
then,
if
probably
immediately
die
after
that
right,
then
there's
also
a
secret
and
service
instance.
What
if
we
call
it's
the
injector
policy
and
things
like
that
community
crew,
so
it
seems
like
we
should
have
a
similar
mechanism
that
we
use
a
PPS
to
describe
the
state
that
the
the
resource
can
be
at
any
given
point.
E
A
I
think
it's
not
uniquely
special,
but
it's
different
from
the
the
flows
that
we've
discussed
before,
because
this
is
where
we're
entering
the
territory
of
we
need
to
have
like
fairly
a
high
degree
of
control
over
the
actual
REST
API
implementation
to
implement
this.
Does
that
make
sense
like,
like
the
the
flows
we've
discussed
so
far,
are
like
you
declare
your
intent
by
creating
a
resource
and
now
we're
getting
into
you
declare
your
intent
by
deleting
a
resource,
but
your
resource
is
not
initially
actually
deleted.
A
There's
some
things
that
have
to
happen
and
we're
talking
about
the
interplay
between
the
the
deletion
at
the
API
server
and
the
controller,
and-
and
this
is
where
I'll
I'll
pop
a
frame
off
the
the
stack
in
this
conversational
stanza
and
say.
I
think
this
is
this
head.
You've
correctly
pointed
out.
There's
there
are
other
concerns
like
this.
A
That
I
think
this
discussion
kind
of
helps
to
ground
and
socializes
the
idea
that,
like
we
need
some
degree
of
control
over
the
actual
rest,
api
implementation
that
backs
the
api
that
we
don't
currently
have
and
that
we're
gonna
have
to
employ.
To
use
this.
To
make
an
API
that
works,
the
way
I
works
in
a
sensible
way
does
that
make
sense.
I.
A
Mean
I
actually
I
think
this
is
really
good
that
you
raised
this
because
I
like
be
late.
Vla
has
raised
a
very
important
point
because
there
there
is
this
issue
of
like
we
still
need
to
talk
about
unbind
or
I'm.
Sorry,
we
still
need
to
talk
about
any
provision.
We
still
need
to
talk
about
what
happens
when
you
go
and
delete
a
broker
right
like
and
in
fact,
on
the
subject
of
deleting
brokers.
I
think
there's
a
fair
amount
to
talk
about
these
Ivy
cascades,
these
a
via
leaving
workmen
things
in
what
happens.
E
So
bleh
I
think
about
this
for
right
or
wrong.
Is
that
when
you
create
the
resource
it
so
when,
whether
it's
a
post
instance
or
whether
it's
you
know,
keep
control
create,
you
know,
whatever
service
are
blinding
whatever
else
a
resource
is
created,
and
then
it
takes
on
a
life
of
its
own,
that
is
controlled
by
the
controller
yeah
and
the
way
that
the
David
resource
is
communicated
and
user.
On
the
left
there
on
the
on
the
diagram
you
drew
is
via
conditions,
yeah,
I.
B
E
A
E
With
what
you're
saying
and
if
those
are
states,
then
it
seems
like
maybe
we
could
take
the
binding,
maybe
step
back
a
little
bit
more
and
say:
let's
go
ahead,
I.
So
first
of
all,
I
love
this
discussion,
because
I
think
we
need
to
have
this,
and
this
is
kind
of
what
I
was
hoping
we
would
have
in
Seattle.
We
didn't
get
around
to
it
yet,
but
was
the
state
machines
like
what
what's
they
can
resource
be
in?
Let's
say
it's
a
binding
and
what
are
the
possible
states
that
it
can?
E
A
Yeah
so
that'd,
that
is
a
really
good
point
and
I
actually
have
a
pull
request.
That
adds
certain
conditions
to
the
API
types
that
we
I
saw
the
ball,
but.
E
E
No
I
was
gonna
say
I
saw
that
I
was.
I
was
curious,
how
you're
going
to
drive
that
in
with
this
one
and
the
discussion
and
so
forth,
and
I'm
not
sure,
well,
I
guess
the
first
question
is:
is
how
should
we
go
about
defining
the
state
machine?
What
is
the
mechanism
of
that?
Should
it
be
something
like
just
a
state
machine
diagram
with
the
things,
or
is
that
going
to
be
a
fancy-pants
markdown
document
or
how
look?
A
A
My
read
of
this
group
and
my
own
personal
predilection,
is
towards
having
some
kind
of
document
that
describes
this
in
some
way,
so
that
you
can,
you
can
look
at
it
as
someone
who
wants
to
understand
how
the
system
works
and
say
say
to
yourself:
oh
okay.
Well,
this
is
what
this
API
condition
means.
I.
A
A
A
Let's
see
I
I
made
an
attempt
to
begin
describing
conditions
and
I
would
be
happy
to
have.
You
know
people's
feedback
on
this,
since
it's
basically
around
what
has
been
discussed
so
far,
I
made
an
attempt
to
incorporate
the
shins
of
the
different
API
resources
that
were
dealt
with
in
this
pull
request
into
it.
So.
F
So
Paul,
since
we
only
have
13
minutes
left,
was
the
point
that
your
discussion
in
the
chart
are
the
stuff
on
the
whiteboard
to
get
into
the
way
we
determined
that
something
in
the
process
of
being
deleted,
or
was
it
more
about
the
elite
process
of
rugs?
I
thought
I
was
more
about
the
elite
process
and
not
about
conditions
versus
a
state
property.
F
A
Kind
of
touched,
both
of
them
and
basically
the
the
primary
point,
though
it
was
to
get
folks
thinking
about
thinking
about
this
because
I,
you
know,
I,
don't
I'm
not
interested
in
being
dictatorial
and
the
the
consensus
and
socialization
of
of
these
concepts
is
really
what
matters
rather
than
what
any
one
person
wants
to
do.
So
I
don't
expect
to
Korea
agreement
on
this
I
wanted
to
expose
the
concept
if
there
were
not
any
strong,
like
knee-jerk
reactions
against
it.
F
B
F
The
only
question
I
would
have
is
on
subsequent
deletes
from
the
end-user
perspective.
I'm,
assuming
those
are
pretty
much
no
ups,
as
opposed
to
he
will
redo
the
lazy
delete
mechanism,
meaning
let's
say,
for
example,
the
lazy
mechanism
or
the
the
indication
that
something
is
going
to
be
deleted.
Is
you
set
the
deleted
timestamp
right
from
Mel
to
current
time,
each
subsequent
delete
from
the
end
user
does
not
re
update
that
timestamp?
It's
a
no
up
right,
yes,
yeah!
That
would
be
the
only
question
I
would
have
in
my
mind.
Ok
yeah.
A
So
this
is
actually
the
we're
getting
now
back
to
the
point
where
the
then
I
was
started,
describing
I
and
it's
kind
of
a
messy
thing
to
talk
about
right,
because
it's
like
all
right,
so
you
gotta
delete.
You
did
a
delete.
You
got,
you
know
a
good
response
and
after
that
controller,
the
and
I
was
going
to
explain
the
pattern
for
how
this
is
implemented
with
namespaces,
where
what
happens
with
namespace
deletion.
A
Is
that,
like,
as
the
finalizer
is
for
a
namespace
run,
they
take
themselves
out
of
this
list
of
remaining
finalized
errs
and
the
API
server
accepts
deletes
when
that
list
is
empty.
So
in
this
case,
what
the
controller
would
do
is
it
would
take
itself
out
of
this
list
of
finalize
errs
on
the
binding
and
then
once
it
was,
that
update
was
successful,
it
would
do
a
delete
and
that
would
be
the
final
delete
to
the
API
server.
The
rest.
A
Says:
ok,
this
thing
has
been
finalized,
I'm
good!
I
can
actually
delete
this
thing
now.
Make
sense.
F
No,
that
one
I
mean
be
written
down.
Cuz,
I,
I
didn't
see
the
relationship
between
the
final
Wiser's
but
I
think
I,
think
I,
see
rundown
they'll
become
clear.
Yeah.
A
A
So
since
we
are
getting
towards
the
end
of
the
hour
here,
perhaps
a
takeaway
that
we
can
have
is,
if
folks
could
look
at
issue
39
I'm.
Sorry,
it's
not
a
poor
best!
That's
an
issue
issue
39
that
will
probably
bring
some
clarity
and
I
will
I
will
try
to
take
some
time
at
this
point.
It
will
probably
be
tomorrow
because
I
have
some
stuff
to
get
done
tonight.
A
A
So
since
I
had
the
bully
pulpit,
I,
wonder
I
think
this
has
been
a
really
constructive.
A
meeting
for
this
group
I
am
happy
that
we
worked
through
like
some
of
these
governance
things
and
that
we're
talking
about
design
again
and
what
I
wonder
is.
What's
the
appetite
of
the
group
to
have
another
meeting
tomorrow,.
A
A
F
Just
one
question:
I
just
look
I'm
okay
with
meeting
tomorrow,
but
as
I
was
quickly
looking
through
issue
39.
In
that
main
paragraph,
we
talked
about
the
finalizer.
You
specifically
talked
about
finalize
errs
and
namespaces.
Are
you
using
namespaces
they're,
just
as
an
example,
or
are
these
finalized
errs
that
operate
on
bindings
part
of
the
namespace?
So.
A
I
and
I'll
go
back.
That's
a
good
question.
Doug
I'll
go
back
and
clarify.
I
think
I
probably
rode
that
at
like
three
in
the
morning,
so
it's
probably
not
the
clearest,
but
I
was
using
namespace
as
an
example
because
namespaces
where
the
precedent
is
implement
a
tease,
okay.
C
A
A
C
Say
if
someone
can
can
at
least
start
thinking
about
that
state
machine
diagram
for
lack
of
a
better
term
starting
a
discussion
around
that
sort
of
deliverable
I
think
would
be
super
help,
both
in
the
online
context,
as
well
as,
like
really
said,
some
of
those
creating
instances,
service
classes
etc.
Context,
let's.
A
C
E
C
E
And
those
I
think
are
the
important
cases,
because
I
think
that
I
mean
just
just
looking
at
the
thing
Thanks
for
writing
all
that
stuff
down
Paul.
But
you
know
just
just
following
along
a
happy
case
and
then
having
branches
all
over
the
place.
Where
you
know
things
take
a
turn
for
the
worst,
then
you
know
then
then
called
the
section
7
B
seems
wonky
to
me,
but
does
anybody
so
it
does?
Anybody
have
concerns
with
coming
up
with
a
condition
diagram,
in
addition
to
words,
I.
E
E
A
Was
going
to
suggest,
like
I,
think
it
will
be
helpful
to
think
of
these
instead
of
states
as
a
of
conditions
again
probably
like,
if,
if
we
have
to
shove
it
into
like
a
state
machine
like
thing,
maybe
the
state,
that's
in
a
circle
is
just
like
writing
out
a
double
yeah.
E
E
H
A
A
E
Okay,
I'll
take
a
look
at
it,
then
I
can
take
a
first
crack
at
putting
together
a
what
something
like
this
could
look
like.
It's
gonna
be
very
incomplete,
but
at
least
it's
gonna
have
some
place
holders
to
go
and
start
the
discussion.
Unless
somebody
absolutely
minds
this,
I
can
take
an
action
identified.
Ok,.
A
E
A
Expect
that
it
might
be,
it
might
take
some
effort
to
get
to
the
point
where
people
are
happy
with
it,
but
I
think
it
will
be
tremendously
valuable
to
have
to
explain
to
users
of
this
API.
That's
we're
at
time
now.
Thank
you,
everybody
for
for
your
time
today
and
coming
in
and
joining
us
and
I
will
see
all
on
the
Internet.
Thank
you.
Bye,
bye,.