2017-02-10 18:08:06 +01:00
|
|
|
// Code generated by protoc-gen-go.
|
|
|
|
|
// source: provider.proto
|
|
|
|
|
// DO NOT EDIT!
|
|
|
|
|
|
2017-02-25 16:25:33 +01:00
|
|
|
package cocorpc
|
2017-02-10 18:08:06 +01:00
|
|
|
|
|
|
|
|
import proto "github.com/golang/protobuf/proto"
|
|
|
|
|
import fmt "fmt"
|
|
|
|
|
import math "math"
|
|
|
|
|
import google_protobuf "github.com/golang/protobuf/ptypes/empty"
|
|
|
|
|
import google_protobuf1 "github.com/golang/protobuf/ptypes/struct"
|
|
|
|
|
|
|
|
|
|
import (
|
|
|
|
|
context "golang.org/x/net/context"
|
|
|
|
|
grpc "google.golang.org/grpc"
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
|
|
|
var _ = proto.Marshal
|
|
|
|
|
var _ = fmt.Errorf
|
|
|
|
|
var _ = math.Inf
|
|
|
|
|
|
Redo object monikers
This change overhauls the way we do object monikers. The old mechanism,
generating monikers using graph paths, was far too brittle and prone to
collisions. The new approach mixes some amount of "automatic scoping"
plus some "explicit naming." Although there is some explicitness, this
is arguably a good thing, as the monikers will be relatable back to the
source more readily by developers inspecting the graph and resource state.
Each moniker has four parts:
<Namespace>::<AllocModule>::<Type>::<Name>
wherein each element is the following:
<Namespace> The namespace being deployed into
<AllocModule> The module in which the object was allocated
<Type> The type of the resource
<Name> The assigned name of the resource
The <Namespace> is essentially the deployment target -- so "prod",
"stage", etc -- although it is more general purpose to allow for future
namespacing within a target (e.g., "prod/customer1", etc); for now
this is rudimentary, however, see marapongo/mu#94.
The <AllocModule> is the token for the code that contained the 'new'
that led to this object being created. In the future, we may wish to
extend this to also track the module under evaluation. (This is a nice
aspect of monikers; they can become arbitrarily complex, so long as
they are precise, and not prone to false positives/negatives.)
The <Name> warrants more discussion. The resource provider is consulted
via a new gRPC method, Name, that fetches the name. How the provider
does this is entirely up to it. For some resource types, the resource
may have properties that developers must set (e.g., `new Bucket("foo")`);
for other providers, perhaps the resource intrinsically has a property
that explicitly and uniquely qualifies the object (e.g., AWS SecurityGroups,
via `new SecurityGroup({groupName: "my-sg"}`); and finally, it's conceivable
that a provider might auto-generate the name (e.g., such as an AWS Lambda
whose name could simply be a hash of the source code contents).
This should overall produce better results with respect to moniker
collisions, ability to match resources, and the usability of the system.
2017-02-24 23:50:02 +01:00
|
|
|
type NameRequest struct {
|
|
|
|
|
Type string `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
|
|
|
|
|
Properties *google_protobuf1.Struct `protobuf:"bytes,2,opt,name=properties" json:"properties,omitempty"`
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m *NameRequest) Reset() { *m = NameRequest{} }
|
|
|
|
|
func (m *NameRequest) String() string { return proto.CompactTextString(m) }
|
|
|
|
|
func (*NameRequest) ProtoMessage() {}
|
|
|
|
|
func (*NameRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
|
|
|
|
|
|
|
|
|
|
func (m *NameRequest) GetType() string {
|
|
|
|
|
if m != nil {
|
|
|
|
|
return m.Type
|
|
|
|
|
}
|
|
|
|
|
return ""
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m *NameRequest) GetProperties() *google_protobuf1.Struct {
|
|
|
|
|
if m != nil {
|
|
|
|
|
return m.Properties
|
|
|
|
|
}
|
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
type NameResponse struct {
|
|
|
|
|
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m *NameResponse) Reset() { *m = NameResponse{} }
|
|
|
|
|
func (m *NameResponse) String() string { return proto.CompactTextString(m) }
|
|
|
|
|
func (*NameResponse) ProtoMessage() {}
|
|
|
|
|
func (*NameResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
|
|
|
|
|
|
|
|
|
|
func (m *NameResponse) GetName() string {
|
|
|
|
|
if m != nil {
|
|
|
|
|
return m.Name
|
|
|
|
|
}
|
|
|
|
|
return ""
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-10 18:08:06 +01:00
|
|
|
type CreateRequest struct {
|
|
|
|
|
Type string `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
|
|
|
|
|
Properties *google_protobuf1.Struct `protobuf:"bytes,2,opt,name=properties" json:"properties,omitempty"`
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m *CreateRequest) Reset() { *m = CreateRequest{} }
|
|
|
|
|
func (m *CreateRequest) String() string { return proto.CompactTextString(m) }
|
|
|
|
|
func (*CreateRequest) ProtoMessage() {}
|
Redo object monikers
This change overhauls the way we do object monikers. The old mechanism,
generating monikers using graph paths, was far too brittle and prone to
collisions. The new approach mixes some amount of "automatic scoping"
plus some "explicit naming." Although there is some explicitness, this
is arguably a good thing, as the monikers will be relatable back to the
source more readily by developers inspecting the graph and resource state.
Each moniker has four parts:
<Namespace>::<AllocModule>::<Type>::<Name>
wherein each element is the following:
<Namespace> The namespace being deployed into
<AllocModule> The module in which the object was allocated
<Type> The type of the resource
<Name> The assigned name of the resource
The <Namespace> is essentially the deployment target -- so "prod",
"stage", etc -- although it is more general purpose to allow for future
namespacing within a target (e.g., "prod/customer1", etc); for now
this is rudimentary, however, see marapongo/mu#94.
The <AllocModule> is the token for the code that contained the 'new'
that led to this object being created. In the future, we may wish to
extend this to also track the module under evaluation. (This is a nice
aspect of monikers; they can become arbitrarily complex, so long as
they are precise, and not prone to false positives/negatives.)
The <Name> warrants more discussion. The resource provider is consulted
via a new gRPC method, Name, that fetches the name. How the provider
does this is entirely up to it. For some resource types, the resource
may have properties that developers must set (e.g., `new Bucket("foo")`);
for other providers, perhaps the resource intrinsically has a property
that explicitly and uniquely qualifies the object (e.g., AWS SecurityGroups,
via `new SecurityGroup({groupName: "my-sg"}`); and finally, it's conceivable
that a provider might auto-generate the name (e.g., such as an AWS Lambda
whose name could simply be a hash of the source code contents).
This should overall produce better results with respect to moniker
collisions, ability to match resources, and the usability of the system.
2017-02-24 23:50:02 +01:00
|
|
|
func (*CreateRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} }
|
2017-02-10 18:08:06 +01:00
|
|
|
|
|
|
|
|
func (m *CreateRequest) GetType() string {
|
|
|
|
|
if m != nil {
|
|
|
|
|
return m.Type
|
|
|
|
|
}
|
|
|
|
|
return ""
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m *CreateRequest) GetProperties() *google_protobuf1.Struct {
|
|
|
|
|
if m != nil {
|
|
|
|
|
return m.Properties
|
|
|
|
|
}
|
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
type CreateResponse struct {
|
|
|
|
|
Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m *CreateResponse) Reset() { *m = CreateResponse{} }
|
|
|
|
|
func (m *CreateResponse) String() string { return proto.CompactTextString(m) }
|
|
|
|
|
func (*CreateResponse) ProtoMessage() {}
|
Redo object monikers
This change overhauls the way we do object monikers. The old mechanism,
generating monikers using graph paths, was far too brittle and prone to
collisions. The new approach mixes some amount of "automatic scoping"
plus some "explicit naming." Although there is some explicitness, this
is arguably a good thing, as the monikers will be relatable back to the
source more readily by developers inspecting the graph and resource state.
Each moniker has four parts:
<Namespace>::<AllocModule>::<Type>::<Name>
wherein each element is the following:
<Namespace> The namespace being deployed into
<AllocModule> The module in which the object was allocated
<Type> The type of the resource
<Name> The assigned name of the resource
The <Namespace> is essentially the deployment target -- so "prod",
"stage", etc -- although it is more general purpose to allow for future
namespacing within a target (e.g., "prod/customer1", etc); for now
this is rudimentary, however, see marapongo/mu#94.
The <AllocModule> is the token for the code that contained the 'new'
that led to this object being created. In the future, we may wish to
extend this to also track the module under evaluation. (This is a nice
aspect of monikers; they can become arbitrarily complex, so long as
they are precise, and not prone to false positives/negatives.)
The <Name> warrants more discussion. The resource provider is consulted
via a new gRPC method, Name, that fetches the name. How the provider
does this is entirely up to it. For some resource types, the resource
may have properties that developers must set (e.g., `new Bucket("foo")`);
for other providers, perhaps the resource intrinsically has a property
that explicitly and uniquely qualifies the object (e.g., AWS SecurityGroups,
via `new SecurityGroup({groupName: "my-sg"}`); and finally, it's conceivable
that a provider might auto-generate the name (e.g., such as an AWS Lambda
whose name could simply be a hash of the source code contents).
This should overall produce better results with respect to moniker
collisions, ability to match resources, and the usability of the system.
2017-02-24 23:50:02 +01:00
|
|
|
func (*CreateResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} }
|
2017-02-10 18:08:06 +01:00
|
|
|
|
|
|
|
|
func (m *CreateResponse) GetId() string {
|
|
|
|
|
if m != nil {
|
|
|
|
|
return m.Id
|
|
|
|
|
}
|
|
|
|
|
return ""
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
type ReadRequest struct {
|
Implement resource provider plugins
This change adds basic support for discovering, loading, binding to,
and invoking RPC methods on, resource provider plugins.
In a nutshell, we add a new context object that will share cached
state such as loaded plugins and connections to them. It will be
a policy decision in server scenarios how much state to share and
between whom. This context also controls per-resource context
allocation, which in the future will allow us to perform structured
cancellation and teardown amongst entire groups of requests.
Plugins are loaded based on their name, and can be found in one of
two ways: either simply by having them on your path (with a name of
"mu-ressrv-<pkg>", where "<pkg>" is the resource package name with
any "/"s replaced with "_"s); or by placing them in the standard
library installation location, which need not be on the path for this
to work (since we know precisely where to look).
If we find a protocol, we will load it as a child process.
The protocol for plugins is that they will choose a port on their
own -- to eliminate races that'd be involved should Mu attempt to
pre-pick one for them -- and then write that out as the first line
to STDOUT (terminated by a "\n"). This is the only STDERR/STDOUT
that Mu cares about; from there, the plugin is free to write all it
pleases (e.g., for logging, debugging purposes, etc).
Afterwards, we then bind our gRPC connection to that port, and create
a typed resource provider client. The CRUD operations that get driven
by plan application are then simple wrappers atop the underlying gRPC
calls. For now, we interpret all errors as catastrophic; in the near
future, we will probably want to introduce a "structured error"
mechanism in the gRPC interface for "transactional errors"; that is,
errors for which the server was able to recover to a safe checkpoint,
which can be interpreted as ResourceOK rather than ResourceUnknown.
2017-02-19 20:08:06 +01:00
|
|
|
Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
|
|
|
|
|
Type string `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
|
2017-02-10 18:08:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m *ReadRequest) Reset() { *m = ReadRequest{} }
|
|
|
|
|
func (m *ReadRequest) String() string { return proto.CompactTextString(m) }
|
|
|
|
|
func (*ReadRequest) ProtoMessage() {}
|
Redo object monikers
This change overhauls the way we do object monikers. The old mechanism,
generating monikers using graph paths, was far too brittle and prone to
collisions. The new approach mixes some amount of "automatic scoping"
plus some "explicit naming." Although there is some explicitness, this
is arguably a good thing, as the monikers will be relatable back to the
source more readily by developers inspecting the graph and resource state.
Each moniker has four parts:
<Namespace>::<AllocModule>::<Type>::<Name>
wherein each element is the following:
<Namespace> The namespace being deployed into
<AllocModule> The module in which the object was allocated
<Type> The type of the resource
<Name> The assigned name of the resource
The <Namespace> is essentially the deployment target -- so "prod",
"stage", etc -- although it is more general purpose to allow for future
namespacing within a target (e.g., "prod/customer1", etc); for now
this is rudimentary, however, see marapongo/mu#94.
The <AllocModule> is the token for the code that contained the 'new'
that led to this object being created. In the future, we may wish to
extend this to also track the module under evaluation. (This is a nice
aspect of monikers; they can become arbitrarily complex, so long as
they are precise, and not prone to false positives/negatives.)
The <Name> warrants more discussion. The resource provider is consulted
via a new gRPC method, Name, that fetches the name. How the provider
does this is entirely up to it. For some resource types, the resource
may have properties that developers must set (e.g., `new Bucket("foo")`);
for other providers, perhaps the resource intrinsically has a property
that explicitly and uniquely qualifies the object (e.g., AWS SecurityGroups,
via `new SecurityGroup({groupName: "my-sg"}`); and finally, it's conceivable
that a provider might auto-generate the name (e.g., such as an AWS Lambda
whose name could simply be a hash of the source code contents).
This should overall produce better results with respect to moniker
collisions, ability to match resources, and the usability of the system.
2017-02-24 23:50:02 +01:00
|
|
|
func (*ReadRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} }
|
2017-02-10 18:08:06 +01:00
|
|
|
|
|
|
|
|
func (m *ReadRequest) GetId() string {
|
|
|
|
|
if m != nil {
|
|
|
|
|
return m.Id
|
|
|
|
|
}
|
|
|
|
|
return ""
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m *ReadRequest) GetType() string {
|
|
|
|
|
if m != nil {
|
|
|
|
|
return m.Type
|
|
|
|
|
}
|
|
|
|
|
return ""
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
type ReadResponse struct {
|
|
|
|
|
Properties *google_protobuf1.Struct `protobuf:"bytes,1,opt,name=properties" json:"properties,omitempty"`
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m *ReadResponse) Reset() { *m = ReadResponse{} }
|
|
|
|
|
func (m *ReadResponse) String() string { return proto.CompactTextString(m) }
|
|
|
|
|
func (*ReadResponse) ProtoMessage() {}
|
Redo object monikers
This change overhauls the way we do object monikers. The old mechanism,
generating monikers using graph paths, was far too brittle and prone to
collisions. The new approach mixes some amount of "automatic scoping"
plus some "explicit naming." Although there is some explicitness, this
is arguably a good thing, as the monikers will be relatable back to the
source more readily by developers inspecting the graph and resource state.
Each moniker has four parts:
<Namespace>::<AllocModule>::<Type>::<Name>
wherein each element is the following:
<Namespace> The namespace being deployed into
<AllocModule> The module in which the object was allocated
<Type> The type of the resource
<Name> The assigned name of the resource
The <Namespace> is essentially the deployment target -- so "prod",
"stage", etc -- although it is more general purpose to allow for future
namespacing within a target (e.g., "prod/customer1", etc); for now
this is rudimentary, however, see marapongo/mu#94.
The <AllocModule> is the token for the code that contained the 'new'
that led to this object being created. In the future, we may wish to
extend this to also track the module under evaluation. (This is a nice
aspect of monikers; they can become arbitrarily complex, so long as
they are precise, and not prone to false positives/negatives.)
The <Name> warrants more discussion. The resource provider is consulted
via a new gRPC method, Name, that fetches the name. How the provider
does this is entirely up to it. For some resource types, the resource
may have properties that developers must set (e.g., `new Bucket("foo")`);
for other providers, perhaps the resource intrinsically has a property
that explicitly and uniquely qualifies the object (e.g., AWS SecurityGroups,
via `new SecurityGroup({groupName: "my-sg"}`); and finally, it's conceivable
that a provider might auto-generate the name (e.g., such as an AWS Lambda
whose name could simply be a hash of the source code contents).
This should overall produce better results with respect to moniker
collisions, ability to match resources, and the usability of the system.
2017-02-24 23:50:02 +01:00
|
|
|
func (*ReadResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{5} }
|
2017-02-10 18:08:06 +01:00
|
|
|
|
|
|
|
|
func (m *ReadResponse) GetProperties() *google_protobuf1.Struct {
|
|
|
|
|
if m != nil {
|
|
|
|
|
return m.Properties
|
|
|
|
|
}
|
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
type UpdateRequest struct {
|
2017-02-11 22:14:29 +01:00
|
|
|
Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
|
|
|
|
|
Type string `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
|
|
|
|
|
Olds *google_protobuf1.Struct `protobuf:"bytes,3,opt,name=olds" json:"olds,omitempty"`
|
|
|
|
|
News *google_protobuf1.Struct `protobuf:"bytes,4,opt,name=news" json:"news,omitempty"`
|
2017-02-10 18:08:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m *UpdateRequest) Reset() { *m = UpdateRequest{} }
|
|
|
|
|
func (m *UpdateRequest) String() string { return proto.CompactTextString(m) }
|
|
|
|
|
func (*UpdateRequest) ProtoMessage() {}
|
Redo object monikers
This change overhauls the way we do object monikers. The old mechanism,
generating monikers using graph paths, was far too brittle and prone to
collisions. The new approach mixes some amount of "automatic scoping"
plus some "explicit naming." Although there is some explicitness, this
is arguably a good thing, as the monikers will be relatable back to the
source more readily by developers inspecting the graph and resource state.
Each moniker has four parts:
<Namespace>::<AllocModule>::<Type>::<Name>
wherein each element is the following:
<Namespace> The namespace being deployed into
<AllocModule> The module in which the object was allocated
<Type> The type of the resource
<Name> The assigned name of the resource
The <Namespace> is essentially the deployment target -- so "prod",
"stage", etc -- although it is more general purpose to allow for future
namespacing within a target (e.g., "prod/customer1", etc); for now
this is rudimentary, however, see marapongo/mu#94.
The <AllocModule> is the token for the code that contained the 'new'
that led to this object being created. In the future, we may wish to
extend this to also track the module under evaluation. (This is a nice
aspect of monikers; they can become arbitrarily complex, so long as
they are precise, and not prone to false positives/negatives.)
The <Name> warrants more discussion. The resource provider is consulted
via a new gRPC method, Name, that fetches the name. How the provider
does this is entirely up to it. For some resource types, the resource
may have properties that developers must set (e.g., `new Bucket("foo")`);
for other providers, perhaps the resource intrinsically has a property
that explicitly and uniquely qualifies the object (e.g., AWS SecurityGroups,
via `new SecurityGroup({groupName: "my-sg"}`); and finally, it's conceivable
that a provider might auto-generate the name (e.g., such as an AWS Lambda
whose name could simply be a hash of the source code contents).
This should overall produce better results with respect to moniker
collisions, ability to match resources, and the usability of the system.
2017-02-24 23:50:02 +01:00
|
|
|
func (*UpdateRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{6} }
|
2017-02-10 18:08:06 +01:00
|
|
|
|
|
|
|
|
func (m *UpdateRequest) GetId() string {
|
|
|
|
|
if m != nil {
|
|
|
|
|
return m.Id
|
|
|
|
|
}
|
|
|
|
|
return ""
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m *UpdateRequest) GetType() string {
|
|
|
|
|
if m != nil {
|
|
|
|
|
return m.Type
|
|
|
|
|
}
|
|
|
|
|
return ""
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-11 22:14:29 +01:00
|
|
|
func (m *UpdateRequest) GetOlds() *google_protobuf1.Struct {
|
2017-02-10 18:08:06 +01:00
|
|
|
if m != nil {
|
2017-02-11 22:14:29 +01:00
|
|
|
return m.Olds
|
|
|
|
|
}
|
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m *UpdateRequest) GetNews() *google_protobuf1.Struct {
|
|
|
|
|
if m != nil {
|
|
|
|
|
return m.News
|
2017-02-10 18:08:06 +01:00
|
|
|
}
|
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-11 22:14:29 +01:00
|
|
|
type UpdateResponse struct {
|
|
|
|
|
Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m *UpdateResponse) Reset() { *m = UpdateResponse{} }
|
|
|
|
|
func (m *UpdateResponse) String() string { return proto.CompactTextString(m) }
|
|
|
|
|
func (*UpdateResponse) ProtoMessage() {}
|
Redo object monikers
This change overhauls the way we do object monikers. The old mechanism,
generating monikers using graph paths, was far too brittle and prone to
collisions. The new approach mixes some amount of "automatic scoping"
plus some "explicit naming." Although there is some explicitness, this
is arguably a good thing, as the monikers will be relatable back to the
source more readily by developers inspecting the graph and resource state.
Each moniker has four parts:
<Namespace>::<AllocModule>::<Type>::<Name>
wherein each element is the following:
<Namespace> The namespace being deployed into
<AllocModule> The module in which the object was allocated
<Type> The type of the resource
<Name> The assigned name of the resource
The <Namespace> is essentially the deployment target -- so "prod",
"stage", etc -- although it is more general purpose to allow for future
namespacing within a target (e.g., "prod/customer1", etc); for now
this is rudimentary, however, see marapongo/mu#94.
The <AllocModule> is the token for the code that contained the 'new'
that led to this object being created. In the future, we may wish to
extend this to also track the module under evaluation. (This is a nice
aspect of monikers; they can become arbitrarily complex, so long as
they are precise, and not prone to false positives/negatives.)
The <Name> warrants more discussion. The resource provider is consulted
via a new gRPC method, Name, that fetches the name. How the provider
does this is entirely up to it. For some resource types, the resource
may have properties that developers must set (e.g., `new Bucket("foo")`);
for other providers, perhaps the resource intrinsically has a property
that explicitly and uniquely qualifies the object (e.g., AWS SecurityGroups,
via `new SecurityGroup({groupName: "my-sg"}`); and finally, it's conceivable
that a provider might auto-generate the name (e.g., such as an AWS Lambda
whose name could simply be a hash of the source code contents).
This should overall produce better results with respect to moniker
collisions, ability to match resources, and the usability of the system.
2017-02-24 23:50:02 +01:00
|
|
|
func (*UpdateResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{7} }
|
2017-02-11 22:14:29 +01:00
|
|
|
|
|
|
|
|
func (m *UpdateResponse) GetId() string {
|
|
|
|
|
if m != nil {
|
|
|
|
|
return m.Id
|
|
|
|
|
}
|
|
|
|
|
return ""
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-10 18:08:06 +01:00
|
|
|
type DeleteRequest struct {
|
Implement resource provider plugins
This change adds basic support for discovering, loading, binding to,
and invoking RPC methods on, resource provider plugins.
In a nutshell, we add a new context object that will share cached
state such as loaded plugins and connections to them. It will be
a policy decision in server scenarios how much state to share and
between whom. This context also controls per-resource context
allocation, which in the future will allow us to perform structured
cancellation and teardown amongst entire groups of requests.
Plugins are loaded based on their name, and can be found in one of
two ways: either simply by having them on your path (with a name of
"mu-ressrv-<pkg>", where "<pkg>" is the resource package name with
any "/"s replaced with "_"s); or by placing them in the standard
library installation location, which need not be on the path for this
to work (since we know precisely where to look).
If we find a protocol, we will load it as a child process.
The protocol for plugins is that they will choose a port on their
own -- to eliminate races that'd be involved should Mu attempt to
pre-pick one for them -- and then write that out as the first line
to STDOUT (terminated by a "\n"). This is the only STDERR/STDOUT
that Mu cares about; from there, the plugin is free to write all it
pleases (e.g., for logging, debugging purposes, etc).
Afterwards, we then bind our gRPC connection to that port, and create
a typed resource provider client. The CRUD operations that get driven
by plan application are then simple wrappers atop the underlying gRPC
calls. For now, we interpret all errors as catastrophic; in the near
future, we will probably want to introduce a "structured error"
mechanism in the gRPC interface for "transactional errors"; that is,
errors for which the server was able to recover to a safe checkpoint,
which can be interpreted as ResourceOK rather than ResourceUnknown.
2017-02-19 20:08:06 +01:00
|
|
|
Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
|
|
|
|
|
Type string `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
|
2017-02-10 18:08:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (m *DeleteRequest) Reset() { *m = DeleteRequest{} }
|
|
|
|
|
func (m *DeleteRequest) String() string { return proto.CompactTextString(m) }
|
|
|
|
|
func (*DeleteRequest) ProtoMessage() {}
|
Redo object monikers
This change overhauls the way we do object monikers. The old mechanism,
generating monikers using graph paths, was far too brittle and prone to
collisions. The new approach mixes some amount of "automatic scoping"
plus some "explicit naming." Although there is some explicitness, this
is arguably a good thing, as the monikers will be relatable back to the
source more readily by developers inspecting the graph and resource state.
Each moniker has four parts:
<Namespace>::<AllocModule>::<Type>::<Name>
wherein each element is the following:
<Namespace> The namespace being deployed into
<AllocModule> The module in which the object was allocated
<Type> The type of the resource
<Name> The assigned name of the resource
The <Namespace> is essentially the deployment target -- so "prod",
"stage", etc -- although it is more general purpose to allow for future
namespacing within a target (e.g., "prod/customer1", etc); for now
this is rudimentary, however, see marapongo/mu#94.
The <AllocModule> is the token for the code that contained the 'new'
that led to this object being created. In the future, we may wish to
extend this to also track the module under evaluation. (This is a nice
aspect of monikers; they can become arbitrarily complex, so long as
they are precise, and not prone to false positives/negatives.)
The <Name> warrants more discussion. The resource provider is consulted
via a new gRPC method, Name, that fetches the name. How the provider
does this is entirely up to it. For some resource types, the resource
may have properties that developers must set (e.g., `new Bucket("foo")`);
for other providers, perhaps the resource intrinsically has a property
that explicitly and uniquely qualifies the object (e.g., AWS SecurityGroups,
via `new SecurityGroup({groupName: "my-sg"}`); and finally, it's conceivable
that a provider might auto-generate the name (e.g., such as an AWS Lambda
whose name could simply be a hash of the source code contents).
This should overall produce better results with respect to moniker
collisions, ability to match resources, and the usability of the system.
2017-02-24 23:50:02 +01:00
|
|
|
func (*DeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{8} }
|
2017-02-10 18:08:06 +01:00
|
|
|
|
|
|
|
|
func (m *DeleteRequest) GetId() string {
|
|
|
|
|
if m != nil {
|
|
|
|
|
return m.Id
|
|
|
|
|
}
|
|
|
|
|
return ""
|
|
|
|
|
}
|
|
|
|
|
|
Implement resource provider plugins
This change adds basic support for discovering, loading, binding to,
and invoking RPC methods on, resource provider plugins.
In a nutshell, we add a new context object that will share cached
state such as loaded plugins and connections to them. It will be
a policy decision in server scenarios how much state to share and
between whom. This context also controls per-resource context
allocation, which in the future will allow us to perform structured
cancellation and teardown amongst entire groups of requests.
Plugins are loaded based on their name, and can be found in one of
two ways: either simply by having them on your path (with a name of
"mu-ressrv-<pkg>", where "<pkg>" is the resource package name with
any "/"s replaced with "_"s); or by placing them in the standard
library installation location, which need not be on the path for this
to work (since we know precisely where to look).
If we find a protocol, we will load it as a child process.
The protocol for plugins is that they will choose a port on their
own -- to eliminate races that'd be involved should Mu attempt to
pre-pick one for them -- and then write that out as the first line
to STDOUT (terminated by a "\n"). This is the only STDERR/STDOUT
that Mu cares about; from there, the plugin is free to write all it
pleases (e.g., for logging, debugging purposes, etc).
Afterwards, we then bind our gRPC connection to that port, and create
a typed resource provider client. The CRUD operations that get driven
by plan application are then simple wrappers atop the underlying gRPC
calls. For now, we interpret all errors as catastrophic; in the near
future, we will probably want to introduce a "structured error"
mechanism in the gRPC interface for "transactional errors"; that is,
errors for which the server was able to recover to a safe checkpoint,
which can be interpreted as ResourceOK rather than ResourceUnknown.
2017-02-19 20:08:06 +01:00
|
|
|
func (m *DeleteRequest) GetType() string {
|
|
|
|
|
if m != nil {
|
|
|
|
|
return m.Type
|
|
|
|
|
}
|
|
|
|
|
return ""
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-10 18:08:06 +01:00
|
|
|
func init() {
|
2017-02-25 16:25:33 +01:00
|
|
|
proto.RegisterType((*NameRequest)(nil), "cocorpc.NameRequest")
|
|
|
|
|
proto.RegisterType((*NameResponse)(nil), "cocorpc.NameResponse")
|
|
|
|
|
proto.RegisterType((*CreateRequest)(nil), "cocorpc.CreateRequest")
|
|
|
|
|
proto.RegisterType((*CreateResponse)(nil), "cocorpc.CreateResponse")
|
|
|
|
|
proto.RegisterType((*ReadRequest)(nil), "cocorpc.ReadRequest")
|
|
|
|
|
proto.RegisterType((*ReadResponse)(nil), "cocorpc.ReadResponse")
|
|
|
|
|
proto.RegisterType((*UpdateRequest)(nil), "cocorpc.UpdateRequest")
|
|
|
|
|
proto.RegisterType((*UpdateResponse)(nil), "cocorpc.UpdateResponse")
|
|
|
|
|
proto.RegisterType((*DeleteRequest)(nil), "cocorpc.DeleteRequest")
|
2017-02-10 18:08:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
|
|
|
var _ context.Context
|
|
|
|
|
var _ grpc.ClientConn
|
|
|
|
|
|
|
|
|
|
// This is a compile-time assertion to ensure that this generated file
|
|
|
|
|
// is compatible with the grpc package it is being compiled against.
|
|
|
|
|
const _ = grpc.SupportPackageIsVersion4
|
|
|
|
|
|
|
|
|
|
// Client API for ResourceProvider service
|
|
|
|
|
|
|
|
|
|
type ResourceProviderClient interface {
|
Redo object monikers
This change overhauls the way we do object monikers. The old mechanism,
generating monikers using graph paths, was far too brittle and prone to
collisions. The new approach mixes some amount of "automatic scoping"
plus some "explicit naming." Although there is some explicitness, this
is arguably a good thing, as the monikers will be relatable back to the
source more readily by developers inspecting the graph and resource state.
Each moniker has four parts:
<Namespace>::<AllocModule>::<Type>::<Name>
wherein each element is the following:
<Namespace> The namespace being deployed into
<AllocModule> The module in which the object was allocated
<Type> The type of the resource
<Name> The assigned name of the resource
The <Namespace> is essentially the deployment target -- so "prod",
"stage", etc -- although it is more general purpose to allow for future
namespacing within a target (e.g., "prod/customer1", etc); for now
this is rudimentary, however, see marapongo/mu#94.
The <AllocModule> is the token for the code that contained the 'new'
that led to this object being created. In the future, we may wish to
extend this to also track the module under evaluation. (This is a nice
aspect of monikers; they can become arbitrarily complex, so long as
they are precise, and not prone to false positives/negatives.)
The <Name> warrants more discussion. The resource provider is consulted
via a new gRPC method, Name, that fetches the name. How the provider
does this is entirely up to it. For some resource types, the resource
may have properties that developers must set (e.g., `new Bucket("foo")`);
for other providers, perhaps the resource intrinsically has a property
that explicitly and uniquely qualifies the object (e.g., AWS SecurityGroups,
via `new SecurityGroup({groupName: "my-sg"}`); and finally, it's conceivable
that a provider might auto-generate the name (e.g., such as an AWS Lambda
whose name could simply be a hash of the source code contents).
This should overall produce better results with respect to moniker
collisions, ability to match resources, and the usability of the system.
2017-02-24 23:50:02 +01:00
|
|
|
// Name names a given resource. Sometimes this will be assigned by a developer, and so the provider
|
|
|
|
|
// simply fetches it from the property bag; other times, the provider will assign this based on its own algorithm.
|
|
|
|
|
// In any case, resources with the same name must be safe to use interchangeably with one another.
|
|
|
|
|
Name(ctx context.Context, in *NameRequest, opts ...grpc.CallOption) (*NameResponse, error)
|
2017-02-10 18:08:06 +01:00
|
|
|
// Create allocates a new instance of the provided resource and returns its unique ID afterwards. (The input ID
|
|
|
|
|
// must be blank.) If this call fails, the resource must not have been created (i.e., it is "transacational").
|
|
|
|
|
Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error)
|
Implement resource provider plugins
This change adds basic support for discovering, loading, binding to,
and invoking RPC methods on, resource provider plugins.
In a nutshell, we add a new context object that will share cached
state such as loaded plugins and connections to them. It will be
a policy decision in server scenarios how much state to share and
between whom. This context also controls per-resource context
allocation, which in the future will allow us to perform structured
cancellation and teardown amongst entire groups of requests.
Plugins are loaded based on their name, and can be found in one of
two ways: either simply by having them on your path (with a name of
"mu-ressrv-<pkg>", where "<pkg>" is the resource package name with
any "/"s replaced with "_"s); or by placing them in the standard
library installation location, which need not be on the path for this
to work (since we know precisely where to look).
If we find a protocol, we will load it as a child process.
The protocol for plugins is that they will choose a port on their
own -- to eliminate races that'd be involved should Mu attempt to
pre-pick one for them -- and then write that out as the first line
to STDOUT (terminated by a "\n"). This is the only STDERR/STDOUT
that Mu cares about; from there, the plugin is free to write all it
pleases (e.g., for logging, debugging purposes, etc).
Afterwards, we then bind our gRPC connection to that port, and create
a typed resource provider client. The CRUD operations that get driven
by plan application are then simple wrappers atop the underlying gRPC
calls. For now, we interpret all errors as catastrophic; in the near
future, we will probably want to introduce a "structured error"
mechanism in the gRPC interface for "transactional errors"; that is,
errors for which the server was able to recover to a safe checkpoint,
which can be interpreted as ResourceOK rather than ResourceUnknown.
2017-02-19 20:08:06 +01:00
|
|
|
// Read reads the instance state identified by ID, returning a populated resource object, or an error if not found.
|
2017-02-10 18:08:06 +01:00
|
|
|
Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (*ReadResponse, error)
|
2017-02-11 22:14:29 +01:00
|
|
|
// Update updates an existing resource with new values. Only those values in the provided property bag are updated
|
|
|
|
|
// to new values. The resource ID is returned and may be different if the resource had to be recreated.
|
|
|
|
|
Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error)
|
2017-02-10 18:08:06 +01:00
|
|
|
// Delete tears down an existing resource with the given ID. If it fails, the resource is assumed to still exist.
|
|
|
|
|
Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
type resourceProviderClient struct {
|
|
|
|
|
cc *grpc.ClientConn
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func NewResourceProviderClient(cc *grpc.ClientConn) ResourceProviderClient {
|
|
|
|
|
return &resourceProviderClient{cc}
|
|
|
|
|
}
|
|
|
|
|
|
Redo object monikers
This change overhauls the way we do object monikers. The old mechanism,
generating monikers using graph paths, was far too brittle and prone to
collisions. The new approach mixes some amount of "automatic scoping"
plus some "explicit naming." Although there is some explicitness, this
is arguably a good thing, as the monikers will be relatable back to the
source more readily by developers inspecting the graph and resource state.
Each moniker has four parts:
<Namespace>::<AllocModule>::<Type>::<Name>
wherein each element is the following:
<Namespace> The namespace being deployed into
<AllocModule> The module in which the object was allocated
<Type> The type of the resource
<Name> The assigned name of the resource
The <Namespace> is essentially the deployment target -- so "prod",
"stage", etc -- although it is more general purpose to allow for future
namespacing within a target (e.g., "prod/customer1", etc); for now
this is rudimentary, however, see marapongo/mu#94.
The <AllocModule> is the token for the code that contained the 'new'
that led to this object being created. In the future, we may wish to
extend this to also track the module under evaluation. (This is a nice
aspect of monikers; they can become arbitrarily complex, so long as
they are precise, and not prone to false positives/negatives.)
The <Name> warrants more discussion. The resource provider is consulted
via a new gRPC method, Name, that fetches the name. How the provider
does this is entirely up to it. For some resource types, the resource
may have properties that developers must set (e.g., `new Bucket("foo")`);
for other providers, perhaps the resource intrinsically has a property
that explicitly and uniquely qualifies the object (e.g., AWS SecurityGroups,
via `new SecurityGroup({groupName: "my-sg"}`); and finally, it's conceivable
that a provider might auto-generate the name (e.g., such as an AWS Lambda
whose name could simply be a hash of the source code contents).
This should overall produce better results with respect to moniker
collisions, ability to match resources, and the usability of the system.
2017-02-24 23:50:02 +01:00
|
|
|
func (c *resourceProviderClient) Name(ctx context.Context, in *NameRequest, opts ...grpc.CallOption) (*NameResponse, error) {
|
|
|
|
|
out := new(NameResponse)
|
2017-02-25 16:25:33 +01:00
|
|
|
err := grpc.Invoke(ctx, "/cocorpc.ResourceProvider/Name", in, out, c.cc, opts...)
|
Redo object monikers
This change overhauls the way we do object monikers. The old mechanism,
generating monikers using graph paths, was far too brittle and prone to
collisions. The new approach mixes some amount of "automatic scoping"
plus some "explicit naming." Although there is some explicitness, this
is arguably a good thing, as the monikers will be relatable back to the
source more readily by developers inspecting the graph and resource state.
Each moniker has four parts:
<Namespace>::<AllocModule>::<Type>::<Name>
wherein each element is the following:
<Namespace> The namespace being deployed into
<AllocModule> The module in which the object was allocated
<Type> The type of the resource
<Name> The assigned name of the resource
The <Namespace> is essentially the deployment target -- so "prod",
"stage", etc -- although it is more general purpose to allow for future
namespacing within a target (e.g., "prod/customer1", etc); for now
this is rudimentary, however, see marapongo/mu#94.
The <AllocModule> is the token for the code that contained the 'new'
that led to this object being created. In the future, we may wish to
extend this to also track the module under evaluation. (This is a nice
aspect of monikers; they can become arbitrarily complex, so long as
they are precise, and not prone to false positives/negatives.)
The <Name> warrants more discussion. The resource provider is consulted
via a new gRPC method, Name, that fetches the name. How the provider
does this is entirely up to it. For some resource types, the resource
may have properties that developers must set (e.g., `new Bucket("foo")`);
for other providers, perhaps the resource intrinsically has a property
that explicitly and uniquely qualifies the object (e.g., AWS SecurityGroups,
via `new SecurityGroup({groupName: "my-sg"}`); and finally, it's conceivable
that a provider might auto-generate the name (e.g., such as an AWS Lambda
whose name could simply be a hash of the source code contents).
This should overall produce better results with respect to moniker
collisions, ability to match resources, and the usability of the system.
2017-02-24 23:50:02 +01:00
|
|
|
if err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
return out, nil
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-10 18:08:06 +01:00
|
|
|
func (c *resourceProviderClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) {
|
|
|
|
|
out := new(CreateResponse)
|
2017-02-25 16:25:33 +01:00
|
|
|
err := grpc.Invoke(ctx, "/cocorpc.ResourceProvider/Create", in, out, c.cc, opts...)
|
2017-02-10 18:08:06 +01:00
|
|
|
if err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
return out, nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (c *resourceProviderClient) Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (*ReadResponse, error) {
|
|
|
|
|
out := new(ReadResponse)
|
2017-02-25 16:25:33 +01:00
|
|
|
err := grpc.Invoke(ctx, "/cocorpc.ResourceProvider/Read", in, out, c.cc, opts...)
|
2017-02-10 18:08:06 +01:00
|
|
|
if err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
return out, nil
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-11 22:14:29 +01:00
|
|
|
func (c *resourceProviderClient) Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) {
|
|
|
|
|
out := new(UpdateResponse)
|
2017-02-25 16:25:33 +01:00
|
|
|
err := grpc.Invoke(ctx, "/cocorpc.ResourceProvider/Update", in, out, c.cc, opts...)
|
2017-02-10 18:08:06 +01:00
|
|
|
if err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
return out, nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (c *resourceProviderClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
|
|
|
|
|
out := new(google_protobuf.Empty)
|
2017-02-25 16:25:33 +01:00
|
|
|
err := grpc.Invoke(ctx, "/cocorpc.ResourceProvider/Delete", in, out, c.cc, opts...)
|
2017-02-10 18:08:06 +01:00
|
|
|
if err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
return out, nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Server API for ResourceProvider service
|
|
|
|
|
|
|
|
|
|
type ResourceProviderServer interface {
|
Redo object monikers
This change overhauls the way we do object monikers. The old mechanism,
generating monikers using graph paths, was far too brittle and prone to
collisions. The new approach mixes some amount of "automatic scoping"
plus some "explicit naming." Although there is some explicitness, this
is arguably a good thing, as the monikers will be relatable back to the
source more readily by developers inspecting the graph and resource state.
Each moniker has four parts:
<Namespace>::<AllocModule>::<Type>::<Name>
wherein each element is the following:
<Namespace> The namespace being deployed into
<AllocModule> The module in which the object was allocated
<Type> The type of the resource
<Name> The assigned name of the resource
The <Namespace> is essentially the deployment target -- so "prod",
"stage", etc -- although it is more general purpose to allow for future
namespacing within a target (e.g., "prod/customer1", etc); for now
this is rudimentary, however, see marapongo/mu#94.
The <AllocModule> is the token for the code that contained the 'new'
that led to this object being created. In the future, we may wish to
extend this to also track the module under evaluation. (This is a nice
aspect of monikers; they can become arbitrarily complex, so long as
they are precise, and not prone to false positives/negatives.)
The <Name> warrants more discussion. The resource provider is consulted
via a new gRPC method, Name, that fetches the name. How the provider
does this is entirely up to it. For some resource types, the resource
may have properties that developers must set (e.g., `new Bucket("foo")`);
for other providers, perhaps the resource intrinsically has a property
that explicitly and uniquely qualifies the object (e.g., AWS SecurityGroups,
via `new SecurityGroup({groupName: "my-sg"}`); and finally, it's conceivable
that a provider might auto-generate the name (e.g., such as an AWS Lambda
whose name could simply be a hash of the source code contents).
This should overall produce better results with respect to moniker
collisions, ability to match resources, and the usability of the system.
2017-02-24 23:50:02 +01:00
|
|
|
// Name names a given resource. Sometimes this will be assigned by a developer, and so the provider
|
|
|
|
|
// simply fetches it from the property bag; other times, the provider will assign this based on its own algorithm.
|
|
|
|
|
// In any case, resources with the same name must be safe to use interchangeably with one another.
|
|
|
|
|
Name(context.Context, *NameRequest) (*NameResponse, error)
|
2017-02-10 18:08:06 +01:00
|
|
|
// Create allocates a new instance of the provided resource and returns its unique ID afterwards. (The input ID
|
|
|
|
|
// must be blank.) If this call fails, the resource must not have been created (i.e., it is "transacational").
|
|
|
|
|
Create(context.Context, *CreateRequest) (*CreateResponse, error)
|
Implement resource provider plugins
This change adds basic support for discovering, loading, binding to,
and invoking RPC methods on, resource provider plugins.
In a nutshell, we add a new context object that will share cached
state such as loaded plugins and connections to them. It will be
a policy decision in server scenarios how much state to share and
between whom. This context also controls per-resource context
allocation, which in the future will allow us to perform structured
cancellation and teardown amongst entire groups of requests.
Plugins are loaded based on their name, and can be found in one of
two ways: either simply by having them on your path (with a name of
"mu-ressrv-<pkg>", where "<pkg>" is the resource package name with
any "/"s replaced with "_"s); or by placing them in the standard
library installation location, which need not be on the path for this
to work (since we know precisely where to look).
If we find a protocol, we will load it as a child process.
The protocol for plugins is that they will choose a port on their
own -- to eliminate races that'd be involved should Mu attempt to
pre-pick one for them -- and then write that out as the first line
to STDOUT (terminated by a "\n"). This is the only STDERR/STDOUT
that Mu cares about; from there, the plugin is free to write all it
pleases (e.g., for logging, debugging purposes, etc).
Afterwards, we then bind our gRPC connection to that port, and create
a typed resource provider client. The CRUD operations that get driven
by plan application are then simple wrappers atop the underlying gRPC
calls. For now, we interpret all errors as catastrophic; in the near
future, we will probably want to introduce a "structured error"
mechanism in the gRPC interface for "transactional errors"; that is,
errors for which the server was able to recover to a safe checkpoint,
which can be interpreted as ResourceOK rather than ResourceUnknown.
2017-02-19 20:08:06 +01:00
|
|
|
// Read reads the instance state identified by ID, returning a populated resource object, or an error if not found.
|
2017-02-10 18:08:06 +01:00
|
|
|
Read(context.Context, *ReadRequest) (*ReadResponse, error)
|
2017-02-11 22:14:29 +01:00
|
|
|
// Update updates an existing resource with new values. Only those values in the provided property bag are updated
|
|
|
|
|
// to new values. The resource ID is returned and may be different if the resource had to be recreated.
|
|
|
|
|
Update(context.Context, *UpdateRequest) (*UpdateResponse, error)
|
2017-02-10 18:08:06 +01:00
|
|
|
// Delete tears down an existing resource with the given ID. If it fails, the resource is assumed to still exist.
|
|
|
|
|
Delete(context.Context, *DeleteRequest) (*google_protobuf.Empty, error)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func RegisterResourceProviderServer(s *grpc.Server, srv ResourceProviderServer) {
|
|
|
|
|
s.RegisterService(&_ResourceProvider_serviceDesc, srv)
|
|
|
|
|
}
|
|
|
|
|
|
Redo object monikers
This change overhauls the way we do object monikers. The old mechanism,
generating monikers using graph paths, was far too brittle and prone to
collisions. The new approach mixes some amount of "automatic scoping"
plus some "explicit naming." Although there is some explicitness, this
is arguably a good thing, as the monikers will be relatable back to the
source more readily by developers inspecting the graph and resource state.
Each moniker has four parts:
<Namespace>::<AllocModule>::<Type>::<Name>
wherein each element is the following:
<Namespace> The namespace being deployed into
<AllocModule> The module in which the object was allocated
<Type> The type of the resource
<Name> The assigned name of the resource
The <Namespace> is essentially the deployment target -- so "prod",
"stage", etc -- although it is more general purpose to allow for future
namespacing within a target (e.g., "prod/customer1", etc); for now
this is rudimentary, however, see marapongo/mu#94.
The <AllocModule> is the token for the code that contained the 'new'
that led to this object being created. In the future, we may wish to
extend this to also track the module under evaluation. (This is a nice
aspect of monikers; they can become arbitrarily complex, so long as
they are precise, and not prone to false positives/negatives.)
The <Name> warrants more discussion. The resource provider is consulted
via a new gRPC method, Name, that fetches the name. How the provider
does this is entirely up to it. For some resource types, the resource
may have properties that developers must set (e.g., `new Bucket("foo")`);
for other providers, perhaps the resource intrinsically has a property
that explicitly and uniquely qualifies the object (e.g., AWS SecurityGroups,
via `new SecurityGroup({groupName: "my-sg"}`); and finally, it's conceivable
that a provider might auto-generate the name (e.g., such as an AWS Lambda
whose name could simply be a hash of the source code contents).
This should overall produce better results with respect to moniker
collisions, ability to match resources, and the usability of the system.
2017-02-24 23:50:02 +01:00
|
|
|
func _ResourceProvider_Name_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
|
|
|
in := new(NameRequest)
|
|
|
|
|
if err := dec(in); err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
if interceptor == nil {
|
|
|
|
|
return srv.(ResourceProviderServer).Name(ctx, in)
|
|
|
|
|
}
|
|
|
|
|
info := &grpc.UnaryServerInfo{
|
|
|
|
|
Server: srv,
|
2017-02-25 16:25:33 +01:00
|
|
|
FullMethod: "/cocorpc.ResourceProvider/Name",
|
Redo object monikers
This change overhauls the way we do object monikers. The old mechanism,
generating monikers using graph paths, was far too brittle and prone to
collisions. The new approach mixes some amount of "automatic scoping"
plus some "explicit naming." Although there is some explicitness, this
is arguably a good thing, as the monikers will be relatable back to the
source more readily by developers inspecting the graph and resource state.
Each moniker has four parts:
<Namespace>::<AllocModule>::<Type>::<Name>
wherein each element is the following:
<Namespace> The namespace being deployed into
<AllocModule> The module in which the object was allocated
<Type> The type of the resource
<Name> The assigned name of the resource
The <Namespace> is essentially the deployment target -- so "prod",
"stage", etc -- although it is more general purpose to allow for future
namespacing within a target (e.g., "prod/customer1", etc); for now
this is rudimentary, however, see marapongo/mu#94.
The <AllocModule> is the token for the code that contained the 'new'
that led to this object being created. In the future, we may wish to
extend this to also track the module under evaluation. (This is a nice
aspect of monikers; they can become arbitrarily complex, so long as
they are precise, and not prone to false positives/negatives.)
The <Name> warrants more discussion. The resource provider is consulted
via a new gRPC method, Name, that fetches the name. How the provider
does this is entirely up to it. For some resource types, the resource
may have properties that developers must set (e.g., `new Bucket("foo")`);
for other providers, perhaps the resource intrinsically has a property
that explicitly and uniquely qualifies the object (e.g., AWS SecurityGroups,
via `new SecurityGroup({groupName: "my-sg"}`); and finally, it's conceivable
that a provider might auto-generate the name (e.g., such as an AWS Lambda
whose name could simply be a hash of the source code contents).
This should overall produce better results with respect to moniker
collisions, ability to match resources, and the usability of the system.
2017-02-24 23:50:02 +01:00
|
|
|
}
|
|
|
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
|
|
|
return srv.(ResourceProviderServer).Name(ctx, req.(*NameRequest))
|
|
|
|
|
}
|
|
|
|
|
return interceptor(ctx, in, info, handler)
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-10 18:08:06 +01:00
|
|
|
func _ResourceProvider_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
|
|
|
in := new(CreateRequest)
|
|
|
|
|
if err := dec(in); err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
if interceptor == nil {
|
|
|
|
|
return srv.(ResourceProviderServer).Create(ctx, in)
|
|
|
|
|
}
|
|
|
|
|
info := &grpc.UnaryServerInfo{
|
|
|
|
|
Server: srv,
|
2017-02-25 16:25:33 +01:00
|
|
|
FullMethod: "/cocorpc.ResourceProvider/Create",
|
2017-02-10 18:08:06 +01:00
|
|
|
}
|
|
|
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
|
|
|
return srv.(ResourceProviderServer).Create(ctx, req.(*CreateRequest))
|
|
|
|
|
}
|
|
|
|
|
return interceptor(ctx, in, info, handler)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func _ResourceProvider_Read_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
|
|
|
in := new(ReadRequest)
|
|
|
|
|
if err := dec(in); err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
if interceptor == nil {
|
|
|
|
|
return srv.(ResourceProviderServer).Read(ctx, in)
|
|
|
|
|
}
|
|
|
|
|
info := &grpc.UnaryServerInfo{
|
|
|
|
|
Server: srv,
|
2017-02-25 16:25:33 +01:00
|
|
|
FullMethod: "/cocorpc.ResourceProvider/Read",
|
2017-02-10 18:08:06 +01:00
|
|
|
}
|
|
|
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
|
|
|
return srv.(ResourceProviderServer).Read(ctx, req.(*ReadRequest))
|
|
|
|
|
}
|
|
|
|
|
return interceptor(ctx, in, info, handler)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func _ResourceProvider_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
|
|
|
in := new(UpdateRequest)
|
|
|
|
|
if err := dec(in); err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
if interceptor == nil {
|
|
|
|
|
return srv.(ResourceProviderServer).Update(ctx, in)
|
|
|
|
|
}
|
|
|
|
|
info := &grpc.UnaryServerInfo{
|
|
|
|
|
Server: srv,
|
2017-02-25 16:25:33 +01:00
|
|
|
FullMethod: "/cocorpc.ResourceProvider/Update",
|
2017-02-10 18:08:06 +01:00
|
|
|
}
|
|
|
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
|
|
|
return srv.(ResourceProviderServer).Update(ctx, req.(*UpdateRequest))
|
|
|
|
|
}
|
|
|
|
|
return interceptor(ctx, in, info, handler)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func _ResourceProvider_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
|
|
|
in := new(DeleteRequest)
|
|
|
|
|
if err := dec(in); err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
if interceptor == nil {
|
|
|
|
|
return srv.(ResourceProviderServer).Delete(ctx, in)
|
|
|
|
|
}
|
|
|
|
|
info := &grpc.UnaryServerInfo{
|
|
|
|
|
Server: srv,
|
2017-02-25 16:25:33 +01:00
|
|
|
FullMethod: "/cocorpc.ResourceProvider/Delete",
|
2017-02-10 18:08:06 +01:00
|
|
|
}
|
|
|
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
|
|
|
return srv.(ResourceProviderServer).Delete(ctx, req.(*DeleteRequest))
|
|
|
|
|
}
|
|
|
|
|
return interceptor(ctx, in, info, handler)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var _ResourceProvider_serviceDesc = grpc.ServiceDesc{
|
2017-02-25 16:25:33 +01:00
|
|
|
ServiceName: "cocorpc.ResourceProvider",
|
2017-02-10 18:08:06 +01:00
|
|
|
HandlerType: (*ResourceProviderServer)(nil),
|
|
|
|
|
Methods: []grpc.MethodDesc{
|
Redo object monikers
This change overhauls the way we do object monikers. The old mechanism,
generating monikers using graph paths, was far too brittle and prone to
collisions. The new approach mixes some amount of "automatic scoping"
plus some "explicit naming." Although there is some explicitness, this
is arguably a good thing, as the monikers will be relatable back to the
source more readily by developers inspecting the graph and resource state.
Each moniker has four parts:
<Namespace>::<AllocModule>::<Type>::<Name>
wherein each element is the following:
<Namespace> The namespace being deployed into
<AllocModule> The module in which the object was allocated
<Type> The type of the resource
<Name> The assigned name of the resource
The <Namespace> is essentially the deployment target -- so "prod",
"stage", etc -- although it is more general purpose to allow for future
namespacing within a target (e.g., "prod/customer1", etc); for now
this is rudimentary, however, see marapongo/mu#94.
The <AllocModule> is the token for the code that contained the 'new'
that led to this object being created. In the future, we may wish to
extend this to also track the module under evaluation. (This is a nice
aspect of monikers; they can become arbitrarily complex, so long as
they are precise, and not prone to false positives/negatives.)
The <Name> warrants more discussion. The resource provider is consulted
via a new gRPC method, Name, that fetches the name. How the provider
does this is entirely up to it. For some resource types, the resource
may have properties that developers must set (e.g., `new Bucket("foo")`);
for other providers, perhaps the resource intrinsically has a property
that explicitly and uniquely qualifies the object (e.g., AWS SecurityGroups,
via `new SecurityGroup({groupName: "my-sg"}`); and finally, it's conceivable
that a provider might auto-generate the name (e.g., such as an AWS Lambda
whose name could simply be a hash of the source code contents).
This should overall produce better results with respect to moniker
collisions, ability to match resources, and the usability of the system.
2017-02-24 23:50:02 +01:00
|
|
|
{
|
|
|
|
|
MethodName: "Name",
|
|
|
|
|
Handler: _ResourceProvider_Name_Handler,
|
|
|
|
|
},
|
2017-02-10 18:08:06 +01:00
|
|
|
{
|
|
|
|
|
MethodName: "Create",
|
|
|
|
|
Handler: _ResourceProvider_Create_Handler,
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
MethodName: "Read",
|
|
|
|
|
Handler: _ResourceProvider_Read_Handler,
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
MethodName: "Update",
|
|
|
|
|
Handler: _ResourceProvider_Update_Handler,
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
MethodName: "Delete",
|
|
|
|
|
Handler: _ResourceProvider_Delete_Handler,
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
Streams: []grpc.StreamDesc{},
|
|
|
|
|
Metadata: "provider.proto",
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func init() { proto.RegisterFile("provider.proto", fileDescriptor1) }
|
|
|
|
|
|
|
|
|
|
var fileDescriptor1 = []byte{
|
2017-02-25 16:25:33 +01:00
|
|
|
// 388 bytes of a gzipped FileDescriptorProto
|
|
|
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xb4, 0x53, 0x4d, 0x6b, 0xe3, 0x30,
|
|
|
|
|
0x14, 0x8c, 0xbd, 0x26, 0xcb, 0xbe, 0x7c, 0xb0, 0x88, 0xdd, 0xc4, 0x78, 0xf7, 0x10, 0x74, 0x0a,
|
|
|
|
|
0x2c, 0x38, 0x6c, 0x42, 0x58, 0xd8, 0x1e, 0xdb, 0xd2, 0x5b, 0x29, 0x2e, 0xbd, 0x94, 0x5e, 0x1c,
|
|
|
|
|
0xfb, 0x35, 0x18, 0x92, 0x48, 0x95, 0xe4, 0x96, 0xfc, 0x88, 0xfe, 0x9d, 0xfe, 0xbe, 0x22, 0xcb,
|
|
|
|
|
0x76, 0xe5, 0x84, 0xb6, 0xe9, 0xa1, 0x37, 0xf1, 0x34, 0x9a, 0x19, 0xcf, 0x3c, 0x43, 0x9f, 0x0b,
|
|
|
|
|
0x76, 0x9f, 0xa5, 0x28, 0x42, 0x2e, 0x98, 0x62, 0xe4, 0x6b, 0xc2, 0x12, 0x26, 0x78, 0x12, 0xfc,
|
|
|
|
|
0x5a, 0x32, 0xb6, 0x5c, 0xe1, 0xa4, 0x18, 0x2f, 0xf2, 0xdb, 0x09, 0xae, 0xb9, 0xda, 0x1a, 0x54,
|
|
|
|
|
0xf0, 0x7b, 0xf7, 0x52, 0x2a, 0x91, 0x27, 0xca, 0xdc, 0xd2, 0x6b, 0xe8, 0x9c, 0xc7, 0x6b, 0x8c,
|
|
|
|
|
0xf0, 0x2e, 0x47, 0xa9, 0x08, 0x01, 0x4f, 0x6d, 0x39, 0xfa, 0xce, 0xc8, 0x19, 0x7f, 0x8b, 0x8a,
|
|
|
|
|
0x33, 0xf9, 0x07, 0xc0, 0x05, 0xe3, 0x28, 0x54, 0x86, 0xd2, 0x77, 0x47, 0xce, 0xb8, 0x33, 0x1d,
|
|
|
|
|
0x86, 0x86, 0x35, 0xac, 0x58, 0xc3, 0xcb, 0x82, 0x35, 0xb2, 0xa0, 0x94, 0x42, 0xd7, 0x70, 0x4b,
|
|
|
|
|
0xce, 0x36, 0x12, 0x35, 0xf9, 0x26, 0x5e, 0xd7, 0xe4, 0xfa, 0x4c, 0x6f, 0xa0, 0x77, 0x2c, 0x30,
|
|
|
|
|
0x56, 0x9f, 0xe3, 0x60, 0x04, 0xfd, 0x8a, 0xbd, 0xf4, 0xd0, 0x07, 0x37, 0x4b, 0x4b, 0x72, 0x37,
|
|
|
|
|
0x4b, 0xe9, 0x5f, 0xe8, 0x44, 0x18, 0xa7, 0x95, 0xfa, 0xce, 0x75, 0xed, 0xc6, 0x7d, 0x71, 0x43,
|
|
|
|
|
0xcf, 0xa0, 0x6b, 0x9e, 0x94, 0x94, 0x4d, 0x77, 0xce, 0xe1, 0xee, 0x1e, 0x1d, 0xe8, 0x5d, 0xf1,
|
|
|
|
|
0xd4, 0xfa, 0xf8, 0x03, 0xe4, 0xc9, 0x1f, 0xf0, 0xd8, 0x2a, 0x95, 0xfe, 0x97, 0xb7, 0x85, 0x0a,
|
|
|
|
|
0x90, 0x06, 0x6f, 0xf0, 0x41, 0xfa, 0xde, 0x3b, 0x60, 0x0d, 0xd2, 0x69, 0x55, 0x76, 0x5e, 0x49,
|
|
|
|
|
0x6b, 0x06, 0xbd, 0x13, 0x5c, 0xe1, 0x87, 0x0c, 0x4f, 0x9f, 0x5c, 0xf8, 0x1e, 0xa1, 0x64, 0xb9,
|
|
|
|
|
0x48, 0xf0, 0xa2, 0xdc, 0x60, 0x32, 0x07, 0x4f, 0xef, 0x06, 0xf9, 0x11, 0x96, 0x4b, 0x1c, 0x5a,
|
|
|
|
|
0x6b, 0x18, 0xfc, 0xdc, 0x99, 0x1a, 0x3b, 0xb4, 0x45, 0x8e, 0xa0, 0x6d, 0x0a, 0x25, 0x83, 0x1a,
|
|
|
|
|
0xd2, 0xd8, 0x9f, 0x60, 0xb8, 0x37, 0xaf, 0x1f, 0xcf, 0xc1, 0xd3, 0xc5, 0x59, 0x9a, 0x56, 0xf5,
|
|
|
|
|
0x96, 0xa6, 0xdd, 0xae, 0xd1, 0x34, 0xb1, 0x58, 0x9a, 0x8d, 0xda, 0x2c, 0xcd, 0x66, 0x7e, 0xb4,
|
|
|
|
|
0x45, 0xfe, 0x43, 0xdb, 0x24, 0x66, 0x3d, 0x6e, 0x44, 0x18, 0x0c, 0xf6, 0x4a, 0x39, 0xd5, 0x7f,
|
|
|
|
|
0x2f, 0x6d, 0x2d, 0xda, 0xc5, 0x64, 0xf6, 0x1c, 0x00, 0x00, 0xff, 0xff, 0xfa, 0x3e, 0xe9, 0xbd,
|
|
|
|
|
0xf8, 0x03, 0x00, 0x00,
|
2017-02-10 18:08:06 +01:00
|
|
|
}
|