maxmustermann/pulumi
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
pulumi/sdk/go/pkg/lumirpc/provider.pb.go

735 lines
27 KiB
Go
Raw Normal View History

Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
// Code generated by protoc-gen-go.
// source: provider.proto
// DO NOT EDIT!
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
package lumirpc
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
import google_protobuf1 "github.com/golang/protobuf/ptypes/empty"
import google_protobuf "github.com/golang/protobuf/ptypes/struct"
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
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
Add a pre-pass to validate resources before creating/updating This change adds a new Check RPC method on the provider interface, permitting resource providers to perform arbitrary verification on the values of properties. This is useful for validating things that might be difficult to express in the type system, and it runs before *any* modifications are run (so failures can be caight early before it's too late). My favorite motivating example is verifying that an AWS EC2 instance's AMI is available within the target region. This resolves pulumi/coconut#107, although we aren't using this in any resource providers just yet. I'll add a work item now for that...
2017-03-03 03:15:38 +01:00
type CheckRequest struct {
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
Type string `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
Properties *google_protobuf.Struct `protobuf:"bytes,2,opt,name=properties" json:"properties,omitempty"`
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
Unknowns map[string]bool `protobuf:"bytes,3,rep,name=unknowns" json:"unknowns,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
Add a pre-pass to validate resources before creating/updating This change adds a new Check RPC method on the provider interface, permitting resource providers to perform arbitrary verification on the values of properties. This is useful for validating things that might be difficult to express in the type system, and it runs before *any* modifications are run (so failures can be caight early before it's too late). My favorite motivating example is verifying that an AWS EC2 instance's AMI is available within the target region. This resolves pulumi/coconut#107, although we aren't using this in any resource providers just yet. I'll add a work item now for that...
2017-03-03 03:15:38 +01:00
}
func (m *CheckRequest) Reset() { *m = CheckRequest{} }
func (m *CheckRequest) String() string { return proto.CompactTextString(m) }
func (*CheckRequest) ProtoMessage() {}
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
func (*CheckRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
Add a pre-pass to validate resources before creating/updating This change adds a new Check RPC method on the provider interface, permitting resource providers to perform arbitrary verification on the values of properties. This is useful for validating things that might be difficult to express in the type system, and it runs before *any* modifications are run (so failures can be caight early before it's too late). My favorite motivating example is verifying that an AWS EC2 instance's AMI is available within the target region. This resolves pulumi/coconut#107, although we aren't using this in any resource providers just yet. I'll add a work item now for that...
2017-03-03 03:15:38 +01:00
func (m *CheckRequest) GetType() string {
if m != nil {
return m.Type
}
return ""
}
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
func (m *CheckRequest) GetProperties() *google_protobuf.Struct {
Add a pre-pass to validate resources before creating/updating This change adds a new Check RPC method on the provider interface, permitting resource providers to perform arbitrary verification on the values of properties. This is useful for validating things that might be difficult to express in the type system, and it runs before *any* modifications are run (so failures can be caight early before it's too late). My favorite motivating example is verifying that an AWS EC2 instance's AMI is available within the target region. This resolves pulumi/coconut#107, although we aren't using this in any resource providers just yet. I'll add a work item now for that...
2017-03-03 03:15:38 +01:00
if m != nil {
return m.Properties
}
return nil
}
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
func (m *CheckRequest) GetUnknowns() map[string]bool {
if m != nil {
return m.Unknowns
}
return nil
}
Add a pre-pass to validate resources before creating/updating This change adds a new Check RPC method on the provider interface, permitting resource providers to perform arbitrary verification on the values of properties. This is useful for validating things that might be difficult to express in the type system, and it runs before *any* modifications are run (so failures can be caight early before it's too late). My favorite motivating example is verifying that an AWS EC2 instance's AMI is available within the target region. This resolves pulumi/coconut#107, although we aren't using this in any resource providers just yet. I'll add a work item now for that...
2017-03-03 03:15:38 +01:00
type CheckResponse struct {
Failures []*CheckFailure `protobuf:"bytes,1,rep,name=failures" json:"failures,omitempty"`
}
func (m *CheckResponse) Reset() { *m = CheckResponse{} }
func (m *CheckResponse) String() string { return proto.CompactTextString(m) }
func (*CheckResponse) ProtoMessage() {}
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
func (*CheckResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
Add a pre-pass to validate resources before creating/updating This change adds a new Check RPC method on the provider interface, permitting resource providers to perform arbitrary verification on the values of properties. This is useful for validating things that might be difficult to express in the type system, and it runs before *any* modifications are run (so failures can be caight early before it's too late). My favorite motivating example is verifying that an AWS EC2 instance's AMI is available within the target region. This resolves pulumi/coconut#107, although we aren't using this in any resource providers just yet. I'll add a work item now for that...
2017-03-03 03:15:38 +01:00
func (m *CheckResponse) GetFailures() []*CheckFailure {
if m != nil {
return m.Failures
}
return nil
}
type CheckFailure struct {
Property string `protobuf:"bytes,1,opt,name=property" json:"property,omitempty"`
Reason string `protobuf:"bytes,2,opt,name=reason" json:"reason,omitempty"`
}
func (m *CheckFailure) Reset() { *m = CheckFailure{} }
func (m *CheckFailure) String() string { return proto.CompactTextString(m) }
func (*CheckFailure) ProtoMessage() {}
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
func (*CheckFailure) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} }
Add a pre-pass to validate resources before creating/updating This change adds a new Check RPC method on the provider interface, permitting resource providers to perform arbitrary verification on the values of properties. This is useful for validating things that might be difficult to express in the type system, and it runs before *any* modifications are run (so failures can be caight early before it's too late). My favorite motivating example is verifying that an AWS EC2 instance's AMI is available within the target region. This resolves pulumi/coconut#107, although we aren't using this in any resource providers just yet. I'll add a work item now for that...
2017-03-03 03:15:38 +01:00
func (m *CheckFailure) GetProperty() string {
if m != nil {
return m.Property
}
return ""
}
func (m *CheckFailure) GetReason() string {
if m != nil {
return m.Reason
}
return ""
}
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 {
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
Type string `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
Properties *google_protobuf.Struct `protobuf:"bytes,2,opt,name=properties" json:"properties,omitempty"`
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
Unknowns map[string]bool `protobuf:"bytes,3,rep,name=unknowns" json:"unknowns,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
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 (m *NameRequest) Reset() { *m = NameRequest{} }
func (m *NameRequest) String() string { return proto.CompactTextString(m) }
func (*NameRequest) ProtoMessage() {}
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
func (*NameRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} }
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 (m *NameRequest) GetType() string {
if m != nil {
return m.Type
}
return ""
}
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
func (m *NameRequest) GetProperties() *google_protobuf.Struct {
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 m != nil {
return m.Properties
}
return nil
}
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
func (m *NameRequest) GetUnknowns() map[string]bool {
if m != nil {
return m.Unknowns
}
return nil
}
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 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() {}
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
func (*NameResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{4} }
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 (m *NameResponse) GetName() string {
if m != nil {
return m.Name
}
return ""
}
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
type CreateRequest struct {
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
Type string `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
Properties *google_protobuf.Struct `protobuf:"bytes,2,opt,name=properties" json:"properties,omitempty"`
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
}
func (m *CreateRequest) Reset() { *m = CreateRequest{} }
func (m *CreateRequest) String() string { return proto.CompactTextString(m) }
func (*CreateRequest) ProtoMessage() {}
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
func (*CreateRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{5} }
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
func (m *CreateRequest) GetType() string {
if m != nil {
return m.Type
}
return ""
}
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
func (m *CreateRequest) GetProperties() *google_protobuf.Struct {
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
if m != nil {
return m.Properties
}
return nil
}
type CreateResponse struct {
Return state as part of Create and Update¬ As part of the bridge bringup, I've discoverd that the property state returned from Creates does *not* always equal the state that is then read from calls to Get. (I suspect this is a bug and that they should be equivalent, but I doubt it's fruitfal to try and track down all occurrences of this; I bet it's widespread). To cope with this, we will return state from Create and Update, instead of issuing a call to Get. This was a design we considered to start with and frankly didn't have a super strong reason to do it the current way, other than that it seemed elegant to place all of the Get logic in one place. Note that providers may choose to return nil, in which case we will read state from the provider in the usual Get style.
2017-07-18 03:44:45 +02:00
Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
Properties *google_protobuf.Struct `protobuf:"bytes,2,opt,name=properties" json:"properties,omitempty"`
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
}
func (m *CreateResponse) Reset() { *m = CreateResponse{} }
func (m *CreateResponse) String() string { return proto.CompactTextString(m) }
func (*CreateResponse) ProtoMessage() {}
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
func (*CreateResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{6} }
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
func (m *CreateResponse) GetId() string {
if m != nil {
return m.Id
}
return ""
}
Return state as part of Create and Update¬ As part of the bridge bringup, I've discoverd that the property state returned from Creates does *not* always equal the state that is then read from calls to Get. (I suspect this is a bug and that they should be equivalent, but I doubt it's fruitfal to try and track down all occurrences of this; I bet it's widespread). To cope with this, we will return state from Create and Update, instead of issuing a call to Get. This was a design we considered to start with and frankly didn't have a super strong reason to do it the current way, other than that it seemed elegant to place all of the Get logic in one place. Note that providers may choose to return nil, in which case we will read state from the provider in the usual Get style.
2017-07-18 03:44:45 +02:00
func (m *CreateResponse) GetProperties() *google_protobuf.Struct {
if m != nil {
return m.Properties
}
return nil
}
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
type GetRequest 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"`
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
}
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
func (m *GetRequest) Reset() { *m = GetRequest{} }
func (m *GetRequest) String() string { return proto.CompactTextString(m) }
func (*GetRequest) ProtoMessage() {}
func (*GetRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{7} }
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
func (m *GetRequest) GetId() string {
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
if m != nil {
return m.Id
}
return ""
}
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
func (m *GetRequest) GetType() string {
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
if m != nil {
return m.Type
}
return ""
}
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
type GetResponse struct {
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
Properties *google_protobuf.Struct `protobuf:"bytes,1,opt,name=properties" json:"properties,omitempty"`
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
}
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
func (m *GetResponse) Reset() { *m = GetResponse{} }
func (m *GetResponse) String() string { return proto.CompactTextString(m) }
func (*GetResponse) ProtoMessage() {}
func (*GetResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{8} }
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
func (m *GetResponse) GetProperties() *google_protobuf.Struct {
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
if m != nil {
return m.Properties
}
return nil
}
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
type InspectChangeRequest struct {
Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
Type string `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
Olds *google_protobuf.Struct `protobuf:"bytes,3,opt,name=olds" json:"olds,omitempty"`
News *google_protobuf.Struct `protobuf:"bytes,4,opt,name=news" json:"news,omitempty"`
Unknowns map[string]bool `protobuf:"bytes,5,rep,name=unknowns" json:"unknowns,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
}
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
func (m *InspectChangeRequest) Reset() { *m = InspectChangeRequest{} }
func (m *InspectChangeRequest) String() string { return proto.CompactTextString(m) }
func (*InspectChangeRequest) ProtoMessage() {}
func (*InspectChangeRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{9} }
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
func (m *InspectChangeRequest) GetId() string {
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
if m != nil {
return m.Id
}
return ""
}
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
func (m *InspectChangeRequest) GetType() string {
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
if m != nil {
return m.Type
}
return ""
}
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
func (m *InspectChangeRequest) GetOlds() *google_protobuf.Struct {
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
if m != nil {
Modify the ResourceProvider.Update API This changes two aspects of the ResourceProvider.Update RPC API: 1. Update needs to return an ID, in case the resource had to be recreated in response to the request. 2. Include both the old and the new values for properties that are being updated.
2017-02-11 22:14:29 +01:00
return m.Olds
}
return nil
}
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
func (m *InspectChangeRequest) GetNews() *google_protobuf.Struct {
Modify the ResourceProvider.Update API This changes two aspects of the ResourceProvider.Update RPC API: 1. Update needs to return an ID, in case the resource had to be recreated in response to the request. 2. Include both the old and the new values for properties that are being updated.
2017-02-11 22:14:29 +01:00
if m != nil {
return m.News
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
}
return nil
}
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
func (m *InspectChangeRequest) GetUnknowns() map[string]bool {
if m != nil {
return m.Unknowns
}
return nil
}
Rename PreviewUpdate (again) Unfortunately, this wasn't a great name. The old one stunk, but the new one was misleading at best. The thing is, this isn't about performing an update -- it's about NOT doing an update, depending on its return value. Further, it's not just previewing the changes, it is actively making a decision on what to do in response to them. InspectUpdate seems to convey this and I've unified the InspectUpdate and Update routines to take a ChangeRequest, instead of UpdateRequest, to help imply the desired behavior.
2017-04-27 20:18:49 +02:00
type InspectChangeResponse struct {
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
Replaces []string `protobuf:"bytes,1,rep,name=replaces" json:"replaces,omitempty"`
Changes *google_protobuf.Struct `protobuf:"bytes,2,opt,name=changes" json:"changes,omitempty"`
Support replacement IDs This change introduces a new RPC function to the provider interface; in pseudo-code: UpdateImpact(id ID, t Type, olds PropertyMap, news PropertyMap) (bool, PropertyMap, error) Essentially, during the planning phase, we will consult each provider about the nature of a proposed update. This update includes a set of old properties and the new ones and, if the resource provider will need to replace the property as a result of the update, it will return true; in general, the PropertyMap will eventually contain a list of all properties that will be modified as a result of the operation (see below). The planning phase reacts to this by propagating the change to dependent resources, so that they know that the ID will change (and so that they can recalculate their own state accordingly, possibly leading to a ripple effect). This ensures the overall DAG / schedule is ordered correctly. This change is most of pulumi/coconut#105. The only missing piece is to generalize replacing the "ID" property with replacing arbitrary properties; there are hooks in here for this, but until pulumi/coconut#90 is addressed, it doesn't make sense to make much progress on this.
2017-03-01 18:08:53 +01:00
}
Rename PreviewUpdate (again) Unfortunately, this wasn't a great name. The old one stunk, but the new one was misleading at best. The thing is, this isn't about performing an update -- it's about NOT doing an update, depending on its return value. Further, it's not just previewing the changes, it is actively making a decision on what to do in response to them. InspectUpdate seems to convey this and I've unified the InspectUpdate and Update routines to take a ChangeRequest, instead of UpdateRequest, to help imply the desired behavior.
2017-04-27 20:18:49 +02:00
func (m *InspectChangeResponse) Reset() { *m = InspectChangeResponse{} }
func (m *InspectChangeResponse) String() string { return proto.CompactTextString(m) }
func (*InspectChangeResponse) ProtoMessage() {}
func (*InspectChangeResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{10} }
Support replacement IDs This change introduces a new RPC function to the provider interface; in pseudo-code: UpdateImpact(id ID, t Type, olds PropertyMap, news PropertyMap) (bool, PropertyMap, error) Essentially, during the planning phase, we will consult each provider about the nature of a proposed update. This update includes a set of old properties and the new ones and, if the resource provider will need to replace the property as a result of the update, it will return true; in general, the PropertyMap will eventually contain a list of all properties that will be modified as a result of the operation (see below). The planning phase reacts to this by propagating the change to dependent resources, so that they know that the ID will change (and so that they can recalculate their own state accordingly, possibly leading to a ripple effect). This ensures the overall DAG / schedule is ordered correctly. This change is most of pulumi/coconut#105. The only missing piece is to generalize replacing the "ID" property with replacing arbitrary properties; there are hooks in here for this, but until pulumi/coconut#90 is addressed, it doesn't make sense to make much progress on this.
2017-03-01 18:08:53 +01:00
Rename PreviewUpdate (again) Unfortunately, this wasn't a great name. The old one stunk, but the new one was misleading at best. The thing is, this isn't about performing an update -- it's about NOT doing an update, depending on its return value. Further, it's not just previewing the changes, it is actively making a decision on what to do in response to them. InspectUpdate seems to convey this and I've unified the InspectUpdate and Update routines to take a ChangeRequest, instead of UpdateRequest, to help imply the desired behavior.
2017-04-27 20:18:49 +02:00
func (m *InspectChangeResponse) GetReplaces() []string {
Support replacement IDs This change introduces a new RPC function to the provider interface; in pseudo-code: UpdateImpact(id ID, t Type, olds PropertyMap, news PropertyMap) (bool, PropertyMap, error) Essentially, during the planning phase, we will consult each provider about the nature of a proposed update. This update includes a set of old properties and the new ones and, if the resource provider will need to replace the property as a result of the update, it will return true; in general, the PropertyMap will eventually contain a list of all properties that will be modified as a result of the operation (see below). The planning phase reacts to this by propagating the change to dependent resources, so that they know that the ID will change (and so that they can recalculate their own state accordingly, possibly leading to a ripple effect). This ensures the overall DAG / schedule is ordered correctly. This change is most of pulumi/coconut#105. The only missing piece is to generalize replacing the "ID" property with replacing arbitrary properties; there are hooks in here for this, but until pulumi/coconut#90 is addressed, it doesn't make sense to make much progress on this.
2017-03-01 18:08:53 +01:00
if m != nil {
Track which updates triggered a replacement This change tracks which updates triggered a replacement. This enables better output and diagnostics. For example, we now colorize those properties differently in the output. This makes it easier to diagnose why an unexpected resource might be getting deleted and recreated.
2017-03-03 00:24:39 +01:00
return m.Replaces
Support replacement IDs This change introduces a new RPC function to the provider interface; in pseudo-code: UpdateImpact(id ID, t Type, olds PropertyMap, news PropertyMap) (bool, PropertyMap, error) Essentially, during the planning phase, we will consult each provider about the nature of a proposed update. This update includes a set of old properties and the new ones and, if the resource provider will need to replace the property as a result of the update, it will return true; in general, the PropertyMap will eventually contain a list of all properties that will be modified as a result of the operation (see below). The planning phase reacts to this by propagating the change to dependent resources, so that they know that the ID will change (and so that they can recalculate their own state accordingly, possibly leading to a ripple effect). This ensures the overall DAG / schedule is ordered correctly. This change is most of pulumi/coconut#105. The only missing piece is to generalize replacing the "ID" property with replacing arbitrary properties; there are hooks in here for this, but until pulumi/coconut#90 is addressed, it doesn't make sense to make much progress on this.
2017-03-01 18:08:53 +01:00
}
Track which updates triggered a replacement This change tracks which updates triggered a replacement. This enables better output and diagnostics. For example, we now colorize those properties differently in the output. This makes it easier to diagnose why an unexpected resource might be getting deleted and recreated.
2017-03-03 00:24:39 +01:00
return nil
Support replacement IDs This change introduces a new RPC function to the provider interface; in pseudo-code: UpdateImpact(id ID, t Type, olds PropertyMap, news PropertyMap) (bool, PropertyMap, error) Essentially, during the planning phase, we will consult each provider about the nature of a proposed update. This update includes a set of old properties and the new ones and, if the resource provider will need to replace the property as a result of the update, it will return true; in general, the PropertyMap will eventually contain a list of all properties that will be modified as a result of the operation (see below). The planning phase reacts to this by propagating the change to dependent resources, so that they know that the ID will change (and so that they can recalculate their own state accordingly, possibly leading to a ripple effect). This ensures the overall DAG / schedule is ordered correctly. This change is most of pulumi/coconut#105. The only missing piece is to generalize replacing the "ID" property with replacing arbitrary properties; there are hooks in here for this, but until pulumi/coconut#90 is addressed, it doesn't make sense to make much progress on this.
2017-03-01 18:08:53 +01:00
}
Rename PreviewUpdate (again) Unfortunately, this wasn't a great name. The old one stunk, but the new one was misleading at best. The thing is, this isn't about performing an update -- it's about NOT doing an update, depending on its return value. Further, it's not just previewing the changes, it is actively making a decision on what to do in response to them. InspectUpdate seems to convey this and I've unified the InspectUpdate and Update routines to take a ChangeRequest, instead of UpdateRequest, to help imply the desired behavior.
2017-04-27 20:18:49 +02:00
func (m *InspectChangeResponse) GetChanges() *google_protobuf.Struct {
Support replacement IDs This change introduces a new RPC function to the provider interface; in pseudo-code: UpdateImpact(id ID, t Type, olds PropertyMap, news PropertyMap) (bool, PropertyMap, error) Essentially, during the planning phase, we will consult each provider about the nature of a proposed update. This update includes a set of old properties and the new ones and, if the resource provider will need to replace the property as a result of the update, it will return true; in general, the PropertyMap will eventually contain a list of all properties that will be modified as a result of the operation (see below). The planning phase reacts to this by propagating the change to dependent resources, so that they know that the ID will change (and so that they can recalculate their own state accordingly, possibly leading to a ripple effect). This ensures the overall DAG / schedule is ordered correctly. This change is most of pulumi/coconut#105. The only missing piece is to generalize replacing the "ID" property with replacing arbitrary properties; there are hooks in here for this, but until pulumi/coconut#90 is addressed, it doesn't make sense to make much progress on this.
2017-03-01 18:08:53 +01:00
if m != nil {
Track which updates triggered a replacement This change tracks which updates triggered a replacement. This enables better output and diagnostics. For example, we now colorize those properties differently in the output. This makes it easier to diagnose why an unexpected resource might be getting deleted and recreated.
2017-03-03 00:24:39 +01:00
return m.Changes
Support replacement IDs This change introduces a new RPC function to the provider interface; in pseudo-code: UpdateImpact(id ID, t Type, olds PropertyMap, news PropertyMap) (bool, PropertyMap, error) Essentially, during the planning phase, we will consult each provider about the nature of a proposed update. This update includes a set of old properties and the new ones and, if the resource provider will need to replace the property as a result of the update, it will return true; in general, the PropertyMap will eventually contain a list of all properties that will be modified as a result of the operation (see below). The planning phase reacts to this by propagating the change to dependent resources, so that they know that the ID will change (and so that they can recalculate their own state accordingly, possibly leading to a ripple effect). This ensures the overall DAG / schedule is ordered correctly. This change is most of pulumi/coconut#105. The only missing piece is to generalize replacing the "ID" property with replacing arbitrary properties; there are hooks in here for this, but until pulumi/coconut#90 is addressed, it doesn't make sense to make much progress on this.
2017-03-01 18:08:53 +01:00
}
return nil
}
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
type UpdateRequest struct {
Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
Type string `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
Olds *google_protobuf.Struct `protobuf:"bytes,3,opt,name=olds" json:"olds,omitempty"`
News *google_protobuf.Struct `protobuf:"bytes,4,opt,name=news" json:"news,omitempty"`
}
func (m *UpdateRequest) Reset() { *m = UpdateRequest{} }
func (m *UpdateRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateRequest) ProtoMessage() {}
func (*UpdateRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{11} }
func (m *UpdateRequest) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *UpdateRequest) GetType() string {
if m != nil {
return m.Type
}
return ""
}
func (m *UpdateRequest) GetOlds() *google_protobuf.Struct {
if m != nil {
return m.Olds
}
return nil
}
func (m *UpdateRequest) GetNews() *google_protobuf.Struct {
if m != nil {
return m.News
}
return nil
}
Return state as part of Create and Update¬ As part of the bridge bringup, I've discoverd that the property state returned from Creates does *not* always equal the state that is then read from calls to Get. (I suspect this is a bug and that they should be equivalent, but I doubt it's fruitfal to try and track down all occurrences of this; I bet it's widespread). To cope with this, we will return state from Create and Update, instead of issuing a call to Get. This was a design we considered to start with and frankly didn't have a super strong reason to do it the current way, other than that it seemed elegant to place all of the Get logic in one place. Note that providers may choose to return nil, in which case we will read state from the provider in the usual Get style.
2017-07-18 03:44:45 +02:00
type UpdateResponse struct {
Properties *google_protobuf.Struct `protobuf:"bytes,1,opt,name=properties" json:"properties,omitempty"`
}
func (m *UpdateResponse) Reset() { *m = UpdateResponse{} }
func (m *UpdateResponse) String() string { return proto.CompactTextString(m) }
func (*UpdateResponse) ProtoMessage() {}
func (*UpdateResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{12} }
func (m *UpdateResponse) GetProperties() *google_protobuf.Struct {
if m != nil {
return m.Properties
}
return nil
}
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
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"`
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
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() {}
Return state as part of Create and Update¬ As part of the bridge bringup, I've discoverd that the property state returned from Creates does *not* always equal the state that is then read from calls to Get. (I suspect this is a bug and that they should be equivalent, but I doubt it's fruitfal to try and track down all occurrences of this; I bet it's widespread). To cope with this, we will return state from Create and Update, instead of issuing a call to Get. This was a design we considered to start with and frankly didn't have a super strong reason to do it the current way, other than that it seemed elegant to place all of the Get logic in one place. Note that providers may choose to return nil, in which case we will read state from the provider in the usual Get style.
2017-07-18 03:44:45 +02:00
func (*DeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{13} }
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
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 ""
}
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
func init() {
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
proto.RegisterType((*CheckRequest)(nil), "lumirpc.CheckRequest")
proto.RegisterType((*CheckResponse)(nil), "lumirpc.CheckResponse")
proto.RegisterType((*CheckFailure)(nil), "lumirpc.CheckFailure")
proto.RegisterType((*NameRequest)(nil), "lumirpc.NameRequest")
proto.RegisterType((*NameResponse)(nil), "lumirpc.NameResponse")
proto.RegisterType((*CreateRequest)(nil), "lumirpc.CreateRequest")
proto.RegisterType((*CreateResponse)(nil), "lumirpc.CreateResponse")
proto.RegisterType((*GetRequest)(nil), "lumirpc.GetRequest")
proto.RegisterType((*GetResponse)(nil), "lumirpc.GetResponse")
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
proto.RegisterType((*InspectChangeRequest)(nil), "lumirpc.InspectChangeRequest")
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
proto.RegisterType((*InspectChangeResponse)(nil), "lumirpc.InspectChangeResponse")
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
proto.RegisterType((*UpdateRequest)(nil), "lumirpc.UpdateRequest")
Return state as part of Create and Update¬ As part of the bridge bringup, I've discoverd that the property state returned from Creates does *not* always equal the state that is then read from calls to Get. (I suspect this is a bug and that they should be equivalent, but I doubt it's fruitfal to try and track down all occurrences of this; I bet it's widespread). To cope with this, we will return state from Create and Update, instead of issuing a call to Get. This was a design we considered to start with and frankly didn't have a super strong reason to do it the current way, other than that it seemed elegant to place all of the Get logic in one place. Note that providers may choose to return nil, in which case we will read state from the provider in the usual Get style.
2017-07-18 03:44:45 +02:00
proto.RegisterType((*UpdateResponse)(nil), "lumirpc.UpdateResponse")
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
proto.RegisterType((*DeleteRequest)(nil), "lumirpc.DeleteRequest")
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
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 {
Add a pre-pass to validate resources before creating/updating This change adds a new Check RPC method on the provider interface, permitting resource providers to perform arbitrary verification on the values of properties. This is useful for validating things that might be difficult to express in the type system, and it runs before *any* modifications are run (so failures can be caight early before it's too late). My favorite motivating example is verifying that an AWS EC2 instance's AMI is available within the target region. This resolves pulumi/coconut#107, although we aren't using this in any resource providers just yet. I'll add a work item now for that...
2017-03-03 03:15:38 +01:00
// Check validates that the given property bag is valid for a resource of the given type.
Check(ctx context.Context, in *CheckRequest, opts ...grpc.CallOption) (*CheckResponse, error)
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)
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
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)
Make more progress on the new deployment model This change restructures a lot more pertaining to deployments, snapshots, environments, and the like. The most notable change is that the notion of a deploy.Source is introduced, which splits the responsibility between the deploy.Plan -- which simply understands how to compute and carry out deployment plans -- and the idea of something that can produce new objects on-demand during deployment. The primary such implementation is evalSource, which encapsulates an interpreter and takes a package, args, and config map, and proceeds to run the interpreter in a distinct goroutine. It synchronizes as needed to poke and prod the interpreter along its path to create new resource objects. There are two other sources, however. First, a nullSource, which simply refuses to create new objects. This can be handy when writing isolated tests but is also used to simulate the "empty" environment as necessary to do a complete teardown of the target environment. Second, a fixedSource, which takes a pre-computed array of objects, and hands those, in order, to the planning engine; this is mostly useful as a testing technique. Boatloads of code is now changed and updated in the various CLI commands. This further chugs along towards pulumi/lumi#90. The end is in sight.
2017-06-10 20:50:47 +02:00
// Get reads the instance state identified by ID, returning a populated resource object, or nil if not found.
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error)
Rename PreviewUpdate (again) Unfortunately, this wasn't a great name. The old one stunk, but the new one was misleading at best. The thing is, this isn't about performing an update -- it's about NOT doing an update, depending on its return value. Further, it's not just previewing the changes, it is actively making a decision on what to do in response to them. InspectUpdate seems to convey this and I've unified the InspectUpdate and Update routines to take a ChangeRequest, instead of UpdateRequest, to help imply the desired behavior.
2017-04-27 20:18:49 +02:00
// InspectChange checks what impacts a hypothetical update will have on the resource's properties.
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
InspectChange(ctx context.Context, in *InspectChangeRequest, opts ...grpc.CallOption) (*InspectChangeResponse, error)
Make replacement first class This change, part of pulumi/coconut#105, rearranges support for resource replacement. The old model didn't properly account for the cascading updates and possible replacement of dependencies. Namely, we need to model a replacement as a creation followed by a deletion, inserted into the overall DAG correctly so that any resources that must be updated are updated after the creation but prior to the deletion. This is done by inserting *three* nodes into the graph per replacement: a physical creation step, a physical deletion step, and a logical replacement step. The logical step simply makes it nicer in the output (the plan output shows a single "replacement" rather than the fine-grained outputs, unless they are requested with --show-replace-steps). It also makes it easier to fold all of the edges into a single linchpin node. As part of this, the update step no longer gets to choose whether to recreate the resource. Instead, the engine takes care of orchestrating the replacement through actual create and delete calls.
2017-03-02 18:52:08 +01:00
// Update updates an existing resource with new values.
Return state as part of Create and Update¬ As part of the bridge bringup, I've discoverd that the property state returned from Creates does *not* always equal the state that is then read from calls to Get. (I suspect this is a bug and that they should be equivalent, but I doubt it's fruitfal to try and track down all occurrences of this; I bet it's widespread). To cope with this, we will return state from Create and Update, instead of issuing a call to Get. This was a design we considered to start with and frankly didn't have a super strong reason to do it the current way, other than that it seemed elegant to place all of the Get logic in one place. Note that providers may choose to return nil, in which case we will read state from the provider in the usual Get style.
2017-07-18 03:44:45 +02:00
Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error)
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
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.
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error)
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
}
type resourceProviderClient struct {
cc *grpc.ClientConn
}
func NewResourceProviderClient(cc *grpc.ClientConn) ResourceProviderClient {
return &resourceProviderClient{cc}
}
Add a pre-pass to validate resources before creating/updating This change adds a new Check RPC method on the provider interface, permitting resource providers to perform arbitrary verification on the values of properties. This is useful for validating things that might be difficult to express in the type system, and it runs before *any* modifications are run (so failures can be caight early before it's too late). My favorite motivating example is verifying that an AWS EC2 instance's AMI is available within the target region. This resolves pulumi/coconut#107, although we aren't using this in any resource providers just yet. I'll add a work item now for that...
2017-03-03 03:15:38 +01:00
func (c *resourceProviderClient) Check(ctx context.Context, in *CheckRequest, opts ...grpc.CallOption) (*CheckResponse, error) {
out := new(CheckResponse)
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
err := grpc.Invoke(ctx, "/lumirpc.ResourceProvider/Check", in, out, c.cc, opts...)
Add a pre-pass to validate resources before creating/updating This change adds a new Check RPC method on the provider interface, permitting resource providers to perform arbitrary verification on the values of properties. This is useful for validating things that might be difficult to express in the type system, and it runs before *any* modifications are run (so failures can be caight early before it's too late). My favorite motivating example is verifying that an AWS EC2 instance's AMI is available within the target region. This resolves pulumi/coconut#107, although we aren't using this in any resource providers just yet. I'll add a work item now for that...
2017-03-03 03:15:38 +01:00
if err != nil {
return nil, err
}
return out, nil
}
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)
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
err := grpc.Invoke(ctx, "/lumirpc.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
}
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
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)
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
err := grpc.Invoke(ctx, "/lumirpc.ResourceProvider/Create", in, out, c.cc, opts...)
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
if err != nil {
return nil, err
}
return out, nil
}
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
func (c *resourceProviderClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) {
out := new(GetResponse)
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
err := grpc.Invoke(ctx, "/lumirpc.ResourceProvider/Get", in, out, c.cc, opts...)
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
if err != nil {
return nil, err
}
return out, nil
}
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
func (c *resourceProviderClient) InspectChange(ctx context.Context, in *InspectChangeRequest, opts ...grpc.CallOption) (*InspectChangeResponse, error) {
Rename PreviewUpdate (again) Unfortunately, this wasn't a great name. The old one stunk, but the new one was misleading at best. The thing is, this isn't about performing an update -- it's about NOT doing an update, depending on its return value. Further, it's not just previewing the changes, it is actively making a decision on what to do in response to them. InspectUpdate seems to convey this and I've unified the InspectUpdate and Update routines to take a ChangeRequest, instead of UpdateRequest, to help imply the desired behavior.
2017-04-27 20:18:49 +02:00
out := new(InspectChangeResponse)
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
err := grpc.Invoke(ctx, "/lumirpc.ResourceProvider/InspectChange", in, out, c.cc, opts...)
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
if err != nil {
return nil, err
}
return out, nil
}
Return state as part of Create and Update¬ As part of the bridge bringup, I've discoverd that the property state returned from Creates does *not* always equal the state that is then read from calls to Get. (I suspect this is a bug and that they should be equivalent, but I doubt it's fruitfal to try and track down all occurrences of this; I bet it's widespread). To cope with this, we will return state from Create and Update, instead of issuing a call to Get. This was a design we considered to start with and frankly didn't have a super strong reason to do it the current way, other than that it seemed elegant to place all of the Get logic in one place. Note that providers may choose to return nil, in which case we will read state from the provider in the usual Get style.
2017-07-18 03:44:45 +02:00
func (c *resourceProviderClient) Update(ctx context.Context, in *UpdateRequest, opts ...grpc.CallOption) (*UpdateResponse, error) {
out := new(UpdateResponse)
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
err := grpc.Invoke(ctx, "/lumirpc.ResourceProvider/Update", in, out, c.cc, opts...)
Support replacement IDs This change introduces a new RPC function to the provider interface; in pseudo-code: UpdateImpact(id ID, t Type, olds PropertyMap, news PropertyMap) (bool, PropertyMap, error) Essentially, during the planning phase, we will consult each provider about the nature of a proposed update. This update includes a set of old properties and the new ones and, if the resource provider will need to replace the property as a result of the update, it will return true; in general, the PropertyMap will eventually contain a list of all properties that will be modified as a result of the operation (see below). The planning phase reacts to this by propagating the change to dependent resources, so that they know that the ID will change (and so that they can recalculate their own state accordingly, possibly leading to a ripple effect). This ensures the overall DAG / schedule is ordered correctly. This change is most of pulumi/coconut#105. The only missing piece is to generalize replacing the "ID" property with replacing arbitrary properties; there are hooks in here for this, but until pulumi/coconut#90 is addressed, it doesn't make sense to make much progress on this.
2017-03-01 18:08:53 +01:00
if err != nil {
return nil, err
}
return out, nil
}
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
func (c *resourceProviderClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*google_protobuf1.Empty, error) {
out := new(google_protobuf1.Empty)
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
err := grpc.Invoke(ctx, "/lumirpc.ResourceProvider/Delete", in, out, c.cc, opts...)
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
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 {
Add a pre-pass to validate resources before creating/updating This change adds a new Check RPC method on the provider interface, permitting resource providers to perform arbitrary verification on the values of properties. This is useful for validating things that might be difficult to express in the type system, and it runs before *any* modifications are run (so failures can be caight early before it's too late). My favorite motivating example is verifying that an AWS EC2 instance's AMI is available within the target region. This resolves pulumi/coconut#107, although we aren't using this in any resource providers just yet. I'll add a work item now for that...
2017-03-03 03:15:38 +01:00
// Check validates that the given property bag is valid for a resource of the given type.
Check(context.Context, *CheckRequest) (*CheckResponse, error)
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)
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
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)
Make more progress on the new deployment model This change restructures a lot more pertaining to deployments, snapshots, environments, and the like. The most notable change is that the notion of a deploy.Source is introduced, which splits the responsibility between the deploy.Plan -- which simply understands how to compute and carry out deployment plans -- and the idea of something that can produce new objects on-demand during deployment. The primary such implementation is evalSource, which encapsulates an interpreter and takes a package, args, and config map, and proceeds to run the interpreter in a distinct goroutine. It synchronizes as needed to poke and prod the interpreter along its path to create new resource objects. There are two other sources, however. First, a nullSource, which simply refuses to create new objects. This can be handy when writing isolated tests but is also used to simulate the "empty" environment as necessary to do a complete teardown of the target environment. Second, a fixedSource, which takes a pre-computed array of objects, and hands those, in order, to the planning engine; this is mostly useful as a testing technique. Boatloads of code is now changed and updated in the various CLI commands. This further chugs along towards pulumi/lumi#90. The end is in sight.
2017-06-10 20:50:47 +02:00
// Get reads the instance state identified by ID, returning a populated resource object, or nil if not found.
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
Get(context.Context, *GetRequest) (*GetResponse, error)
Rename PreviewUpdate (again) Unfortunately, this wasn't a great name. The old one stunk, but the new one was misleading at best. The thing is, this isn't about performing an update -- it's about NOT doing an update, depending on its return value. Further, it's not just previewing the changes, it is actively making a decision on what to do in response to them. InspectUpdate seems to convey this and I've unified the InspectUpdate and Update routines to take a ChangeRequest, instead of UpdateRequest, to help imply the desired behavior.
2017-04-27 20:18:49 +02:00
// InspectChange checks what impacts a hypothetical update will have on the resource's properties.
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
InspectChange(context.Context, *InspectChangeRequest) (*InspectChangeResponse, error)
Make replacement first class This change, part of pulumi/coconut#105, rearranges support for resource replacement. The old model didn't properly account for the cascading updates and possible replacement of dependencies. Namely, we need to model a replacement as a creation followed by a deletion, inserted into the overall DAG correctly so that any resources that must be updated are updated after the creation but prior to the deletion. This is done by inserting *three* nodes into the graph per replacement: a physical creation step, a physical deletion step, and a logical replacement step. The logical step simply makes it nicer in the output (the plan output shows a single "replacement" rather than the fine-grained outputs, unless they are requested with --show-replace-steps). It also makes it easier to fold all of the edges into a single linchpin node. As part of this, the update step no longer gets to choose whether to recreate the resource. Instead, the engine takes care of orchestrating the replacement through actual create and delete calls.
2017-03-02 18:52:08 +01:00
// Update updates an existing resource with new values.
Return state as part of Create and Update¬ As part of the bridge bringup, I've discoverd that the property state returned from Creates does *not* always equal the state that is then read from calls to Get. (I suspect this is a bug and that they should be equivalent, but I doubt it's fruitfal to try and track down all occurrences of this; I bet it's widespread). To cope with this, we will return state from Create and Update, instead of issuing a call to Get. This was a design we considered to start with and frankly didn't have a super strong reason to do it the current way, other than that it seemed elegant to place all of the Get logic in one place. Note that providers may choose to return nil, in which case we will read state from the provider in the usual Get style.
2017-07-18 03:44:45 +02:00
Update(context.Context, *UpdateRequest) (*UpdateResponse, error)
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
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.
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
Delete(context.Context, *DeleteRequest) (*google_protobuf1.Empty, error)
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
}
func RegisterResourceProviderServer(s *grpc.Server, srv ResourceProviderServer) {
s.RegisterService(&_ResourceProvider_serviceDesc, srv)
}
Add a pre-pass to validate resources before creating/updating This change adds a new Check RPC method on the provider interface, permitting resource providers to perform arbitrary verification on the values of properties. This is useful for validating things that might be difficult to express in the type system, and it runs before *any* modifications are run (so failures can be caight early before it's too late). My favorite motivating example is verifying that an AWS EC2 instance's AMI is available within the target region. This resolves pulumi/coconut#107, although we aren't using this in any resource providers just yet. I'll add a work item now for that...
2017-03-03 03:15:38 +01:00
func _ResourceProvider_Check_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CheckRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ResourceProviderServer).Check(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
FullMethod: "/lumirpc.ResourceProvider/Check",
Add a pre-pass to validate resources before creating/updating This change adds a new Check RPC method on the provider interface, permitting resource providers to perform arbitrary verification on the values of properties. This is useful for validating things that might be difficult to express in the type system, and it runs before *any* modifications are run (so failures can be caight early before it's too late). My favorite motivating example is verifying that an AWS EC2 instance's AMI is available within the target region. This resolves pulumi/coconut#107, although we aren't using this in any resource providers just yet. I'll add a work item now for that...
2017-03-03 03:15:38 +01:00
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ResourceProviderServer).Check(ctx, req.(*CheckRequest))
}
return interceptor(ctx, in, info, handler)
}
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,
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
FullMethod: "/lumirpc.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)
}
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
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,
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
FullMethod: "/lumirpc.ResourceProvider/Create",
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
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)
}
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
func _ResourceProvider_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetRequest)
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
return srv.(ResourceProviderServer).Get(ctx, in)
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
}
info := &grpc.UnaryServerInfo{
Server: srv,
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
FullMethod: "/lumirpc.ResourceProvider/Get",
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
return srv.(ResourceProviderServer).Get(ctx, req.(*GetRequest))
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
}
return interceptor(ctx, in, info, handler)
}
Rename PreviewUpdate (again) Unfortunately, this wasn't a great name. The old one stunk, but the new one was misleading at best. The thing is, this isn't about performing an update -- it's about NOT doing an update, depending on its return value. Further, it's not just previewing the changes, it is actively making a decision on what to do in response to them. InspectUpdate seems to convey this and I've unified the InspectUpdate and Update routines to take a ChangeRequest, instead of UpdateRequest, to help imply the desired behavior.
2017-04-27 20:18:49 +02:00
func _ResourceProvider_InspectChange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
in := new(InspectChangeRequest)
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
Rename PreviewUpdate (again) Unfortunately, this wasn't a great name. The old one stunk, but the new one was misleading at best. The thing is, this isn't about performing an update -- it's about NOT doing an update, depending on its return value. Further, it's not just previewing the changes, it is actively making a decision on what to do in response to them. InspectUpdate seems to convey this and I've unified the InspectUpdate and Update routines to take a ChangeRequest, instead of UpdateRequest, to help imply the desired behavior.
2017-04-27 20:18:49 +02:00
return srv.(ResourceProviderServer).InspectChange(ctx, in)
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
}
info := &grpc.UnaryServerInfo{
Server: srv,
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
FullMethod: "/lumirpc.ResourceProvider/InspectChange",
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
return srv.(ResourceProviderServer).InspectChange(ctx, req.(*InspectChangeRequest))
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
}
return interceptor(ctx, in, info, handler)
}
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
func _ResourceProvider_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
in := new(UpdateRequest)
Support replacement IDs This change introduces a new RPC function to the provider interface; in pseudo-code: UpdateImpact(id ID, t Type, olds PropertyMap, news PropertyMap) (bool, PropertyMap, error) Essentially, during the planning phase, we will consult each provider about the nature of a proposed update. This update includes a set of old properties and the new ones and, if the resource provider will need to replace the property as a result of the update, it will return true; in general, the PropertyMap will eventually contain a list of all properties that will be modified as a result of the operation (see below). The planning phase reacts to this by propagating the change to dependent resources, so that they know that the ID will change (and so that they can recalculate their own state accordingly, possibly leading to a ripple effect). This ensures the overall DAG / schedule is ordered correctly. This change is most of pulumi/coconut#105. The only missing piece is to generalize replacing the "ID" property with replacing arbitrary properties; there are hooks in here for this, but until pulumi/coconut#90 is addressed, it doesn't make sense to make much progress on this.
2017-03-01 18:08:53 +01:00
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
return srv.(ResourceProviderServer).Update(ctx, in)
Support replacement IDs This change introduces a new RPC function to the provider interface; in pseudo-code: UpdateImpact(id ID, t Type, olds PropertyMap, news PropertyMap) (bool, PropertyMap, error) Essentially, during the planning phase, we will consult each provider about the nature of a proposed update. This update includes a set of old properties and the new ones and, if the resource provider will need to replace the property as a result of the update, it will return true; in general, the PropertyMap will eventually contain a list of all properties that will be modified as a result of the operation (see below). The planning phase reacts to this by propagating the change to dependent resources, so that they know that the ID will change (and so that they can recalculate their own state accordingly, possibly leading to a ripple effect). This ensures the overall DAG / schedule is ordered correctly. This change is most of pulumi/coconut#105. The only missing piece is to generalize replacing the "ID" property with replacing arbitrary properties; there are hooks in here for this, but until pulumi/coconut#90 is addressed, it doesn't make sense to make much progress on this.
2017-03-01 18:08:53 +01:00
}
info := &grpc.UnaryServerInfo{
Server: srv,
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
FullMethod: "/lumirpc.ResourceProvider/Update",
Support replacement IDs This change introduces a new RPC function to the provider interface; in pseudo-code: UpdateImpact(id ID, t Type, olds PropertyMap, news PropertyMap) (bool, PropertyMap, error) Essentially, during the planning phase, we will consult each provider about the nature of a proposed update. This update includes a set of old properties and the new ones and, if the resource provider will need to replace the property as a result of the update, it will return true; in general, the PropertyMap will eventually contain a list of all properties that will be modified as a result of the operation (see below). The planning phase reacts to this by propagating the change to dependent resources, so that they know that the ID will change (and so that they can recalculate their own state accordingly, possibly leading to a ripple effect). This ensures the overall DAG / schedule is ordered correctly. This change is most of pulumi/coconut#105. The only missing piece is to generalize replacing the "ID" property with replacing arbitrary properties; there are hooks in here for this, but until pulumi/coconut#90 is addressed, it doesn't make sense to make much progress on this.
2017-03-01 18:08:53 +01:00
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
Initial support for output properties (1 of 3) This change includes approximately 1/3rd of the change necessary to support output properties, as per pulumi/lumi#90. In short, the runtime now has a new hidden type, Latent<T>, which represents a "speculative" value, whose eventual type will be T, that we can use during evaluation in various ways. Namely, operations against Latent<T>s generally produce new Latent<U>s. During planning, any Latent<T>s that end up in resource properties are transformed into "unknown" property values. An unknown property value is legal only during planning-time activities, such as Check, Name, and InspectChange. As a result, those RPC interfaces have been updated to include lookaside maps indicating which properties have unknown values. My intent is to add some helper functions to make dealing with this circumstance more correct-by-construction. For now, using an unresolved Latent<T> in a conditional will lead to an error. See pulumi/lumi#67. Speculating beyond these -- by supporting iterative planning and application -- is something we want to support eventually, but it makes sense to do that as an additive change beyond this initial support. That is a missing 1/3. Finally, the other missing 1/3rd which will happen much sooner than the rest is restructuing plan application so that it will correctly observe resolution of Latent<T> values. Right now, the evaluation happens in one single pass, prior to the application, and so Latent<T>s never actually get witnessed in a resolved state.
2017-05-24 02:32:59 +02:00
return srv.(ResourceProviderServer).Update(ctx, req.(*UpdateRequest))
Support replacement IDs This change introduces a new RPC function to the provider interface; in pseudo-code: UpdateImpact(id ID, t Type, olds PropertyMap, news PropertyMap) (bool, PropertyMap, error) Essentially, during the planning phase, we will consult each provider about the nature of a proposed update. This update includes a set of old properties and the new ones and, if the resource provider will need to replace the property as a result of the update, it will return true; in general, the PropertyMap will eventually contain a list of all properties that will be modified as a result of the operation (see below). The planning phase reacts to this by propagating the change to dependent resources, so that they know that the ID will change (and so that they can recalculate their own state accordingly, possibly leading to a ripple effect). This ensures the overall DAG / schedule is ordered correctly. This change is most of pulumi/coconut#105. The only missing piece is to generalize replacing the "ID" property with replacing arbitrary properties; there are hooks in here for this, but until pulumi/coconut#90 is addressed, it doesn't make sense to make much progress on this.
2017-03-01 18:08:53 +01:00
}
return interceptor(ctx, in, info, handler)
}
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
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,
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
FullMethod: "/lumirpc.ResourceProvider/Delete",
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
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{
Rename Coconut to Lumi This is part of pulumi/coconut#147. After it has landed, I will rename the repo on GitHub.
2017-05-18 20:38:28 +02:00
ServiceName: "lumirpc.ResourceProvider",
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
HandlerType: (*ResourceProviderServer)(nil),
Methods: []grpc.MethodDesc{
Add a pre-pass to validate resources before creating/updating This change adds a new Check RPC method on the provider interface, permitting resource providers to perform arbitrary verification on the values of properties. This is useful for validating things that might be difficult to express in the type system, and it runs before *any* modifications are run (so failures can be caight early before it's too late). My favorite motivating example is verifying that an AWS EC2 instance's AMI is available within the target region. This resolves pulumi/coconut#107, although we aren't using this in any resource providers just yet. I'll add a work item now for that...
2017-03-03 03:15:38 +01:00
{
MethodName: "Check",
Handler: _ResourceProvider_Check_Handler,
},
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,
},
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
{
MethodName: "Create",
Handler: _ResourceProvider_Create_Handler,
},
{
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
MethodName: "Get",
Handler: _ResourceProvider_Get_Handler,
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
},
{
Rename PreviewUpdate (again) Unfortunately, this wasn't a great name. The old one stunk, but the new one was misleading at best. The thing is, this isn't about performing an update -- it's about NOT doing an update, depending on its return value. Further, it's not just previewing the changes, it is actively making a decision on what to do in response to them. InspectUpdate seems to convey this and I've unified the InspectUpdate and Update routines to take a ChangeRequest, instead of UpdateRequest, to help imply the desired behavior.
2017-04-27 20:18:49 +02:00
MethodName: "InspectChange",
Handler: _ResourceProvider_InspectChange_Handler,
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
},
Support replacement IDs This change introduces a new RPC function to the provider interface; in pseudo-code: UpdateImpact(id ID, t Type, olds PropertyMap, news PropertyMap) (bool, PropertyMap, error) Essentially, during the planning phase, we will consult each provider about the nature of a proposed update. This update includes a set of old properties and the new ones and, if the resource provider will need to replace the property as a result of the update, it will return true; in general, the PropertyMap will eventually contain a list of all properties that will be modified as a result of the operation (see below). The planning phase reacts to this by propagating the change to dependent resources, so that they know that the ID will change (and so that they can recalculate their own state accordingly, possibly leading to a ripple effect). This ensures the overall DAG / schedule is ordered correctly. This change is most of pulumi/coconut#105. The only missing piece is to generalize replacing the "ID" property with replacing arbitrary properties; there are hooks in here for this, but until pulumi/coconut#90 is addressed, it doesn't make sense to make much progress on this.
2017-03-01 18:08:53 +01:00
{
Rename resource provider methods This change renames two provider methods: * Read becomes Get. * UpdateImpact becomes PreviewUpdate. These just read a whole lot nicer than the old names.
2017-04-20 23:09:00 +02:00
MethodName: "Update",
Handler: _ResourceProvider_Update_Handler,
Support replacement IDs This change introduces a new RPC function to the provider interface; in pseudo-code: UpdateImpact(id ID, t Type, olds PropertyMap, news PropertyMap) (bool, PropertyMap, error) Essentially, during the planning phase, we will consult each provider about the nature of a proposed update. This update includes a set of old properties and the new ones and, if the resource provider will need to replace the property as a result of the update, it will return true; in general, the PropertyMap will eventually contain a list of all properties that will be modified as a result of the operation (see below). The planning phase reacts to this by propagating the change to dependent resources, so that they know that the ID will change (and so that they can recalculate their own state accordingly, possibly leading to a ripple effect). This ensures the overall DAG / schedule is ordered correctly. This change is most of pulumi/coconut#105. The only missing piece is to generalize replacing the "ID" property with replacing arbitrary properties; there are hooks in here for this, but until pulumi/coconut#90 is addressed, it doesn't make sense to make much progress on this.
2017-03-01 18:08:53 +01:00
},
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
{
MethodName: "Delete",
Handler: _ResourceProvider_Delete_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "provider.proto",
}
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
func init() { proto.RegisterFile("provider.proto", fileDescriptor2) }
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
Add basic analyzer support This change introduces the basic requirements for analyzers, as per pulumi/coconut#119. In particular, an analyzer can implement either, or both, of the RPC methods, Analyze and AnalyzeResource. The former is meant to check an overall deployment (e.g., to ensure it has been signed off on) and the latter is to check individual resources (e.g., to ensure properties of them are correct, such as checking style, security, etc. rules). These run simultaneous to overall checking. Analyzers are loaded as plugins just like providers are. The difference is mainly in their naming ("analyzer-" prefix, rather than "resource-"), and the RPC methods that they support. This isn't 100% functional since we need a way to specify at the CLI that a particular analyzer should be run, in addition to a way of recording which analyzers certain projects should use in their manifests.
2017-03-11 08:49:17 +01:00
var fileDescriptor2 = []byte{
Return state as part of Create and Update¬ As part of the bridge bringup, I've discoverd that the property state returned from Creates does *not* always equal the state that is then read from calls to Get. (I suspect this is a bug and that they should be equivalent, but I doubt it's fruitfal to try and track down all occurrences of this; I bet it's widespread). To cope with this, we will return state from Create and Update, instead of issuing a call to Get. This was a design we considered to start with and frankly didn't have a super strong reason to do it the current way, other than that it seemed elegant to place all of the Get logic in one place. Note that providers may choose to return nil, in which case we will read state from the provider in the usual Get style.
2017-07-18 03:44:45 +02:00
// 635 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xc4, 0x56, 0x5d, 0x4e, 0xdb, 0x40,
0x10, 0xc6, 0x4e, 0x08, 0x61, 0x82, 0x23, 0xb4, 0x4d, 0x42, 0xe4, 0xfe, 0x28, 0xda, 0xbe, 0x44,
0x42, 0x32, 0x25, 0xa8, 0x2a, 0x02, 0xa9, 0x95, 0x48, 0x21, 0xe2, 0xa5, 0x42, 0xae, 0x78, 0xa8,
0xd4, 0x17, 0xe3, 0x4c, 0x82, 0x15, 0xc7, 0x76, 0xd7, 0x6b, 0x50, 0x0e, 0xd1, 0x0b, 0xf4, 0x32,
0x3d, 0x46, 0xd5, 0xdb, 0x54, 0x5e, 0xaf, 0x8d, 0x9d, 0xa4, 0x50, 0x5a, 0x45, 0x7d, 0xf3, 0xce,
0x7c, 0x33, 0xf3, 0xcd, 0xec, 0xb7, 0x93, 0x40, 0x3d, 0x60, 0xfe, 0x8d, 0x33, 0x44, 0x66, 0x04,
0xcc, 0xe7, 0x3e, 0xd9, 0x70, 0xa3, 0xa9, 0xc3, 0x02, 0x5b, 0x7f, 0x3a, 0xf6, 0xfd, 0xb1, 0x8b,
0x7b, 0xc2, 0x7c, 0x15, 0x8d, 0xf6, 0x70, 0x1a, 0xf0, 0x59, 0x82, 0xd2, 0x9f, 0xcd, 0x3b, 0x43,
0xce, 0x22, 0x9b, 0x27, 0x5e, 0xfa, 0x53, 0x81, 0xad, 0xfe, 0x35, 0xda, 0x13, 0x13, 0xbf, 0x44,
0x18, 0x72, 0x42, 0xa0, 0xcc, 0x67, 0x01, 0xb6, 0x95, 0x8e, 0xd2, 0xdd, 0x34, 0xc5, 0x37, 0x79,
0x03, 0x10, 0x30, 0x3f, 0x40, 0xc6, 0x1d, 0x0c, 0xdb, 0x6a, 0x47, 0xe9, 0xd6, 0x7a, 0x3b, 0x46,
0x92, 0xd7, 0x48, 0xf3, 0x1a, 0x1f, 0x45, 0x5e, 0x33, 0x07, 0x25, 0xef, 0xa0, 0x1a, 0x79, 0x13,
0xcf, 0xbf, 0xf5, 0xc2, 0x76, 0xa9, 0x53, 0xea, 0xd6, 0x7a, 0x2f, 0x0d, 0x49, 0xda, 0xc8, 0x57,
0x35, 0x2e, 0x25, 0xea, 0xd4, 0xe3, 0x6c, 0x66, 0x66, 0x41, 0xfa, 0x31, 0x68, 0x05, 0x17, 0xd9,
0x86, 0xd2, 0x04, 0x67, 0x92, 0x5d, 0xfc, 0x49, 0x1a, 0xb0, 0x7e, 0x63, 0xb9, 0x11, 0x0a, 0x5e,
0x55, 0x33, 0x39, 0x1c, 0xa9, 0x87, 0x0a, 0x3d, 0x01, 0x4d, 0x16, 0x09, 0x03, 0xdf, 0x0b, 0x91,
0xec, 0x43, 0x75, 0x64, 0x39, 0x6e, 0xc4, 0x30, 0x6c, 0x2b, 0x82, 0x4e, 0xb3, 0x48, 0xe7, 0x2c,
0xf1, 0x9a, 0x19, 0x8c, 0x9e, 0xc8, 0xf1, 0x48, 0x0f, 0xd1, 0xa1, 0x2a, 0xfb, 0x4b, 0x49, 0x64,
0x67, 0xd2, 0x82, 0x0a, 0x43, 0x2b, 0xf4, 0x3d, 0x41, 0x65, 0xd3, 0x94, 0x27, 0xfa, 0x43, 0x81,
0xda, 0x07, 0x6b, 0x8a, 0x2b, 0x19, 0xf1, 0xdb, 0x85, 0x11, 0xd3, 0xac, 0xa7, 0x5c, 0xd1, 0xd5,
0x4c, 0x98, 0xc2, 0x56, 0x52, 0x43, 0x0e, 0x98, 0x40, 0xd9, 0xb3, 0xa6, 0x59, 0x67, 0xf1, 0x37,
0xfd, 0x0c, 0x5a, 0x9f, 0xa1, 0xc5, 0x57, 0xd2, 0x3e, 0xfd, 0x04, 0xf5, 0x34, 0xbb, 0xe4, 0x50,
0x07, 0xd5, 0x19, 0xca, 0xe4, 0xaa, 0x33, 0xfc, 0xfb, 0xd4, 0xaf, 0x00, 0x06, 0xc8, 0x53, 0xd6,
0xf3, 0x69, 0xd3, 0x2e, 0xd4, 0xbb, 0x2e, 0xe8, 0x19, 0xd4, 0x44, 0x84, 0x64, 0x52, 0xac, 0xac,
0xfc, 0x79, 0xe5, 0x6f, 0x2a, 0x34, 0xce, 0xbd, 0x30, 0x40, 0x9b, 0xf7, 0xaf, 0x2d, 0x6f, 0x8c,
0x8f, 0x20, 0x41, 0x76, 0xa1, 0xec, 0xbb, 0xc3, 0x58, 0x0c, 0xf7, 0xd6, 0x13, 0xa0, 0x18, 0xec,
0xe1, 0x6d, 0xd8, 0x2e, 0x3f, 0x00, 0x8e, 0x41, 0x64, 0x90, 0x93, 0xda, 0xba, 0x90, 0xda, 0x6e,
0x26, 0xb5, 0x65, 0x74, 0x57, 0xa3, 0xb9, 0x11, 0x34, 0xe7, 0x8a, 0xc9, 0x71, 0xeb, 0x50, 0x65,
0x18, 0xb8, 0x96, 0x2d, 0x5f, 0xf7, 0xa6, 0x99, 0x9d, 0xc9, 0x3e, 0x6c, 0xd8, 0x02, 0xfd, 0xa0,
0x02, 0x52, 0x1c, 0xfd, 0xaa, 0x80, 0x76, 0x19, 0x0c, 0x73, 0xc2, 0xfd, 0xaf, 0xd3, 0xa7, 0xe7,
0x50, 0x4f, 0xe9, 0xfc, 0xab, 0xbe, 0x0e, 0x40, 0x7b, 0x8f, 0x2e, 0x3e, 0xaa, 0xb3, 0xde, 0xf7,
0x12, 0x6c, 0x9b, 0x18, 0xfa, 0x11, 0xb3, 0xf1, 0x42, 0xfe, 0x10, 0x91, 0x43, 0x58, 0x17, 0xeb,
0x91, 0x34, 0x97, 0xee, 0x75, 0xbd, 0x35, 0x6f, 0x4e, 0xa8, 0xd3, 0x35, 0xf2, 0x1a, 0xca, 0xf1,
0xea, 0x20, 0x8d, 0x65, 0xdb, 0x4a, 0x6f, 0xce, 0x59, 0xb3, 0xb0, 0x63, 0xa8, 0x24, 0xef, 0x9d,
0xe4, 0x52, 0xe7, 0xd7, 0x8b, 0xbe, 0xb3, 0x60, 0xcf, 0x82, 0x7b, 0x50, 0x1a, 0x20, 0x27, 0x4f,
0x32, 0xc4, 0xdd, 0xfb, 0xd6, 0x1b, 0x45, 0x63, 0x16, 0x73, 0x01, 0x5a, 0x41, 0x6e, 0xe4, 0xf9,
0xbd, 0x9a, 0xd7, 0x5f, 0xfc, 0xce, 0x9d, 0x6f, 0x21, 0xb9, 0xc8, 0x5c, 0x0b, 0x05, 0xa1, 0xe5,
0x5a, 0x28, 0xde, 0x38, 0x5d, 0x23, 0x47, 0x50, 0x49, 0xae, 0x2e, 0x17, 0x5c, 0xb8, 0x4b, 0xbd,
0xb5, 0xa0, 0x80, 0xd3, 0xf8, 0xdf, 0x00, 0x5d, 0xbb, 0xaa, 0x08, 0xcb, 0xc1, 0xaf, 0x00, 0x00,
0x00, 0xff, 0xff, 0x8e, 0x49, 0xa9, 0xb9, 0x48, 0x08, 0x00, 0x00,
Generate Golang Protobuf/gRPC code This change moves the RPC definitions to the pkg/murpc package, underneath the proto folder. This is to ensure that the resulting Protobufs get a good package name "murpc" that is unique within the overall toolchain. It also includes a `generate.sh` script that can be used to manually regenerate client/server code. Finally, we are actually checking in the generated files underneath pkg/murpc.
2017-02-10 18:08:06 +01:00
}
Reference in a new issue Copy permalink