►
From YouTube: OCI Weekly Discussion - 2022-03-17
A
C
D
E
A
A
It
does
we
didn't
have
anything
on
the
agenda
last
night,
so
many
people
looked
at
and
figured
they
would
reschedule
for
other
stuff,
or
maybe
it's
just
that
week
between
time
zone
changes
when
everybody
on
the
eu
doesn't
realize
that
we
moved
it
or
maybe
we're
in
the
wrong
and
it
hasn't
moved.
Yet
that
is
the
challenge.
A
Look
at
kind
of
a
pretty
picture
example,
which
is
we're
trying
to
make
things
that
are
artifacts,
I'm
going
to
keep
picking
s
bomb
just
because
I
think
that's
the
least
confrontational
you
say
signature
and
pioneer,
that's
their
signature,
personal
signature,
you
say
yes,
small
and
people
are
like
okay
and
so
we're
adding
an
s
bomb
out
there
on
an
already
existing
image.
And
so
you
have
this
little
arrow.
That
points
over
and
says:
hey,
I'm
an
artifact
for
this
image
and
what
that
gives
us
the
ability
to
do
in
the
future.
A
Hopefully,
is
that
we
can
run
a
api
query
and
say
for
this
given
image.
Tell
me
all
the
artifacts
that
point
to
it
and
so
you're
going
to
have
this
kind
of
query
we're
going
to
build
at
some
point.
Hopefully,
that's
kind
of
the
goal
we're
trying
to
come
out
with,
and
so
we're
going
to
have
a
tag
that
points
this
image
and
that
that
that
index
points
to
the
image.
Sorry
so
tag
to
the
index
index
the
image
and
then
all
the
blobs
and
whatnot,
and
so
garbage
collection
can
look
at
that
and
realize.
A
Okay,
this
is
a
tagged
index.
Let
me
go
through
and
recursively
look
through
all
these
things
and
find
all
the
stuff
that
points
to
this
and
know
that
these
blobs
shouldn't
be
garbage
collected.
This
image
shouldn't
be
garbage
collected
and
it
sorts
all
that
out
for
us
and
when
we
have
these
artifacts
one
of
the
goals
is
that
the
artifact
itself
shouldn't
necessarily
have
to
be
tagged.
A
But
if
it's
not
tagged-
and
it
has
a
point
to
the
image-
there's
nothing
pointing
to
the
artifact-
the
registry
will
say:
okay,
we
just
clean
this
up
and
delete
it,
but
the
goal
that
we're
trying
to
say
is
well
maybe
for
the
garbage
collection.
This
should
be
reversed
and
that's
why
I
kind
of
put
this
little
hollow
arrow
on
this
side,
saying
logically,
the
index
is
tagged.
The
image
is
pointed
to
by
the
index.
A
Oh,
by
the
way,
I
also
have
a
reference.
This
image,
then
that
forward
pointer
over
there
becomes
reverse
pointer
and
you
get
this
loop
and
so
the
question
I
have
for
hopefully
people
smarter
than
me
that
have
done
this
before
is:
is
that
loop,
a
problem
or
not?
If
we're
talking
about
say
the
what
was
the
term
for
at
the
mark
and
scan
and
marked
term,
I
think
it
was
perk
and
sweep
mark
and
sweep
that
was
terminal.
A
So
we've
got
a
couple
algorithms
out
there
in
the
marking
sweep
if
it
just
goes
through
and-
and
it
looks
for
everything-
that's
been
marked
as
long
as
the
marking
process
doesn't
get
stuck
in
that
recursive
loop,
you're,
okay,
I've
heard
other
people
mention
that
recursive
count
or
a
reference
counting
is
the
other
option
they've
been
looking
at.
If
you
get
into
reference
counting,
I
don't
know
how
I
would
handle
a
loop
in
this
case,
and
so
either
garbage
collection
doesn't
handle
these
reference
types,
which
wouldn't
be
great.
A
A
One
as
we
say,
is
not
actually
a
problem
and
brandon
go
away,
and
that
would
be
awesome
if
you
can
tell
me
that
that's
that'll
be
the
highlight
of
my
day.
The
other
option
is
that
we
just
say
you
know.
The
big
issue
here
is
that
the
index
can
have
a
child
pointer
and
a
reference
pointer
to
the
same
thing,
and
that's
because
the
index
points
other
manifest.
A
Then
we
can't
get
into
this
kind
of
looping
scenario,
because
you
can't
point
to
one
of
your
children,
because
your
children
are
only
blobs
and
you
can't
a
reference
type
is
never
a
blob,
it's
always
a
manifest.
So
we
break
that
loop
that
way
so,
depending
on
how
we
want
to
solve
this.
If
we
can
say
this
is
fine,
it's
not
an
actual
big
deal,
because
the
way
we
implement
our
mark
and
sweep
is
just
not
going
to
run
into
these
kind
of
cases.
That's
awesome.
A
Otherwise,
if
we
are
worried
about
it,
we
will
be
stuck
with
this
case,
and
so
I
just
kind
of
want
to
get
a
feeling
from
other
people
that
have
looked
at
this
stuff.
Do
we
need
to
worry
about
it,
and
what
does
that
look
like.
A
B
The
index
one
is
an
interesting
one,
because
the
index
one
is
basically
so
sorry.
Let
me
start
with
there's
an
assumption
here.
Let
me
just
call
out
the
reason
we
call
out
lifecycle
versus
garbage
collection,
because
I
think
of
garbage
collection
as
a
detail
where
life
cycle
is
more
of
a
user
intent.
The
fact
that
registries
can
dedupe,
blobs
and
so
forth
is
a
great
optimization
users
only
care
because
they
pay
for
less
storage
when
they
even
pay
for
it.
For
the
life
cycle
management,
they
are
trying
to
purge
content.
B
In
fact,
weave
is
you
know,
transparency
what
we
went
through
in
acr
and
what
I've
seen
many
other
registries
deal
with
also
is,
we
might
tell
somebody
we
delete
it,
but
we
didn't
actually
delete
it
yet
because
we
didn't
get
to
all
the
gcs,
because
gc
wasn't
implemented
in
some
of
the
core
products
at
core
projects.
Rather
so,
but
we
actually
got
into
an
issue
where
a
customer
came
back.
So
hey
we
deleted
this.
We
want
to
make
sure
it
really
is
gone
from
a
compliance
perspective,
so
it
is.
B
It
is
a
an
important
thing
to
actually
do
that.
The
so
the
we
think
of
the
life
cycle
of
management,
the
things
that
a
user
thinks
about
is
the
manifest
the
manifest
is
the
descript
description.
Let's
say:
descriptor
the
description
of
the
thing
the
user
deals
with
it
might
be
a
digest.
They
might
put
a
tag
for
friendly
names
on
it.
So
that's
why
the
image
manifest
has
always
been
kind
of
like
the
main
thing
that
we
think
about
from
a
user's
perspective.
B
The
index
the
multi-arc
index
is
a
special
hybrid
today,
where
it
says
hey,
you
have
a
couple
of
these
things
in
the
registry
that
users
think
about
reason
about,
but
there's
an
aggregation
atop
it
because
it
turns
out
the
main
use
case.
The
cnab
is
another
one,
but
I'll
avoid
seeing
that
for
a
second.
B
The
main
use
case
is,
I
want
to
run
redis
on
both
windows
and
linux,
or
pick
the
pick,
the
thing
that
you
know
the
image
so
what's
interesting,
there
is,
if
you
delete
an
image,
manifest
and
there's
no
other
blobs
that
reference
it
the
blobs,
get
deleted.
There's
a
cascading
delete
that
kind
of
happens.
B
If
you
delete
an
index,
there's
not
you're,
not
intentionally
saying
I
want
to
delete
the
individual
architectures,
so
there's
just
an
interesting
caveat,
at
least
the
way
I've.
I
know
what
we've
implemented
in
acr-
and
this
is
similar
conversations
we've
had
with
other
registry
operators-
is
deleting
an
index,
doesn't
intentionally
delete
the
children
of
the
index
today,
because
that's
intentional,
whether
or
not
you
have
a
forward
pointer
or
a
back
pointer.
B
B
The
right
that's
highlighted,
that
is
a
little
more
easier
to
attract
to
track,
because
you
have
a
thing,
the
image
and
it
might
be
pointing
at
another
thing
and
the
question
mark.
If
you
just
said
another
another
manifest,
we
can
call
it
manifest
as
opposed
to
image
or
artifact,
because
to
me
an
artifact
is
a
manifest.
The
blobs
are
an
implementation
detail,
but
they
are,
but
the
idea
that
the
back
pointer
exists
is
like
a
ref
count,
so
you
can
find
it.
If
you
want
it,
you
can
track
it.
B
You
can
delete
it,
but
it
doesn't
completely
map
to
the
way
indexes
are
today
because
indexes
are
a
special
thing.
B
B
B
What
we
said
is,
if
now,
if
you
highlight
to
the
top,
go
to
your
top
image,
the
green
one
at
the
very
top
of
your
page-
that's
a
good
example
of
that
would
be
the
container
image
and
then
the
purple
ones
could
be
the
signature
and
s
bomb.
Let's
just
say
the
thought
was:
if
you
delete
the
image
the,
when
you
got
selected,
we
would
delete
the
two
child
artifacts,
even
though
the
reverse
pointers,
because
that's
the
concept
of
a
life
cycle.
B
But
we
also
said
that
if
a
registry
doesn't
want
it,
we
said,
should,
I
think,
was
the
word
or
may
or
should
so
that
a
registry
could
keep
those
around
if
they
wanted
to,
because
those
themselves
do
have
life
cycle
of
their
own,
in
the
sense
that
they
are
a
manifest.
B
So,
in
that
case,
that
absolutely
can
point
to
an
index
also,
the
the
subject
can
be
any
manifest
if
you
wanted
to
create
a
new
manifest
tomorrow.
That
would
absolutely
work.
Of
course,
the
manifest,
generally
speaking,
manifests
have
to
be
understood
by
a
registry,
because
that's
how
the
registry
does
lifecycle
management
but
the
way
the
subject.
The
definition
of
a
subject
is
any
manifest.
A
B
Today,
because
we
couldn't
come
to
agreement
on
adding
properties
to
a
manifest
an
existing
manifest
because
it
I'm
trying
not
to
break
into
jail
a
whole
nother
conversation,
because
we
weren't
comfortable,
adding
formal
properties
to
the
existing
manifest.
We
did
add
the
subject
property
to
a
new
manifest.
The
new
manifest
is
just
a
formalization
of
what
was
there.
The
hard
part,
which
is
the
break-in
and
jail
part,
is
not
so
much
the
manifest
descriptions.
B
B
A
Probably
it
does
mean
be
that
shirt
up,
welcome
yeah,
so
to
kind
of
throw
this
a
little
bit
more
into
context.
I
think
your
proposal,
steve
and
probably
a
few
others,
are
okay,
just
saying
we're
we're
defining
the
artifact
down
here
and
it
it
has
a
reference
type
on
it,
but
we're
not
going
to
put
the
reference
types
on
these
other
objects.
B
I
mean
to
be
clear
just
because
you
said
our
proposal
is
one
versus
the
other.
It's
not
that
we
wanted
to
create
a
new
manifest
per
se.
It's
that
we
wanted
to
create
a
well-understood
behavior
to
know
how
to
deal
with
these
things.
So
we
didn't
just
jam
stuff
in
registries
that
they
get
so
screwed
up.
They
don't
know
how
to
manage
them.
So
it's
the
direction
we
took
was
because
of
the
the
direction
and
the
guidance
that
we
got
by
the
group
on
where
changes
could
be
made.
A
B
A
G
That's
that's
where
we
landed
with
the
current
implementation,
because
the
artifact
itself
has
a
blob
right.
You
can
think
of
it
like
it
has
a
single
js
bomb
or
something
or.
B
G
Thank
you.
The
the
point
here
is
that
if
you
drop
the
image,
there
is
still
a
discussion,
whether
you
want
to
keep
the
s
permanent,
which
you
should
be
able
to
do.
The
other
conversation
we're
having
is
you
should
be
able
to
push
the
signature
without
pushing
the
image?
So
what
does
the
gc
look
like
for
that?
G
So
there
are
a
couple
of
conversations
that
haven't
been
kind
of
like
totally
ironed
out
as
to
what
the
behavior
should
be
and
we've
never
kind
of
like
gone
down
the
index
path,
primarily
because
of
this,
because
the
index
can
point
to
an
image,
an
index
can
point.
If
we
make
it
point
to
a
reference,
then
you
do
have
exactly
the
loop
that
you
mentioned
at
the
bottom,
and
you
try
to
keep
the
index
away
from
being
able
to
attach
signatures
to
indexes
themselves
in
some
way,
and
that's.
B
G
B
B
If
we
were
told
yes,
I
think,
because
I
know
that's
the
conversation
we're
starting
to
have
with
the
reference
types.
I
think
the
big
fur
ball
that
we
have
to
unravel
is
what
does
that
mean?
If
we
add
them
is
that
is
that
a
new
version
is
that
an
optional
if
we
make
it
optional?
What
are
registries
expected
to
do
with
it?
So
it
just
breaks
into
jail
the
whole
versioning
thing.
So
that's
why
I've
always
said
it's
not
just
about
adding
properties
to
the
existing
manifests.
It's.
What
is
the
versioning
story
for
these.
A
No,
sadly,
it
sadly
it
isn't.
I
was
described
in
the
email
that
it
was
an
index,
but
just
assume
this
is
an
artifact
you're
going
to
have
something
you're
pointing
to
let's
call
it
dead
beef
just
because
I
don't
have
a
lot
of
good
creative
names
for
shaw,
hatch
names
and
so
in
what
we
think
of
today.
As
an
index,
it's
going
to
have
a
list
of
manifest
in
there
and
one
of
those
manifests
in
there.
A
You
can
point
to,
and
just
say,
I'm
pointed
at
beef
and
it's
gonna
have
a
list
of
references,
and
you
could
also
say
that
reference
is
dead
beef
and
what
happens
when
we
do.
This
is
the
whole
idea
of
the
artifacts
we
were
trying
to
do
was
create
this
picture
up
top,
we
said
we're
going
to
have
an
index
multi-platform
image.
A
A
If
you
don't
treat
this
pointer
as
a
reverse
pointer,
then
you
would
go
out
there
and
say
well.
There's
nothing
pointing
to
the
artifact.
We've
got
a
tag
point
of
the
index,
but
there's
no
tag
pointing
the
artifact,
so
let's
just
delete
it.
So
the
better
scenario
here
is
that
we
say:
let's
treat
this
as
a
reverse
pointer
for
the
garbage
collection
standpoint.
A
B
B
Because
if
it's
an,
if
it's
a
non-supported
case
but
a
technically
incapable,
because
the
way
the
property
is
defined,
I'm
still
struggling
to
wrap
my
head
around
exactly
how
it
has
part
of
the
ref
counting
allows
you
to
just
figure
out.
Did
you
ever
get
to
zero?
And
if
you
don't
you
leave
it
and
you
could
in
theory,
flag
the
bad
b's
in
your
registry
and
decide
like.
I
delete
corrupted
data.
G
The
I
think,
I'm
seeing
the
point
here
according
to
the
the
rough
count
on
that
manifest
is
two
because
it's
both
a
reference
and
this
and
a
pointer.
So
if
you
delete
the
artifact,
the
manifest
will
not
get
enough
count
just
because
of
that
shot
you
need
to
mark
and
sweep
here.
Most
of
us
don't
implement
market
sweepers,
so
we
could,
but
it'll
take
a
long
time
to
do
that.
So.
G
If
I
create
this
artifact,
according
to
your
text
document
before
you
had
said
that,
that
index
would
point
to
the
manifest
as
well
as
the
reference
would
also
be
the
manifest,
so
that
our.
A
Let's,
let's
say
that
I've
got
a
tag,
and
so
before
anything,
I've
got
my
tag
sitting
over
here.
That
just
says
tag
explains
this
manifest:
it's
good:
it
works,
everything's,
fine,
and
so
the
manifest
has
probably
a
rough
count
of
one
at
that
point.
Is
that
correct
right?
A
A
G
It
depends
on
how
you
want
to
purge
them.
So
if
you
want
to
say
that
I
want
to
drop
the
s-bombs
when
I
drop
the
image,
then
we
go
that
way.
But
if
you
say
that
if
I
drop
the
artifact,
I
want
to
drop
the
like
that's
how
index
should
technically
work
right,
you
drop
the
index,
then
all
the
children
are
can
be
purged
or
maybe
kept
around
depending
on.
A
G
B
I
want
to
be
transparent
because
we
we
ventured
into
this,
so
I
came
over
where
we
were.
Actually
it
was
actually
a
place.
The
last
place
actually
saw
people
in
three
dimensions.
We
were
discussing
this
that
blobs
could
be
like.
Could
the
aura's
artifact
maxfest
be
a
new
index?
So
we
said
why
couldn't
what
we
call
blobs?
B
What's
currently
called
layers
be
descriptors
and
it
we
walked
into
this
exact
conversation
said
all
right:
we're
not
ready
to
carve
that
beast,
but
if
we
just
rename
blobs
of
descriptors,
then
we
could,
if
we
figured
out
how
to
make
it
work
in
the
future,
but
everybody
was
really
nervous
around.
How
do
you
do
exactly
what
you're,
what
you're
suggesting
so
this
is.
This
is
why
putting
subject
on
index
is
problematic
and,
quite
frankly,
we
haven't
fully
identified
that
use
case
for
it.
B
So
that's
why,
even
as
close
as
we
got
to
it
with
auras,
where
we
renamed
blobs
of
descriptors,
we
stopped
by
saying
that
it
was
a
property
name
change,
but
the
behavior
didn't
change
and
we
actually
reverted
it
because
it
was
gonna
be
too
difficult
to
do.
The
name
change
at
this
point
yeah,
so
it
is,
it
is
a
like,
I
think,
trying
to
identify
why
we
need.
It
would
probably
be
a
better
case.
A
G
So
the
proposals
with
index
does
have
this
problem,
and
I
think
that
echo,
what
steve
said
is,
which
is
if
we
have
a
use
case
for
this,
then
maybe
it's
worth
discussing,
but
I
think
we
should
discuss
when
would
an
index
want
to
point
to
a
manifest?
G
To
your
point,
I
think
guiding
this
at
one
level
is
one,
but
you
could
still
have
the
manifest
be
like
you
could
have
one
more
level
of
indirection,
so
the
artifact
can
point
to
an
index
that
points
to
another
manifest.
So
you
can
have
two
levels
of
problems
there
so
pointing
to
an
index
by
default
will
create
these
problems,
so
I'm
leaning
on
this
is
a
tough
one
to
crack
at
this
point.
So
unless
we
have
a
real
use
case,
for
it
don't
make
artifacts
point
to
manifest
might
be
a.
A
B
Well,
and
it's
that
you
do
both
so,
for
instance,
if
we
keep
so,
let's
just
say,
multi-arc
is
a
good
thing,
not
just
for
container
images,
but
for
you
know,
debian
packages
or
npm
packages
or
whatever
right.
Like
you.
Let's
say
there
are
platform,
specific
things
that
are
not
just
container
images,
so
the
lit
the
index
is
a
good
idea.
The
question
is:
does
does
the
index
need
to
have
a
subject
to
point
to
something
else?
B
The
idea
is
that
if
you
do
have
two
manifest
types,
the
artifact
manifest
and
the
index
as
being
the
two,
because
the
the
the
artifact
manifest
that
we've
been
playing
with
is
basically
a
superset,
a
superset
subset
of
image.
That
is
today.
So
you
have
a
single
artifact
and
a
collection
of
artifacts.
That's
where
the
index
kind
of
works
today
and
the
collection
is
based
on
a
pivot
either
one
of
them.
B
You
want
to
sorry
you
that
would
want
to
be
able
to
put
children
that
are
individual
things
as
individual
s-bomb,
individual
signature,
that
it
is
referring
to
the
thing
I
want
to
be
able
to
sign
the
container.
I
want
to
be
able
to
sign
the
index,
so
the
premise
is,
we
still
have
two.
I
think
what
we're
kind
of
realizing
is.
We
couldn't
quite
get
to
one
manifest
to
rule
them
all,
which
was
part
of
justin's
number
37.
If
you
remember
right,
we
had
27,
29
and
37..
B
We,
I
think,
thinking
all
the
way
through
with
realizing
this
is
we
couldn't
get
to
two,
because
if
we
sorry
we
couldn't
get
to
one
so
we
landed
on
two
index
and
a
manifest.
That
knows
how
to
define
a
thing,
and
it
says
that
thing
an
artifact
can
also
refer
to
another
thing.
That
other
thing
it
refers
to
can
be
another
artifact,
a
container
image
or
it
could
be
a
multi-arc,
but
a
multi-arc
thing
itself
doesn't
have
a
way
to
be
a
subject
to
something
else.
An
index
would
be
the
top-level
object.
B
B
A
Yeah
looking
at
this
picture,
I
want
to
make
sure
it's
clear
that
you
can
have
an
artifact
point
to
an
index
even
with
this
scenario,
as
long
as
the
child
of
the
artifact
is
just
blobs,
and
so
the
the
reference
can
point
to
the
index,
but
the
child
pointers
whatever
this
artifact
contains,
cannot
contain
another
manifest
as
its
child.
It
can
only
be
referenced
to
the
index,
and
so
it's
this
error,
that's
bad
one.
All
these
errors
are
just
fine,
the
artifact
that
has
a
bunch
of
blobs.
A
A
How
would
you
you
know,
pull
off
that
restriction?
I
I
think
the
restriction
here
is
that
we
just
don't
allow
the
scenario
where
an
artifact
itself
can
have
a
child
of
a
manifest
used
to
say
an
artifact
can
only
ever
have
blops,
it's
whatever
it
contains,
and
then
we
see
or
probably
it's
just
it's
part
of
the
schema
itself
of
whatever
an
artifact
can
be.
The
schema
itself
is
just
going
to
say:
hey
the
only
thing
you
think
these
can
point
to
our
blob
descriptors
in
the
spec
level
and
then
check
it
on
them.
A
A
A
A
Yeah
there
are
any
registry
operators
out
there
that
say:
hey
we
implemented
reference
counting
and
this
would
break
our
registry.
If
you
try
to
push
it.
So,
please
don't
even
try
to
propose
it
because
we're
going
to
veto
later
on.
A
G
B
I
mean
the
only
reason
that
most
registries
have
added
index.
I
I
don't
want
to
like.
I
don't
know
if
they
were
public
about
it
or
not.
So
I
know
two
registries
that
only
recently
added
index
and
it
took
them
a
year
to
add
it
because
of
the
lifecycle
management
issues
of
it
and
not
not
that
they
were
trying
to
cascade
the
delete,
but
just
the
the
the
issues
related
to
like.
If
you
do,
because
the
opposite
is
problem.
B
If
I
delete
the
arm
image-
and
I
have
a
multi-arc
index-
that's
pointing
to
arm
windows
and
linux,
do
you
does
that
mean
the
multi-arc
document
is
still
there
and
it
points
to
it?
Has
a
dead
pointer
or
is:
does
it
have
a
ref
count
of
one
or
ref
count
a
two?
It
itself
is
a
ref
counter
one
and
the
index
pointing
to
it
is
another
ref
count.
So
if
you're
distribution.
G
To
mike's
question
before
I
think,
if
we
limited
through
schema,
saying
that
anything
that
can
have
a
manifest
cannot
have
a
reference,
it
will
protect
you
from
the
tread
arrow.
That
might
be
an
easy
validation
to
do.
Otherwise
we
have
to
go
a
walk
down
the
chain
and
make
sure
that
the
links
don't
exist,
and
things
like
that.
So
that's
that
just
makes
it
much
harder.
A
A
To
do
it
yeah
so
some
said
new
types,
some
have
said,
create
a
whole
new
thing.
That's
the
generic
of
everything
I
think
justin's
proposal
was
trying
to
be
that
grand
unified
thing
and
ran
into
this
case,
and
so
I
just
think
it.
I
think
the
easy
answer
is
we
just
say
this
on
the
left
doesn't
exist.
We
just
make
sure
artifacts
only
have
blops
magic
problems
problem
solved
in
that
way,.
B
I
know
I
owe
this
to
the
community.
It's
just
that
we've
been
I've
been
busy
and
it's
obvious
what
we're
going
to
submit,
but
the
the
concept
of
the
the
artifact
manifest
is
not
meant
to
be
a
third.
It's
meant
to
be
the
replacement
of
image,
because
it
is
it
handles
all
the
image
scenarios.
So
it's.
I
know
that
that's
a
touchy
subject,
but
it's
my
point
is:
is
that
we're
not
trying
to
have
n
level
mike's
going?
I
mean
the
point
is
not
to
have
50
manifest
that
a
registry
has
to
process.
B
B
A
E
I
okay
index:
can
it
point
to
an
artifact.
E
Well,
you
mentioned
that
a
goal
of
artifact
would
be
to
also
be
able
to
support
blobs
right
as
the
bottom
right
hand
corner.
So
then
the
question
would
be:
could
are
we
going
to
have
a
new?
Can.
B
B
So
the
idea
and
I've
said
the
image
can
be
signed.
Fine,
so
I
put
an
artifact
in
the
manifest
in
the
registry
that
says
it
is
signing.
Actually
this
can't
exist.
I
take
that
back.
This
can't
happen
conceptually.
If
time
was
not
a
factor
I
figured
what
movie
was.
I
was
just
watching
this,
or
the
good
place
was
another
fun
one.
The
problem
is,
is
that
so
what
I
was
trying
to
say
is
if
you
signed
a
index
so
that
purple
purple
box
you
just
put
there.
B
I
didn't
see
your
point
here,
but
the
one
on
the
mid
left.
If
that's
the
signature
and
you're
signing
an
index
totally
valid
scenario
right,
because
before
I
pull
the
multi-arc
index,
I
want
to
know
it's
signed
by
somebody.
I
trust
in
theory.
Time
is
not
a
factor.
The
index
manifest
collection
could
conceptually
contain
the
digest
of
that
artifact
and
you
would
have
the
loop.
B
A
B
But
just
you
see
what
I'm
saying
the
index
is
a
collection
of
manifests,
so
the
index
has
that
collection
of
valve
things
to
the
right
to
green
ones,
because
artifact
is
a
manifest
technically
that
purple
one
could
be
in
the
collection
it
just.
It
can't
be
placed
in
that
particular
collection,
because
the
sequence
of
creation
makes
that
impossible.
Yeah.
E
H
No,
I
like
I
like
it.
I
like
the
discussion,
but.
H
I
was
also
shoving
food
in
my
fat
in
my
mouth
while
you
were
talking
so
this.
Could
I
like
the
discussion
like
where
it's
going.
A
A
C
C
C
I
don't
even
know
what
you
want
to
call
it
like
a
a
pretty
strong
response
rate.
I
guess
from
like
all
the
major
operators.
B
The
distribution
group,
the
distribution
distribution,
cntf
distribution,
has
been
a
good
group
because
there's
I
don't
know
what
percentage
there's
some
reasonable
percentage
of
people
that
do
implement
distribution.
So
there's
a
set
of
folks
that
do
appear
there,
but
folks
are
busy
that's
kind
of
what
the
wines
are
coming
back
with.
So
it's
yeah.
I.
B
We
haven't,
I
I've
set
up
the
initial
kind
of
recurring
meetings
and
for
a
bit
we
had
them
because
when
it
first
got
donated
to
cncf
there
was
a
lot
of
engagement
to
make
sure
like
the
test
cases
and
other
stuff
got
done,
and
then
there
was
a
security
thing
that
there
was
some
activity
around,
but
there's
there's
activity,
it's
mostly
just
async.
A
Yeah
I
took
the
effort
to
start
looking
through
distribution
distribution
to
see
how
it
does
garbage
collection.
I
think
it
is
kind
of
mark
and
sweep,
but
I
feel,
like
I
uncovered
a
few
bugs
just
looking
through
at
least
the
version
of
code
that
I
have
so.
I
might
have
to
put
some
test
case
together
and
see
if
I
can
break
the
garbage
collector
or
not.
A
B
Like
just
because
this
is
a,
I
hate
this
one,
because
we
actually
just
ran
on
this.
The
other
day
when
we
were
trying
we're
implementing
the
graph
of
artifacts
in
the
registry
in
the
portal
was,
if
you
delete
a
tag,
you
technically
aren't
deleting
the
manifest
the
manifest
is.
There
is
an
untagged
manifest
which
confuses
the
hell
out
of
users,
because
users
don't
want
to
think
about
digests.
A
A
A
You
can
and
if
you
have
the
tag
on
the
image
that
makes
things
easier.
But
let
me
take
the
case
where
you
don't
and
I
delete
this.
B
A
A
It
descends
and
says
all
of
these
things
are
in
the
reference
list,
but
it
doesn't
actually
descend
into
the
image
and
say.
Let
me
look
at
all
your
blobs,
at
least
when
I
first
looked
at
it,
and
so
I
think
there
might
be
some
cases
where
things
on
the
garbage
collector
over
there
at
least
the
version
I
had.
Maybe
I
need
to
fetch
a
newer
version
of
it.
Some
might
have
patched
it
since
then.
A
E
In
this
bottom
right
hand,
corner
picture
you're
showing
the
artifacts
can
have
blobs
themselves.
Yeah.
Is
that
true,
only
in
the
context
of
it's
pointing
to
an
image
or
does
it
is
it
also?
In
that
top
picture,
you
need
to
show
the
artifact
pointing
to
blobs.
A
These
would
have
blobs
up
here.
This
would
have
blobs
over
here
as
well.
The
artifact
definition
itself
is.
I
have
blobs,
because
I've
got
like
an
s
bomb.
That's
a
big
file
that
I
need
to
tell
people
what
to
pull
and.
E
So
same
looping
kind
of
scenario:
is
there
a
rule
that
the
the
artifact
that
points
to
a
manifest
can't
have
or
must
have
only
orthogonal
blobs
to
the
image
that
it's
also
pointing
to.
A
A
A
E
A
I
don't
know
if
I
don't
know
if
you
would
want
to
do
that,
but
I
don't
think
that's
a
problem.
If
you
did
it
because
from
index
going
down
remember
this
point
is
reverse.
So
index
is
going
to
artifacts
going
to
the
blob
index
going
to
the
image
it's
going
to
blob.
There
are
no
loops
they're,
just
all
pointing
down
to
the
blobs.
B
In
practice
I
haven't
seen
it
much,
I
mean
it's
been
a
concept,
the
the
idea
is,
a
config
object
might
be
shared
or
even
a
layer
might
be
shared,
so
the
scenario
have
been
kind
of
initially
didn't
help
team
didn't
want
going
this
way,
but
if
you
think
about
helm
having
a
config
as
well
as
their
individual
charts,
the
if
you
had
an
inheritance
model,
so
let's
say
I
have
the
redis
cache
image,
sorry
the
redis
cache
chart,
and
then
I
have
multiple
multiple
configurations
of
that.
B
A
E
A
Yeah
and
I've
thought
of
cases
where
I
wanted
to
have
maybe
an
artifact
that
points
to
all
the
images,
because
it's
a
multi-platform
image
they
might
have
had
a
multi-platform
build,
but
they
all
have
the
same
s
balm
because
they
all
put
from
the
same
upstream
code
base,
and
so
they
would
all
have
one
set
of
blobs.
But
the
other
take
on
that
is
well
give
each
image's
own
artifact.
That's
just
a
small
manifest,
and
the
underlying
blob
is
the
same
so
which.
E
B
If
you
think
about
the
part
of
this
ref
counting
and
life
cycle
management
and
de-duping,
the
d-tubing
is
about
size.
Keep
the
registry
reasonably
sized,
making
sure
that
a
client
that's
pulling
common
layers
doesn't
have
to
pull
the
same
thing
again
because
there's
different
digest,
but
it's
the
same
content.
So
that's
like
the
beauty
right.
You
pull.
14
versions
of
things
are
built
in
the
debian
image.
The
debian
layers
only
have
to
come
once.
So
that's
not
just
a
registry
persistent
savings,
but
it's
a
client
and
bandwidth
savings
and
then
the
other
is.
E
B
B
A
B
D
A
B
That
vegan
neutral
enough
for
you,
sadly.
H
H
H
H
H
A
H
They
have
a
book,
it's
wonderful!
It's
very
relatable
content,
no
good
stuff.
H
B
Okay,
one
more
hey
vincent:
we
don't
hear
crying
babies
in
the
background
everybody
getting
to
a
sleeping
point
in
your
life.
H
They're
in
a
partner
and
a
little
one
and
another
kid
are
in
upstate
new
york
this
week
and
one
of
the
kids
is
off
so
the
others
at
school
right
now.
So
just
me
and
two
sleeping
dogs.