►
From YouTube: 20180228 - API Management Working Group Meeting
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
B
B
D
Next
few
weeks,
API
support
yeah,
hear
me:
okay,
yes
yeah,
so
that
discussion
are
you
talking
about
whether
you
are
basically
going
to
externally
import
things
with
a
tool
from
open
API
into
our
misty,
or
you
know,
API
specification
versus
like
I'm,
not
sure
what
the
question
you're
asking
it
versus
you
know
actually
having
some
versus
last.
You
know
ability
to
just
given
it
open,
API
specification
say:
that's
that's
the
way
you
do
this
or
one
other
ways.
That's.
C
B
P+,
a
pope
app
people
have
open
api
specs,
they
have
G
received
services,
they're
going
to
want
to
run
those
in
sto
and
have
some
API
level
awareness
of
other
how's
it
work.
We
can.
We
have
a
minimal
spec
right
now
that
is
sufficient
to
enable
the
runtime
the
fund
sto
to
table
API
management
type
features.
Is
that
good
enough
and
anything
else?
A
mom?
Let
me
say
it's
your
problem.
You
deal
with
it.
B
B
D
B
A
B
B
At
Google
we've
had
to
deal
with
in
terms
of
things
being
under
specified
or
two
things
in
terms
of
things
we
know
under
specified
beyond
that,
and
then
you
have
multiple
specifications
to
these
specifications.
He
doesn't
like
open
API,
but
they
like
they
have
something
else
they
want
to
use.
Are
we
just
very
opinionated
about
this
page,
just
open,
API,
that's
probably
good
enough,
because
we
talked
to
your
receipt,
so
we
lose
needs
for
two
or
two.
Maybe
there's
more
and
more
things
that
we
want
to
have
another
story
for
how
do
we?
B
How
would
we
do
that
in
a
reasonable
way?
There's
not
just
HTTP
API,
there's
other
protocols
as
well.
Should
we
consider
that,
and
so
he
kind
of
go
down
this
rabbit
hole
portrait
taken?
Is
this
step
back,
so
it's
the
minimal
amount?
We
can
do
that.
We
all
agree
on.
We
all
agree.
We
need
some
normalized
form,
that's
just
the
path,
the
method
that
correspond
to
some
operation,
that
we
definitely.
D
Unless
you're
basically
saying
that,
there's
this
discussion
of
whether
you
know
if
you're
not
going
to
say
we
don't
support
any
of
these,
you
know
standard
format
of
specifying
your
API,
so
we're
not
going
to
support
it.
I'm
gonna
support
any
of
them.
Then
we
have
to
at
least
kind
of
pick
some
reasonable
subset
of
more
than
you
know,
not
just
over
a
guy
whatever
it
has
to
be
some
subset
or
or
nothing
I
guess
is
kind
of
the
alternative
and
say
you
said
we
leave
this
as
an
exercise
for
the
customer.
B
B
B
Expect
it
to
be
a
moving
target,
so
we're
not
going
to
even
if
we
said
we
want
to
support
everything
open
API,
which
is
probably
not
the
right
thing
to
do.
But
if
argument
saying
we
wouldn't
say
much
smaller,
subset
and
document
here
are
the
features
that
we
support
within.
That's
that
specification
specifically.
What
are
we
looking
at
in
that?
Maybe
I
spec?
How
are
we
normalizing
it
into
the
format?
B
F
Community
maintain
client,
libraries
or
tooling,
so
we
only
support
one
and
having
all
different
kinds
of
these
formats.
We
say
we
never
support
and
there's
a
conversion
tools
and
there
is
open
to
the
community
so
for
whatever
people
want
is
to
do
support
that
they
can
is
plugging
their
conversion
tool,
and
this
is
only
thing
by
the
and.
A
I
think
I
think
that
requires
a
strong
common
common
common
support
in
the
proxy.
The
normalized
form
needs
to
be
able
to
express
a
variety
of
formats,
but
I,
agree,
I,
think
that's
the
right
approach.
I
I
would
prefer
a
model
where
we
support
open
API
and
it
flows
this
way
and
will
work
open
the
doors
and
will
work
with
partners
that
want
to
extend
this
to
support
other
formats
and
as
if
they
find
that
our
low-level
stuff
is
not
expressive
enough.
D
1:1
reference
implementation
in
external
thing,
like
there's
sort
of
the
you
know,
the
canonical
or
normalized
form,
is
this
sort
of
what
we
expect
and
there's
a
mechanism
to
register
other
types
of
converting
things
and
and
we
implement
one
of
them,
an
open-source.
You
know
probably
open
one
of
the
ìiî
whatever
and-
and
you
say
that
everything
else
is
you
know,
but
that's
the
reference
implementation
people
can
plug
in
and
the
community's
community
can
plug
in
other
versions.
Is
that
sort
of
what
you're
saying
yeah,
except
it'd,
probably
be
to
your.
C
B
Why
do
we
understand
that?
So
the
the
core
is
tio
capabilities
of
that
goals
and
quota
and
telemetry
right
now
is
dimension
by
service.
You
can
also
define
that
against
the
the
raw
it's
OPP
headers
right.
You
can
do
all
that
right,
but
there
may
be
ap
has
and
refined
as
they
not
the
full
path.
So
you
may
have
a
path
that
include
like
a
resource
ID,
which
is
unique
and
change
it,
and
you
don't
want
I'm
quote
on
particular
object
in
it.
Fluctuating
will
have
the
quota
on
the
collection
as
a
whole.
I
mean.
C
I
think
right
so
I
mean
I,
mean
I.
Think
you
want
to
do
this
to
make
it
more
convenient
for
people
to
configure
the
AMS
to
do
different
things
for
different
api's.
What
I'm
wondering
is
you
know,
and
we've
been
working
on
a
mixer
adapter
as
we've
discussed
in
send,
and
so
are
you.
It
would
be
nice
if
a
mixer
adapter
could
consume
everything
in
the
open,
API
spec,
including
the
security
specification,
and
things
like
that,
so
that
it
could
then
decide
what
to
do
based
on
what's
in
the
open,
API
spec.
C
A
A
Or
basically,
what
we
do
coded
for
the
junk
oaken's
based
on
the
method,
all
this
kind
of
stuff
I
want
to
be
able
to,
and
then
and
you,
the
proxy
need
to
be
able
to
cache
answers
to
a
lot
of
need
to
detect
calls.
So
in
order
to
be
able
to
cache
properly,
it
needs
to
have
kind
of
it
needs
decoded
these
things
to
find
enough
level
of
detail.
So,
in
the
general
case,
I,
don't
think
we
can
do
everything
in
the
proxy
and
the
mixer.
A
C
C
Right
because
that's
where
I'm
I
guess
I'm
sort
of
imagining
a
world
where
hey
I
have
an
API
and
I
run
some
policies
based
on
URL
patterns
and
I
call.
This
do
distract
the
URL
patterns
from
my
open,
API,
spec
and
then
I
want
to
do
you
know.
Api
management
and
I
want
to
automatically
enforce
the
security
requirements
in
that
open,
API
spec,
so
I
gotta
tell
my
mixer
about
the
spec
again.
So.
A
Help
me
salamanca
what
part
of
what
we're
trying
to
do
in
the
proxy
is
to
decode
this
information
and
produce
it
as
attributes.
So
the
only
reason
you
would
need
to
look
at
the
API
spec
in
the
in
the
minute
in
the
adapter
is,
if
we
didn't
so,
if
the
proxy,
this
is
the
code
information
you
need
it
yeah.
C
C
B
Taking
on
too
much
so
yeah,
you
could
certainly
build
a
system
with
the
infrastructure
we
have
now.
You
can
do
two
specific
extensions
and
you
have
a
admission
controller
which
looks
like
that
and
maybe
generates
other
is:
do
we
pay
for
education
policy
or
anything
else,
that's
possible.
That
thing
can
stop
you
from
doing
that.
Should
we
encourage
that
or
we
try
to
push
that
can
take
authorship
to
a
single
spot
by
this
custom
of
the
rest
of
the
kindergarten
texture?
With
that
we
have
an
issue,
so
that's
impossible.
B
You
could
again,
if
because,
if
we
have
open
API
in
this
one,
your
mixture
after
it
could
just
have
special
cases
or
the
extensions,
are
you
looking
at
again?
We
can't
prevent
that,
but
I
think
we
want
to
discourage
that
in
a
more
systematic
way
of
defining
policy.
That's
not
unique
to
our
particular
down
the
there's,
always
room
for
the
escape
yeah,
there's,
always
returning
Scafell,
that's
just
what.
What
do
we
want
to
say
is
because.
C
B
All
right,
so
that's
that's
one
of
the
motivations
for
including
the
spec,
so
the
advantage
of
just
using
the
normalized
form
which
I
have
on
on
the
screen
now
is.
We
don't
have
to
deal
with
this,
so
this
conceptually
simple,
every
component
pilot
mixer
is
just
looking
at
the
normalized
spec
for
me
and
that's
just
a
list
of
patterns
that
correspond
get
operation
and
that's
the
necessary
and
good
part,
but
it's
not
sufficient.
B
If
we
had
a
way
to
reference
the
original
specification,
the
guys
back,
then
you
can
you
have
this
escape
valve,
so
you
can
do
all
sorts
of
clever
things.
If
you
want
to
do.
You
could
also
have
some
support
for
other
normalization,
so
you
don't
need
clients,
I
tolling,
to
convert
from
t2
to
generate
the
normal
I
expect
from
do
some.
C
So
yeah,
okay,
so
I
understand!
If,
if
you,
if
you,
if
you
only
implement
this
in
sto-
and
you
do
the
translation
from
open
API
to
this
in
a
tool,
then
when
you
know
open
API
for
comes
along,
you
won't
have
to
build
that
into
every
sto
in
the
world.
Right.
B
So
we
definitely
want
to
if
we
decide
that
it's
it's
there
are,
is
merit
in
having
some
open
API
awareness
or
G
or
PC
awareness
in
sto.
We
should
kind
of
limit
the
blast
radius
of
that
limit.
So
if
you
have
some
under
specified
feature
is
that
you
can
see
that
show
up
on
the
proxy
now.
That
would
be
a
bad
thing.
You're
having
to
do
all
that
that
interpretation
of
open
a
their
rules
and
yeah.
A
So
so
this
reaches
the
the
discussion.
One
of
the
key
things
we're
looking
at
in
the
config
space
is
separation
between
the
user
experience
and
the
runtime
state
of
this
system
consumes.
This
is
appropriate,
for
this
is
what
the
run
line
needs
to
evaluate
things
and
the
the
user
level
stuff
is
of
this
is
a
separable
separable
concern,
so
the
key
is:
how
is
this
expressive
enough?
It's
this
low-level
thing
expressive
enough
to
address
most
of
open
api,
and
most
of
these
are
the
weird
formats
that
seem.
B
B
A
B
B
B
Needs
to
change
proxy
change
or
pilot
change,
yeah,
that's
the
best
of
best
kids.
Yes,
that's
the
best
case
yeah,
but
as
an
escape
valve.
If
you
had
a
mixture
adapter,
you
really
wanted
to
use
open
API.
You
still
have
the
reference
available,
so
you
can
look
at.
Oh
here's,
the
normalized
form
I
want
to
see
where
that
originated.
Yet,
okay.
B
B
It's
possible,
but
I'd
like
to
avoid
that
to
start
I
think
you
could
get
pretty
far
just
focusing
on
the
HTTP
yeah
art
and
that's
contentious
enough
about
what
goes.
Learn
what
go.
And
how
do
you
support
it
without
trying
to
consider
how
it
also
works,
because,
essentially
then
you're
trying
to
create
a
super
set,
API
specification
that
it
does
as
HTTP
and
every
other
conceivable
program,
which
is
just
no
no
I'm,
not
suggesting.
B
B
A
B
You
can
and
then
run
can
build
stuff
right
if
it's,
if
it's
in
the
proxy,
so
from
a
user
point
of
view,
I'm,
not
thinking
I,
don't
want
somebody
to
think
I'm
writing
normalize
that
this
could
be
normal
I
expect
because
the
proxy
I
want
somebody
writing
that
because
they
say
I
really
don't
like
open
API
am
on
the
vocal
minority.
Did
that
likes?
Do
you
just
rest?
B
Look
I
saw,
maybe
is
so
I
can
use
a
normal
aspect
and
write
in
that
form
or
have
an
API
name
will
get
reduced
to
that
common
front,
and
then,
wherever
happens,
rumor
that
knows
I
don't
really
care,
it
can
go
directly
to
the
proxy
and
we
can
go
to
the
mixer.
The
mixture
could
push
stuff
down
to
the
mixture
client.
I
know.
We've
discussed
that
at
some
point
you
could
have
a
purely
mixture
based
version
of
this.
F
B
B
F
B
Separate
things
so,
whenever
we
have
in
the
mixture
client
now,
the
mixture
client
can
continue
to
consume.
We
have
code
looped
every
time,
but
fundamentally
it's
getting
the
whatever's
in
this
new
API.
It
just
so
happens
that
that
form
looks
just
like
very,
very
similar
to
the
normal
I
expect.
Remember
boys
in
here,
because
it
is
the
minimal
amount
that
you
would
need
to
find
an
HTTP.
A
B
F
F
When
user,
where
the
APS
back,
they
should
this
resource
since
many
years
back
that,
what's
meant
for,
instead
of
writing,
what
makes
our
country
so
I
think
the
only
disconnection
is
why
this
one
can
cannot
be
just
the
form
that
it's
a
cryin
back
to
reeds
and
part
of
the
configuration.
Then
replacing
me.
Is
this
the
one
instead
of
me
having
to
maintain
two
of
this,
because
that's
kind
of
opened
the
door
like
they
can
actually
come
fake.
The
API
through
the
mix,
a
client
come
fake
and
store
this,
and
that's.
B
B
A
B
B
To
be,
I
spec,
it
includes
a
reference
to
the
normalized
form
and
that
is
very
similar
to
what
would
be
given
to
the
normally
source
very
similar.
What
would
be
given
to
the
mixer,
but
it
also
has
findings
or
which
services
it
should
be
sent
to
which
gateways
or
bench
proxies
mesh.
You
might
need
to
send
those
to
so.
B
B
Update
you
Steve
control
to
do
the
conversion
sister
control.
Take
some
of
the
Navy
is
pectins
but
normalized
it.
But
if
that's
client
science,
if
you
want
to
update
it,
somebody's
use
an
old
version
of
the
toy
and
it's
not
consistent
with
the
version
of
tissue
that
we
ship
we
might
want
to
still
have
a
reference
to
the
original
spec.
So
if
you
haven't
make
sure
it
out
or
they
wanted
to
do
some
experiments
and
maybe
do
some
primary
validation
or
something
it's
so
you
start
adding
annotations
on
the
sierra
de.
B
B
Not
both
at
the
same
time
so
walk
into
this.
Assuming
we
just
have
the
normalized
form,
I
mean
I'm,
a
user
who
doesn't
like
the
open,
API
and
I
want
to
write
my
own
that
things
myself
so
I
do
that
and
step
one
I
push
it
to
the
API
server.
There's
some
there's
various
web
hooks
that
we'll
look
at
that
deceives
any
conversion.
Any
normalization
needs
to
be
done.
The
first
number
two,
it
doesn't
do.
B
Know
so
it
just
it
square,
but
no
on
the
second
tier
number,
three
look
and
verify
that
the
the
spec
is
will
form.
So
it
has
it's
bound
to
a
service.
It
has
a
normalized,
its
respect,
that's
well-formed,
and
then
they'll
say:
yes,
that's
actually
a
that's
artistic
validation.
The
rest
of
the
CEO
has
that
the
same
sort
of
thing
at
that
point
there
is
a
niche
that
we
would
let
the
resource
be
creative.
It
would
be
visible
to
the
rest
of
the
compliances,
become
a
CBI
HTTP,
API
spec
that
a
pilot
might
be
watching.
B
B
Form
the
number
one
can
actually
starting
with
the
normalized
one.
So
now
suppose
I
say
open
API,
it's
G,
RPC
or
something
else.
It's
not
just
I'm
going
to
specify
the
normalized
form
because
that
here's
here's
a
scheme
I
want
you
to
do
that.
I
pushed
it
to
the
advanced
server.
The
second
one
would
see
that
there
is
a
schema.
That's
so
first.
A
B
Or
you
have
a
reference
to
a
file,
that's
your
in
guy
spec,
yeah
yeah.
So
you
could
do
a
reference.
There's
some
downsides
to
that!
We're
not
above
the
file
would
be
referenced
at
the
point
where
there's
syntactic
sugar,
we
could
do
on
the
client
side
so
nice
to
show
because
they
used
to
control,
create
API,
spec
and
I
pointed
out
a
file
and
then
client
side.
We
just
take
that
file
and
we
copy
the
contents
in
line
to
in
line
to
the
CRNAs
we
hand
the
whole
thing
over
to
the
guys.
B
B
Not
manipulating
we're
saying
here's
a
snapshot
of
everything
users
made
it
a
bit
easier,
so
you
don't
have
the
cap
files
and
says
they
64
code,
so
that
point
number
one:
each
pack
has
an
inline
schema
some
service.
Now,
first,
we
can
look
and
see
that
there's
a
scheme
of
era-
and
it
can
it
recognizes
the
type
it
can
do
some
normalization.
So.
A
I
see
I
see
downsides
to
visit
that
version
of
this
approach,
because
now
I'm
running
more
opinionated,
more
complicated
work
within
the
mesh
to
do
this,
this
conversion
and
there's
really
our
target
all
completed-
are
not
able
to
do
the
work
that
the
mesh
suppose
the
mesh
is
processing
incoming
requests,
and
now
it's
got
this
little
extra
computation
that
is
doing
on
the
side
to
produce
this
state
and
from
the
user,
the
user
flow.
There
is
no
real
advantage.
A
B
C
C
C
B
So
yeah,
so
so
there's
this
point:
two
things
they
consider
is
I.
Suppose
let
me
just
start
talking
through
this,
which
and
then
so
we
do
some
server-side
normalization
now
within
a
point
three
which
is
independent
of
what
they
will
look
and
see.
Okay,
this
is
well-formed.
It
doesn't
look
at
this.
Kima
doesn't
care
about
that.
There's
a
normalized
form
as
well
form
this
ballasts
and
services.
Great,
it's
let
that
be
created.
Now
pilot
does
the
same
thing.
No
changes
looks
at
the
normalized
form
sees
as
family.
B
B
C
If
I
have
in
particular
I
might
say
you
know
what
I
want
to
write
my
own
converter,
that's
gonna,
convert
the
open,
API
spec
to
the
generic
schema
and
I'm
gonna
set
attributes
on
the
generic
schema.
That
tell
me
what
the
security
attribute
was
and
what
the
you
know:
X
IBM,
mainframe
transaction
ID
attribute
was
and
I
can
extend
it
all
I
want
and
it
doesn't
matter
whether
or
not
sto
supports
open
API.
So
at
least
an
able
thing
and
on
the
client
side
seems
to
be
able
to
be
a
very
powerful
capability.
Yeah.
B
A
C
Standard
attributes
for
certain
aspects,
so
it's
like
hey
by
the
way
you
know
the
API
key
attribute
is
always
called
you
know,
is
you
know,
open
API,
v2,
dot,
API
key
or
whatever,
and
actually
Martinelli
just
left
he's
one
of
the
vocal
minority
who
prefers
rest-
and
you
know
even
the
word
operation-
it's
not
universally
loved.
You
know.
Operation
should
just
be
an
attribute
rather
than
heart
floating
that.
So
that
is
actually
what
we
have
now.
Okay,
good.
B
A
F
Dealing
with
specific,
and
so
regarding
on
how
this
API
expect
that
the
model
which
we
transform
into
the
form
pilot
understand
I,
think
we
should
getting
aligned
with
other
transformations
and,
as
we
gonna
decide
how
so
Martin
has
the
complete
architecture
doc.
He
has
a
big
number.
We
can
do
with
imam
sadiq
effect,
I
think
if
you
could
to
have
this
one
being
in
the
same
way
and
other
convicts
aligned,
yeah.
B
A
This
adds
an
extra
dimension
on
top
of
the
options
we
have
already,
because,
because
what
you
get,
this
normalization
is
effectively
something
you
can
do
completely.
Independent
of
this
do
I'll,
do
whatever
I
want
and
produce
this
file,
and
then
that
enters
their
normal
Lister
pipeline,
or
we
can
shift
everything
right
by
one
notch
and
say:
okay,
some
of
it
is
done
inside
of
this
year.
My
preference
is
anything
that
doesn't
need
to
be
in
the
mesh
should
not
be
unless
the
user
experiences.
A
B
E
B
B
B
C
B
B
F
A
G
D
Start
so
yeah
I'm,
looking
so
NAND
and
I
guess
has
a
document
that
he
just
put
out,
which
is
kind
of
interesting
as
well,
so
I'm
not
sure
to
what
degree
we
want
to
talk
about
it
without
that
without
addressing
that,
but
without
looking
at
that
as
well.
But
you
know,
there's
there's
two
sides
to
this
or
two
questions
here
in
my
mind
anyway,
on
this
mediation
thing.
D
And
are
you
urine
and
what
I
I
have
a
little
demo
and
using
ground
rules
to
sort
of
you
know,
Jack
a
mediator
service,
basically
answer
them
and
you
know
into
the
path
and-
and
you
had
sort
of
suggested
but
enhancements,
we're
routing
rule.
It
does
the
same
thing:
yeah
more
concisely,
I
guess
so
so
yeah
I'm,
not
sure
which
is
better
or
worse
than
we
can
discuss
that,
but
I
think
as
far
as
I'm
concerned.
D
Discussion,
we
can
look
at
but
more
important
that,
if
that's
all
stuff,
that's
separate
more
transparent
than
to
the
user
that
but
the
interesting
other
thing
that's
related
to
this
whole
pictures.
What
is
this
mediator?
And
that
was
a
demo
thing
that
I
put
together?
That's
on
the
mailing
list.
The.
D
Know,
mediators,
you
know,
there's
a
lot
here
that
we're
kind
of
glossing
over
what
is
this
mediator
thing
and
I
know
man
that
stuff
kind
of
brings
up
this
notion
of
a
mediation
engine
which
says
you
know
are
we
talking
about?
Is
so
it's
like
to
sort
of
what
you're
talking
about
the
last
thing?
What's
the
actual
scope
of
this
deal
here,
are
we
going
to
do
provide
sort
of
some
kind
of
generic
mediation
service
engine
that
can
be
configured
in
the
program
to
do
transformations?
D
And-
and
you
know,
what's
this,
how
many
of
those
things
do
we
have
versus
do
to
just
provide?
You
know
a
mechanism
to
say
yeah
when
you
have
mediation
involved,
you
have
some
way
to
plug-ins,
basically
make
this.
Do
people
routing
under
the
covers
whether
it's
with
your
routing
proposal,
men
or
what
just
what's
there,
but
you
know
the
real
question
is
about
the
mediators
being
something
that
we
have
as
a
full-blown
service.
You
know
like
I,
know
the
API
management
solutions
like
IBM's,
for
example.
You
know,
there's
there's
ways
that
you
can
program.
D
You
know
I
guess,
there's
an
almost
like
there's
a
language,
a
compositional
and
for
sort
of
said,
you're,
plugging
in
and
programming
the
transformations
that
you
want
to
have.
My
little
example
has
a
little
pipeline
program
that
does
a
very
custom
validation
thing
written
by
Donna
and
I
want
to
inject
that
somehow.
So
what
is
a
mediator-
and
you
know
how's-
that
thing
programmed
seems
to
me
sort
of
a
more
fundamental
question.
Then
you
know
getting
the
details
of
you
know.
Are
we
gonna?
D
Have
this
thing
called
a
mediation
service,
or
is
it
going
to
be
some
kind
of
a
mediation
component
like
mixer
or
or
so?
Well?
So
anyway,
that's
that's
kind
of
the
discussion.
From
my
perspective
side,
other
people
have
strong.
D
Again,
maybe
we're
getting
ahead
of
what
should
wait
till
next
meeting
where
it
man
that's
here
and
we've
looked
at
his
doctrine
but
like
when
he's
talking
about
a
mixer
like
thing,
you
know
where
you
can
plug
in
stuff
into
it
like
a
mediation
engine,
that's
kind
of
a
component
of
this
yo
and
then
it
starts
getting.
You
know
more
fantasy.
In
my
mind,
you.
C
Know
I
mean
certainly
I
I
would
tend
to
have
the
same
philosophy
as
more
10,
which
is
that
it
needs
to
be
pluggable,
because
one
thing
that
we
know
enterprises
need
to
do
is
mediate
and
there's
a
lot
of
mediation
in
the
room
and
a
lot
of
ways
to
do
it.
Iii
know
we're
nom
d'un
is
coming
from
and
he's
also
thinking
that,
yes,
maybe
there's
a
concept
in
sto
called
a
mediation
service,
but
the
implementation
of
that
service
is
completely
up
to
completely
up
to
the
user.
C
D
D
It's
it's
not
clear
to
me,
though,
to
what
you
know
to
what
degree
we
we
need
to
do
the
the
same
kind
of
stuff
that
the
Jason
was
talking
about
in
terms
of
getting
some
canonical
representation
of
information.
You
might
need
to
decide
whether
you
have
to
whether
is
do
weather
envoy
is
going
to
need
to.
You
know
basically
redirect
the
calls
to
a
mediator
service
or
weather
mix.
It's
going
to
just
let
mix
you
get
this.
It's
almost
like
some
minimal
set
of
control
on
trapeze
for
that
decision.
D
A
D
D
A
Http
decoding
stuff
that
we
need
to
put
the
core
in
to
have
to
enable
the
broader
functionality,
but
for
for
this
mediation,
stuff
in
theory
is
tio
can
do
nothing.
I
mediation
is
just
about
somebody.
One
of
our
customers
decide
that
their
service
actually
is
made
up
of
two
services.
The
front
one
does
conversion
and
then
calls
a
second
one,
and
then
this
do
is
otherwise
but
I
think
we'd
like
to
do
a
little
better,
because
it's
a
it's
a
well-known,
canonical
pattern
right.
G
G
It
is
part
of
the
the
routing
API
surface
itself,
which
is
why
I
have
slight
preference
for
that,
because
it
is,
it
is
a
well
known,
routing
function,
it
is
a
well
understood,
dotting
function
and
then
it's
we
can
actually
make
it
part
of
the
repair
that
that's
that's
better.
So
yeah
I
agree
that
the
other
plan,
which
is
to
do
nothing,
is
well
that's
where
we
are
today.
G
D
G
Want
like,
if
you're
the
host,
all
the
way
to
that
intended,
you
should
say
I
want
this
type
of
function.
Get
me
that
and
then
someone
will
say:
okay
well,
that
function
is
provided
by
this
intermediary,
so
I'm
gonna,
add
via,
and
then
that
gets
down
into
and
boy
as
whatever
we
decide.
However,
it
compiles
down
to
invoice
config,
maybe.
D
I'm
still
struggling
with
this
little
back
to
this,
you
know,
if
I'm
going
to
be
trying
to
say
I,
don't
want
some
intermediate
transformation
happen.
So
I
basically
want
know
what
what
is
the
user
and
the
config
gonna
be
saying,
where
I'm
trying
to
inject
some
con
transformation
between
unity
between
the
calls
to
through
and
service
bar
and
I,
and
it's
this
transformation.
D
I
have
some
code
like
it's
my
example
in
it,
but
I
had
that
I
created
right,
it's
just
a
little
Python
program
that
goes
and
looks
at
the
body
of
the
thing
and
validates
one
of
the
fields
and
and
how
do
I
specify
that
I
want
that?
You
know
in
my
case
it's
a
service,
so
I'd
say
basically,
sex
specified
yeah
I
want
the
service
to
get
caught
in
the
path
Wow,
and
is
that
sort
of
what
we're
talking
about
here
period?
There's
no
there's
nothing!.
G
Behind
the
willow
content,
you
could
you
could
have
capabilities
for
that
service
right
or
haven't
actually
appear
named
for
that
service,
as
whatever
scanner
you
whatever
you
want
to
call
it,
and
then
at
the
highest
level,
you
could
say
that
I
want
service,
X
graphic
to
always
come
through
this
scanner
and
and
and
at
that
level.
This
is
not
the
particular
manifestation
of
service,
but
this
is
a
capability
and
somewhere
along
the
path
it
gets
translated
into.
G
A
Right
guys,
we're
running
out
of
time,
so
I
think
we
need
to
continue
the
discussion
up
there.
It's
all
actually
very
interesting,
and
it
all
ties
into
our
new
config
model
story
as
well.
This
via
thing
could
plug
in
at
different
levels,
all
right.
So
let's
continue
the
discussion
on
line
and
we'll
meet
again
in
two
weeks
that
this
will
probably
be
the
main
topic
at
that
point,
and
that's
right.