maxmustermann/pulumi
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Goodbye, custom AWS provider code

Browse source 
😥

Preparing to RI the tfbridge branch into master.
This commit is contained in:
joeduffy 2017-07-21 14:36:58 -07:00
parent 10dc68090d
commit 232ed7e248
206 changed files with 3 additions and 24760 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.travis.yml
View file

@ -22,7 +22,6 @@ install:
- godep restore -v
- pushd cmd/lumijs/ && yarn install && popd
- pushd lib/lumi/ && yarn install && popd
- pushd lib/aws/pack/ && yarn install && popd
before_script:
- export PATH=$TRAVIS_BUILD_DIR/cmd/lumijs:$PATH
- export LUMIROOT=~/.lumi

14
Makefile
View file

@ -13,10 +13,10 @@ GOMETALINTER=${GOMETALINTERBIN} --config=Gometalinter.json
default: banner vet test install lint_quiet
.PHONY: all
all: banner_all vet test install lint_quiet lumijs lumirtpkg lumijspkg lumipkg awspkg
all: banner_all vet test install lint_quiet lumijs lumirtpkg lumijspkg lumipkg
.PHONY: nightly
nightly: banner_all vet test install lint_quiet lumijs lumirtpkg lumijspkg lumipkg awspkg examples gocover
nightly: banner_all vet test install lint_quiet lumijs lumirtpkg lumijspkg lumipkg examples gocover
.PHONY: banner
banner:
@ -75,21 +75,13 @@ test:
lumijs:
@cd ./cmd/lumijs && $(MAKE)
.PHONY: lumirtpkg
lumirtpkg:
@cd ./lib/lumirt && $(MAKE)
.PHONY: lumijspkg
lumijspkg:
@cd ./lib/lumijs && $(MAKE)
.PHONY: lumipkg
lumipkg:
@cd ./lib/lumi && $(MAKE)
.PHONY: awspkg
awspkg:
@cd ./lib/aws && $(MAKE)
.PHONY: lumirtpkg lumijspkg lumipkg
publish:
@$(ECHO) "\033[0;32mPublishing current release:\033[0m"

2
lib/aws/.gitignore vendored
View file

@ -1,2 +0,0 @@
/bin/

26
lib/aws/Gometalinter.json
View file

@ -1,26 +0,0 @@
{
"Deadline": "5m",
"DisableAll": true,
"Enable": [
"aligncheck",
"deadcode",
"errcheck",
"gas",
"goconst",
"gofmt",
"golint",
"gosimple",
"ineffassign",
"interfacer",
"lll",
"misspell",
"staticcheck",
"structcheck",
"unconvert",
"varcheck",
"vet",
"vetshadow"
],
"LineLength": 120
}

87
lib/aws/Makefile
View file

@ -1,87 +0,0 @@
SHELL=/bin/bash
.SHELLFLAGS=-e
GOPKGS = $(shell go list ./provider/... | grep -v /vendor/)
LUMIROOT ?= /usr/local/lumi
LUMILIB = ${LUMIROOT}/packs
THISLIB = ${LUMILIB}/aws
TESTPARALLELISM = 10
ECHO=echo -e
GOMETALINTERBIN=gometalinter
GOMETALINTER=${GOMETALINTERBIN} --config=Gometalinter.json
.PHONY: default
default: banner vet build test install lint_quiet
.PHONY: banner
banner:
@$(ECHO) "\033[1;37m================\033[0m"
@$(ECHO) "\033[1;37mLumi AWS Package\033[0m"
@$(ECHO) "\033[1;37m================\033[0m"
.PHONY: gen
gen:
@$(ECHO) "\033[0;32mGEN:\033[0m"
lumidl \
aws idl/ \
--recursive \
--out-pack=pack/ \
--out-rpc=rpc/
.PHONY: clean
clean:
rm -rf ./bin
rm -rf ${THISLIB}
.PHONY: build
build:
@$(ECHO) "\033[0;32mBUILD:\033[0m"
cd pack/ && yarn link @lumi/lumirt @lumi/lumijs @lumi/lumi # ensure we resolve to Lumi's stdlib.
cd pack/ && lumijs # compile the LumiPack
cd pack/ && lumi pack verify # ensure the pack verifies
cp -R pack/.lumi/bin/ bin/ # copy the pack to our bin dir
go version
cd provider/ && go build -i -o ../bin/lumi-resource-aws # compile the resource provider
.PHONY: install
install: build
@$(ECHO) "\033[0;32mINSTALL:\033[0m [${LUMILIB}]"
cd pack/ && yarn link # ensure NPM references resolve locally.
mkdir -p ${LUMILIB} # ensure the machine-wide library dir exists.
cp -R ./bin/ ${THISLIB} # copy to the standard library location.
.PHONY: lint
lint:
@$(ECHO) "\033[0;32mLINT:\033[0m"
./pack/node_modules/.bin/tslint './pack/**/*.ts' --exclude='./pack/node_modules/**'
which ${GOMETALINTERBIN} >/dev/null
$(GOMETALINTER) ./provider/... | sort ; exit "$${PIPESTATUS[0]}"
# In quiet mode, suppress some messages.
# - "or be unexported": TODO[pulumi/lumi#191]: will fix when we write all of our API docs
# - "cyclomatic complexity" (in config): TODO[pulumi/lumi#259]: need to fix a bunch of complex functions.
LINT_SUPPRESS="or be unexported"
.PHONY: lint_quiet
lint_quiet:
@$(ECHO) "\033[0;32mLINT (quiet):\033[0m"
./pack/node_modules/.bin/tslint './pack/**/*.ts' --exclude='./pack/node_modules/**'
which ${GOMETALINTERBIN} >/dev/null
$(GOMETALINTER) ./provider/... | grep -vE ${LINT_SUPPRESS} | sort ; exit $$(($${PIPESTATUS[1]}-1))
@$(ECHO) "\033[0;33mgolint was run quietly; to run with noisy errors, run 'make lint'\033[0m"
.PHONY: vet
vet:
@$(ECHO) "\033[0;32mVET:\033[0m"
go tool vet -printf=false provider/
.PHONY: test
test:
@$(ECHO) "\033[0;32mTEST:\033[0m"
go test -cover -parallel ${TESTPARALLELISM} ${GOPKGS}
.PHONY: verify
verify: gen
$(shell git diff --quiet .)

6
lib/aws/README.md
View file

@ -1,6 +0,0 @@
# lib/aws
This directory contains the primitive stacks for AWS resources.
Eventually, this should likely move out into its own standalone Git repo.

17
lib/aws/idl/apigateway/account.go
View file

@ -1,17 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package apigateway
import (
"github.com/pulumi/lumi/pkg/resource/idl"
"github.com/pulumi/lumi/lib/aws/idl/iam"
)
// The Account resource specifies the AWS Identity and Access Management (IAM) role that Amazon API
// Gateway (API Gateway) uses to write API logs to Amazon CloudWatch Logs (CloudWatch Logs).
type Account struct {
idl.NamedResource
// CloudWatchRole is the IAM role that has write access to CloudWatch Logs in your account.
CloudWatchRole *iam.Role `lumi:"cloudWatchRole,optional"`
}

30
lib/aws/idl/apigateway/apiKey.go
View file

@ -1,30 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package apigateway
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// The APIKey resource creates a unique key that you can distribute to clients who are executing Amazon
// API Gateway (API Gateway) Method resources that require an API key. To specify which API key clients must use, map
// the API key with the RestApi and Stage resources that include the methods requiring a key.
type APIKey struct {
idl.NamedResource
// KeyName is a name for the API key. If you don't specify a name, a unique physical ID is generated and used.
KeyName *string `lumi:"keyName,replaces,optional"`
// Description is a description of the purpose of the API key.
Description *string `lumi:"description,optional"`
// Enabled indicates whether the API key can be used by clients.
Enabled *bool `lumi:"enabled,optional"`
// StageKeys is a list of stages to associated with this API key.
StageKeys *StageKey `lumi:"stageKeys,optional"`
}
type StageKey struct {
// RestAPI is a RestAPI resource that includes the stage with which you want to associate the API key.
RestAPI *RestAPI `lumi:"restAPI,optional"`
// Stage is the stage with which to associate the API key. The stage must be included in the RestAPI
// resource that you specified in the RestAPI property.
Stage *Stage `lumi:"stage,optional"`
}

50
lib/aws/idl/apigateway/authorizer.go
View file

@ -1,50 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package apigateway
import (
"github.com/pulumi/lumi/pkg/resource/idl"
"github.com/pulumi/lumi/lib/aws/idl/iam"
)
// The Authorizer resource creates an authorization layer that Amazon API Gateway (API Gateway) activates for
// methods that have authorization enabled. API Gateway activates the authorizer when a client calls those methods.
type Authorizer struct {
idl.NamedResource
// Type is the type of authorizer.
Type AuthorizerType `lumi:"type"`
// AuthorizerCredentials are the credentials required for the authorizer. To specify an AWS Identity and Access
// Management (IAM) role that API Gateway assumes, specify the role. To use resource-based permissions on the AWS
// Lambda (Lambda) function, specify null.
AuthorizerCredentials *iam.Role `lumi:"authorizerCredentials,optional"`
// AuthorizerResultTTLInSeconds is the time-to-live (TTL) period, in seconds, that specifies how long API Gateway
// caches authorizer results. If you specify a value greater than `0`, API Gateway caches the authorizer responses.
// By default, API Gateway sets this property to `300`. The maximum value is `3600`, or 1 hour.
AuthorizerResultTTLInSeconds *float64 `lumi:"authorizerResultTTLInSeconds,optional"`
// AuthorizerURI is the authorizer's Uniform Resource Identifier (URI). If you specify `TOKEN` for the authorizer's
// type property, specify a Lambda function URI, which has the form `arn:aws:apigateway:region:lambda:path/path`.
// The path usually has the form `/2015-03-31/functions/LambdaFunctionARN/invocations`.
AuthorizerURI *string `lumi:"authorizerURI,optional"`
// IdentitySource is the source of the identity in an incoming request. If you specify `TOKEN` for the authorizer's
// type property, specify a mapping expression. The custom header mapping expression has the form
// `method.request.header.name`, where name is the name of a custom authorization header that clients submit as part
// of their requests.
IdentitySource *string `lumi:"identitySource,optional"`
// IdentityValidationExpression is a validation expression for the incoming identity. If you specify `TOKEN` for
// the authorizer's type property, specify a regular expression. API Gateway uses the expression to attempt to
// match the incoming client token, and proceeds if the token matches. If the token doesn't match, API Gateway
// responds with a 401 (unauthorized request) error code.
IdentityValidationExpression *string `lumi:"identityValidationExpression,optional"`
// providers is a list of the Amazon Cognito user pools to associate with this authorizer.
Providers *[]idl.Resource/*TODO[pulumi/lumi#217]: cognito.UserPool*/ `lumi:"providers,optional"`
// RestAPI is the resource in which API Gateway creates the authorizer.
RestAPI *RestAPI `lumi:"restAPI,optional"`
}
type AuthorizerType string
const (
TokenAuthorizer AuthorizerType = "TOKEN" // a custom authorizer that uses a Lambda function.
CognitoAuthorizer AuthorizerType = "COGNITO_USER_POOLS" // an authorizer that uses Amazon Cognito user pools.
)

21
lib/aws/idl/apigateway/basePathMapping.go
View file

@ -1,21 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package apigateway
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// The BasePathMapping resource creates a base path that clients who call your Amazon API Gateway API
// must use in the invocation URL.
type BasePathMapping struct {
idl.NamedResource
// DomainName is the domain name for the base path mapping.
DomainName string `lumi:"domainName"`
// RestAPI is the API to map.
RestAPI *RestAPI `lumi:"restAPI"`
// BasePath is the base path that callers of the API must provider in the URL after the domain name.
BasePath *string `lumi:"basePath,optional"`
// Stage is the mapping's API stage.
Stage *Stage `lumi:"stage,optional"`
}

15
lib/aws/idl/apigateway/clientCertificate.go
View file

@ -1,15 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package apigateway
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// The ClientCertificate resource creates a client certificate that Amazon API Gateway (API Gateway)
// uses to configure client-side SSL authentication for sending requests to the integration endpoint.
type ClientCertificate struct {
idl.NamedResource
// Description is a description of the client certificate.
Description *string `lumi:"description,optional"`
}

22
lib/aws/idl/apigateway/deployment.go
View file

@ -1,22 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package apigateway
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// The Deployment resource deploys an Amazon API Gateway (API Gateway) RestAPI resource to a stage so
// that clients can call the API over the Internet. The stage acts as an environment.
type Deployment struct {
idl.NamedResource
// restAPI is the RestAPI resource to deploy.
RestAPI *RestAPI `lumi:"restAPI,replaces"`
// description is a description of the purpose of the API Gateway deployment.
Description *string `lumi:"description,optional"`
// The identifier for the deployment resource.
ID string `lumi:"id,out"`
// The date and time that the deployment resource was created.
CreatedDate string `lumi:"createdDate,out"`
}

215
lib/aws/idl/apigateway/method.go
View file

@ -1,215 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package apigateway
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// The Method resource creates Amazon API Gateway (API Gateway) methods that define the parameters and
// body that clients must send in their requests.
type Method struct {
idl.NamedResource
// The HTTP method that clients will use to call this method.
HTTPMethod string `lumi:"httpMethod"`
// The API Gateway resource. For root resource methods, specify the RestAPI's root resource ID.
APIResource *Resource `lumi:"apiResource"`
// The RestAPI resource in which API Gateway creates the method.
RestAPI *RestAPI `lumi:"restAPI"`
// Indicates whether the method requires clients to submit a valid API key.
APIKeyRequired *bool `lumi:"apiKeyRequired,optional"`
// The method's authorization type. Required to be "CUSTOM" if you specify an authorizer.
AuthorizationType *AuthorizationType `lumi:"authorizationType,optional"`
// The authorizer to use on this method. If you specify this, make sure authorizationType is set to "CUSTOM".
Authorizer *Authorizer `lumi:"authorizer,optional"`
// The back-end system that the method calls when it receives a request.
Integration *Integration `lumi:"integration,optional"`
// The responses that can be sent to the client who calls the method.
MethodResponses *[]MethodResponse `lumi:"methodResponses,optional"`
// The resources used for the response's content type. Specify response models as key-value pairs, with a content
// type (string) as the key and a Model resource as the value.
RequestModels *map[string]*Model `lumi:"requestModels,optional"`
// Request parameters that API Gateway accepts. Specify request parameters as key-value pairs (string-to-Boolean
// map), with a source as the key and a Boolean as the value. The Boolean specifies whether a parameter is
// required. A source must match the following format `method.request.location.name`, where the `location` is
// `querystring`, `path`, or `header`, and `name` is a valid, unique parameter name.
RequestParameters *map[string]bool `lumi:"requestParameters,optional"`
}
// The method's authorization type.
type AuthorizationType string
const (
NoAuthorization AuthorizationType = "NONE" // open access.
AWSIAMAuthorization AuthorizationType = "AWS_IAM" // using AWS IAM permissions.
CustomAuthorization AuthorizationType = "CUSTOM" // a custom authorizer.
CognitoAuthorization AuthorizationType = "COGNITO_USER_POOLS" // a Cognito user pool.
)
// Integration specifies information about the target back end that an Amazon API Gateway method calls.
type Integration struct {
// The type of back end your method is running.
Type IntegrationType `lumi:"type"`
// A list of request parameters whose values API Gateway will cache.
CacheKeyParameters *[]string `lumi:"cacheKeyParameters,optional"`
// An API-specific tag group of related cached parameters.
CacheNamespace *string `lumi:"cacheNamespace,optional"`
// The credentials required for the integration. To specify an AWS Identity and Access Management (IAM) role that
// API Gateway assumes, specify the role's Amazon Resource Name (ARN). To require that the caller's identity be
// passed through from the request, specify arn:aws:iam::*:user/*.
//
// To use resource-based permissions on the AWS Lambda (Lambda) function, don't specify this property. Use the
// AWS::Lambda::Permission resource to permit API Gateway to call the function. For more information, see
// http://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html#access-control-resource-based-example-apigateway-invoke-function.
Credentials *string `lumi:"credentials,optional"`
// The integration's HTTP method type. This is required for all types except for "MOCK".
IntegrationHTTPMethod *string `lumi:"integrationHTTPMethod,optional"`
// The response that API Gateway provides after a method's back end completes processing a request. API Gateway
// intercepts the back end's response so that you can control how API Gateway surfaces back-end responses. For
// example, you can map the back-end status codes to codes that you define.
IntegrationResponse *[]IntegrationResponse `lumi:"integrationResponse,optional"`
// Indicates when API Gateway passes requests to the targeted back end. This behavior depends on the request's
// Content-Type header and whether you defined a mapping template for it.
PassthroughBehavior *PassthroughBehavior `lumi:"passthroughBehavior,optional"`
// The request parameters that API Gateway sends with the back-end request. Specify request parameters as key-value
// pairs (string-to-string maps), with a destination as the key and a source as the value.
//
// Specify the destination using the following pattern `integration.request.location.name`, where `location` is
// `querystring`, `path`, or `header`, and `name` is a valid, unique parameter name.
//
// The source must be an existing method request parameter or a static value. Static values must be enclosed in
// single quotation marks and pre-encoded based on their destination in the request.
RequestParameters *map[string]string `lumi:"requestParameters,optional"`
// A map of Apache Velocity templates that are applied on the request payload. The template that API Gateway uses
// is based on the value of the Content-Type header sent by the client. The content type value is the key, and the
// template is the value (specified as a string). For more information about templates, see
// http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html.
RequestTemplates *map[string]string `lumi:"requestTemplates,optional"`
// The integration's Uniform Resource Identifier (URI).
//
// If you specify "HTTP" for the Type property, specify the API endpoint URL.
//
// If you specify "MOCK" for the Type property, don't specify this property.
//
// If you specify "AWS" for the Type property, specify an AWS service that follows the form:
// `arn:aws:apigateway:region:subdomain.service|service:path|action/service_api`. For example, a Lambda function
// URI follows the form: `arn:aws:apigateway:region:lambda:path/path`. The path is usually in the form
// `/2015-03-31/functions/LambdaFunctionARN/invocations`. For more information, see Integration's URI property.
//
// If you specify "HTTP" or "AWS" for the Type property, you must specify the URI property.
URI *string `lumi:"uri,optional"`
}
// IntegrationType specifies an Integration's type.
type IntegrationType string
const (
HTTPIntegration IntegrationType = "HTTP" // for integrating with an HTTP back end.
HTTPProxyIntegration IntegrationType = "HTTP_PROXY" // for integrating with the HTTP proxy integration.
AWSIntegration IntegrationType = "AWS" // for any AWS service endpoints.
AWSProxyIntegration IntegrationType = "AWS_PROXY" // for integrating with the Lambda proxy integration type.
MockIntegration IntegrationType = "MOCK" // for testing without actually invoking the back end.
)
// IntegrationResponse specifies the response that Amazon API Gateway sends after a method's back end finishes
// processing a request.
type IntegrationResponse struct {
// The response parameters from the back-end response that API Gateway sends to the method response. Specify
// response parameters as key-value pairs (string-to-string mappings).
//
// Use the destination as the key and the source as the value:
//
// * The destination must be an existing response parameter in the MethodResponse property.
//
// * The source must be an existing method request parameter or a static value. You must enclose static values
// in single quotation marks and pre-encode these values based on the destination specified in the request.
//
// For more information, see
// http://docs.aws.amazon.com/apigateway/latest/developerguide/request-response-data-mappings.html.
ResponseParameters *map[string]string `lumi:"responseParameters,optional"`
// The templates used to transform the integration response body. Specify templates as key-value pairs
// (string-to-string maps), with a content type as the key and a template as the value. For more information, see
// http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html.
ResponseTemplates *map[string]string `lumi:"responseTemplates,optional"`
// A regular expression that specifies which error strings or status codes from the back end map to the integration
// response.
SelectionPattern *string `lumi:"selectionPattern,optional"`
// The status code that API Gateway uses to map the integration response to a MethodResponse status code.
StatusCode *string `lumi:"statusCode,optional"`
}
// PassthroughBehavior specifies how the method request body of an unmapped content type will be passed through the
// integration request to the back end without transformation. A content type is unmapped if no mapping template is
// defined in the integration or the content type does not match any of the mapped content types.
type PassthroughBehavior string
const (
// Passes the method request body through the integration request to the back end without transformation when the
// method request content type does not match any content type associated with the mapping templates defined in the
// integration request.
PassthroughWhenNoMatch PassthroughBehavior = "WHEN_NO_MATCH"
// Passes the method request body through the integration request to the back end without transformation when no
// mapping template is defined in the integration request. If a template is defined when this option is selected,
// the method request of an unmapped content-type will be rejected with an HTTP 415 Unsupported Media Type response.
PassthroughWhenNoTemplates PassthroughBehavior = "WHEN_NO_TEMPLATES"
// Rejects the method request with an HTTP 415 Unsupported Media Type response when either the method request
// content type does not match any content type associated with the mapping templates defined in the integration
// request or no mapping template is defined in the integration request.
PassthroughNever PassthroughBehavior = "NEVER"
)
// MethodResponse defines the responses that can be sent to the client who calls an Amazon API Gateway method.
type MethodResponse struct {
// The method response's status code, which you map to an IntegrationResponse.
StatusCode string `lumi:"statusCode"`
// The resources used for the response's content type. Specify response models as key-value pairs, with a content
// type as the key (string) and a Model resource as the value.
ResponseModels *map[string]*Model `lumi:"responseModels,optional"`
// Response parameters that API Gateway sends to the client that called a method. Specify response parameters as
// key-value pairs (string-to-Boolean maps), with a destination as the key and a Boolean as the value. Specify the
// destination using the following pattern: `method.response.header.name`, where the `name` is a valid, unique
// header name. The Boolean specifies whether a parameter is required.
ResponseParameters *map[string]bool `lumi:"responseParameters,optional"`
}
// MethodSetting configures settings for all methods in an Amazon API Gateway (API Gateway) stage.
type MethodSetting struct {
// Indicates whether the cached responses are encrypted.
CacheDataEncrypted *bool `lumi:"cacheDataEncrypted,optional"`
// The time-to-live (TTL) period, in seconds, that specifies how long API Gateway caches responses.
CacheTTLInSeconds *float64 `lumi:"cacheTTLInSeconds,optional"`
// Indicates whether responses are cached and returned for requests. You must enable a cache cluster on the stage
// to cache responses. For more information, see
// http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-caching.html.
CachingEnabled *bool `lumi:"cachingEnabled,optional"`
// Indicates whether data trace logging is enabled for methods in the stage. API Gateway pushes these logs to Amazon
// CloudWatch Logs.
DataTraceEnabled *bool `lumi:"dataTraceEnabled,optional"`
// The HTTP method.
HTTPMethod *string `lumi:"httpMethod,optional"`
// The logging level for this method.
LoggingLevel *LoggingLevel `lumi:"loggingLevel,optional"`
// Indicates whether Amazon CloudWatch metrics are enabled for methods in the stage.
MetricsEnabled *bool `lumi:"metricsEnabled,optional"`
// The resource path for this method. Forward slashes (`/`) are encoded as `~1` and the initial slash must include
// a forward slash. For example, the path value `/resource/subresource` must be encoded as
// `/~1resource~1subresource.` To specify the root path, use only a slash (`/`).
ResourcePath *string `lumi:"resourcePath,optional"`
// The number of burst requests per second that API Gateway permits across all APIs, stages, and methods in your
// AWS account. For more information, see
// http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-request-throttling.html.
ThrottlingBurstLimit *float64 `lumi:"throttlingBurstLimit,optional"`
// The number of steady-state requests per second that API Gateway permits across all APIs, stages, and methods in
// your AWS account. For more information, see
// http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-request-throttling.html.
ThrottlingRateLimit *float64 `lumi:"throttlingRateLimit,optional"`
}
// Specifies the logging level for this method, which effects the log entries pushed to Amazon CloudWatch Logs.
type LoggingLevel string
const (
LoggingOff LoggingLevel = "OFF"
LoggingErrorLevel LoggingLevel = "ERROR"
LoggingInfoLevel LoggingLevel = "INFO"
)

23
lib/aws/idl/apigateway/model.go
View file

@ -1,23 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package apigateway
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// The Model resource defines the structure of a request or response payload for an Amazon API Gateway method.
type Model struct {
idl.NamedResource
// The content type for the model.
ContentType string `lumi:"contentType,replaces"`
// The REST API with which to associate this model.
RestAPI *RestAPI `lumi:"restAPI,replaces"`
// The schema to use to transform data to one or more output formats. Specify null (`{}`) if you don't want to
// specify a schema.
Schema interface{} `lumi:"schema"`
// A name for the model. If you don't specify a name, a unique physical ID is generated and used.
ModelName *string `lumi:"modelName,replaces,optional"`
// A description that identifies this model.
Description *string `lumi:"description,optional"`
}

19
lib/aws/idl/apigateway/resource.go
View file

@ -1,19 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package apigateway
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// An Amazon API Gateway (API Gateway) API resource.
type Resource struct {
idl.NamedResource
// If you want to create a child resource, the parent resource. For resources without a parent, specify
// the RestAPI's root resource.
Parent *Resource `lumi:"parent,replaces"`
// A path name for the resource.
PathPart string `lumi:"pathPart,replaces"`
// The RestAPI resource in which you want to create this resource.
RestAPI *RestAPI `lumi:"restAPI,replaces"`
}

55
lib/aws/idl/apigateway/restAPI.go
View file

@ -1,55 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package apigateway
import (
"github.com/pulumi/lumi/pkg/resource/idl"
"github.com/pulumi/lumi/lib/aws/idl/s3"
)
// The RestAPI resource contains a collection of Amazon API Gateway (API Gateway) resources and methods that can be
// invoked through HTTPS endpoints.
type RestAPI struct {
idl.NamedResource
// An OpenAPI specification that defines a set of RESTful APIs in the JSON format.
Body *interface{} `lumi:"body,optional"`
// The Amazon Simple Storage Service (Amazon S3) location that points to a OpenAPI file, which defines a set of
// RESTful APIs in JSON or YAML format.
BodyS3Location *S3Location `lumi:"bodyS3Location,optional"`
// Another API Gateway RestAPI resource that you want to clone.
CloneFrom *RestAPI `lumi:"cloneFrom,optional"`
// A description of the purpose of this API Gateway RestAPI resource.
Description *string `lumi:"description,optional"`
// If a warning occurs while API Gateway is creating the RestAPI resource, indicates whether to roll back the
// resource.
FailOnWarnings *bool `lumi:"failOnWarnings,optional"`
// A name for the API Gateway RestApi resource. Required if you don't specify an OpenAPI definition.
APIName *string `lumi:"apiName,optional"`
// Custom header parameters for the request.
Parameters *[]string `lumi:"parameters,optional"`
// The API's identifier. This identifier is unique across all of your APIs in Amazon API Gateway.
ID string `lumi:"id,out"`
// The timestamp when the API was created.
CreatedDate string `lumi:"createdDate,out"`
// A version identifier for the API.
Version string `lumi:"version,out"`
// The warning messages reported when failonwarnings is turned on during API import.
Warnings []string `lumi:"warnings,out"`
// The list of binary media types supported by the RestApi. By default, the RestApi supports only UTF-8-encoded
// text payloads.
BinaryMediaTypes []string `lumi:"binaryMediaTypes,out"`
}
// S3Location is a property of the RestAPI resource that specifies the Amazon Simple Storage Service (Amazon S3)
// location of a OpenAPI (formerly Swagger) file that defines a set of RESTful APIs in JSON or YAML.
type S3Location struct {
// The S3 object corresponding to the OpenAPI file.
Object *s3.Object `lumi:"object"`
// The Amazon S3 ETag (a file checksum) of the OpenAPI file. If you don't specify a value, API Gateway skips ETag
// validation of your OpenAPI file.
ETag *string `lumi:"etag,optional"`
// For versioning-enabled buckets, a specific version of the OpenAPI file.
Version *string `lumi:"version,optional"`
}

42
lib/aws/idl/apigateway/stage.go
View file

@ -1,42 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package apigateway
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// The Stage resource specifies the AWS Identity and Access Management (IAM) role that Amazon API
// Gateway (API Gateway) uses to write API logs to Amazon CloudWatch Logs (CloudWatch Logs).
type Stage struct {
idl.NamedResource
// The RestAPI resource that you're deploying with this stage.
RestAPI *RestAPI `lumi:"restAPI,replaces"`
// The name of the stage, which API Gateway uses as the first path segment in the invoke URI.
StageName string `lumi:"stageName,replaces"`
// The deployment that the stage points to.
Deployment *Deployment `lumi:"deployment"`
// Indicates whether cache clustering is enabled for the stage.
CacheClusterEnabled *bool `lumi:"cacheClusterEnabled,optional"`
// The stage's cache cluster size.
CacheClusterSize *string `lumi:"cacheClusterSize,optional"`
// The identifier of the client certificate that API Gateway uses to call your integration endpoints in the stage.
ClientCertificate *ClientCertificate `lumi:"clientCertificate,optional"`
// A description of the stage's purpose.
Description *string `lumi:"description,optional"`
// Settings for all methods in the stage.
MethodSettings *[]MethodSetting `lumi:"methodSettings,optional"`
// A map (string to string map) that defines the stage variables, where the variable name is the key and the
// variable value is the value. Variable names are limited to alphanumeric characters. Values must match the
// following regular expression: `[A-Za-z0-9-._~:/?#&=,]+`.
Variables *map[string]string `lumi:"variables,optional"`
// The timestamp when the stage was created.
CreatedDate string `lumi:"createdDate,out"`
// The timestamp when the stage last updated.
LastUpdatedDate string `lumi:"lastUpdatedDate,out"`
// The URL to invoke the HTTP endpoint for this API stage.
URL string `lumi:"url,out"`
// The execution ARN needed to pass to Lambda to give this API stage permission.
ExecutionARN string `lumi:"executionARN,out"`
}

61
lib/aws/idl/apigateway/usagePlan.go
View file

@ -1,61 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package apigateway
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// The UsagePlan resource specifies a usage plan for deployed Amazon API Gateway (API Gateway) APIs. A
// usage plan enforces throttling and quota limits on individual client API keys. For more information, see
// http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html.
type UsagePlan struct {
idl.NamedResource
APIStages *[]APIStage `lumi:"apiStages,optional"`
Description *string `lumi:"description,optional"`
Quota *QuotaSettings `lumi:"quota,optional"`
Throttle *ThrottleSettings `lumi:"throttle,optional"`
UsagePlanName *string `lumi:"usagePlanName,optional"`
}
// APIStage specifies which Amazon API Gateway (API Gateway) stage and API to associate with a usage plan.
type APIStage struct {
// The API you want to associate with the usage plan.
API *RestAPI `lumi:"api,optional"`
// The Stage you want to associate with the usage plan.
Stage *Stage `lumi:"stage,optional"`
}
// QuotaSettings specifies the maximum number of requests users can make to your Amazon API Gateway (API Gateway) APIs.
type QuotaSettings struct {
// The maximum number of requests that users can make within the specified time period.
Limit *float64 `lumi:"limit,optional"`
// For the initial time period, the number of requests to subtract from the specified limit. When you first
// implement a usage plan, the plan might start in the middle of the week or month. With this property, you can
// decrease the limit for this initial time period.
Offset *float64 `lumi:"offset,optional"`
// The time period for which the maximum limit of requests applies.
Period *QuotaPeriod `lumi:"period,optional"`
}
// The time period in which a quota limit applies.
type QuotaPeriod string
const (
QuotaDayPeriod QuotaPeriod = "DAY"
QuotaWeekPeriod QuotaPeriod = "WEEK"
QuotaMonthPeriod QuotaPeriod = "MONTH"
)
// ThrottleSettings specifies the overall request rate (average requests per second) and burst capacity when users call
// your Amazon API Gateway (API Gateway) APIs.
type ThrottleSettings struct {
// The maximum API request rate limit over a time ranging from one to a few seconds. The maximum API request rate
// limit depends on whether the underlying token bucket is at its full capacity. For more information about request
// throttling, see http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-request-throttling.html.
BurstRateLimit *float64 `lumi:"burstRateLimit,optional"`
// The API request steady-state rate limit (average requests per second over an extended period of time). For more
// information about request throttling, see
// http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-request-throttling.html.
RateLimit *float64 `lumi:"rateLimit,optional"`
}

17
lib/aws/idl/apigateway/usagePlanKey.go
View file

@ -1,17 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package apigateway
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// The UsagePlanKey resource associates an Amazon API Gateway API key with an API Gateway usage plan. This association
// determines which user the usage plan is applied to.
type UsagePlanKey struct {
idl.NamedResource
// The API key for the API resource to associate with a usage plan.
Key *APIKey `lumi:"key,replaces"`
// The usage plan.
UsagePlan *UsagePlan `lumi:"usagePlan,replaces"`
}

118
lib/aws/idl/cloudwatch/alarm.go
View file

@ -1,118 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package cloudwatch
import (
"github.com/pulumi/lumi/pkg/resource/idl"
"github.com/pulumi/lumi/lib/aws/idl/sns"
)
// Alarm is a CloudWatch alarm. For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cw-alarm.html.
type Alarm struct {
idl.NamedResource
// The arithmetic operator to use when comparing the specified statistic and threshold. The specified statistic
// value is used as the first operand (so, "<statistic> <op> <threshold>").
ComparisonOperator AlarmComparisonOperator `lumi:"comparisonOperator"`
// The number of periods over which data is compared to the specific threshold.
EvaluationPeriods float64 `lumi:"evaluationPerids"`
// The name for the alarm's associated metric.
MetricName string `lumi:"metricName"`
// The namespace for the alarm's associated metric.
Namespace string `lumi:"namespace"`
// The time over which the specified statistic is applied; it is a time in second that is a multiple of 60.
Period float64 `lumi:"period"`
// The statistic to apply to the alarm's associated metric.
Statistic AlarmStatistic `lumi:"statistic"`
// The value against which the specified statistic is compared.
Threshold float64 `lumi:"threshold"`
// Indicates whether or not actions should be executed during any changes to the alarm's state.
ActionsEnabled *bool `lumi:"actionsEnabled,optional"`
// The list of actions to execute hen this alarm transitions into an ALARM state from any other state. Each action
// is specified as an Amazon Resource Number (ARN).
AlarmActions *[]ActionTarget `lumi:"alarmActions,optional"`
// The description for the alarm.
AlarmDescription *string `lumi:"alarmDescription,optional"`
// A name for the alarm. If you don't specify one, an auto-generated physical ID will be assigned.
AlarmName *string `lumi:"alarmName,replaces,optional"`
// The dimension for the alarm's associated metric.
Dimensions *[]AlarmDimension `lumi:"dimensions,optional"`
// The list of actions to execute when this alarm transitions into an INSUFFICIENT_DATA state from any other state.
// Each action is specified as an Amazon Resource Number (ARN). Currently the only action supported is publishing
// to an Amazon SNS topic or an Amazon Auto Scaling policy.
InsufficientDataActions *[]ActionTarget `lumi:"insufficientDataActions,optional"`
// The list of actions to execute when this alarm transitions into an OK state from any other state. Each action is
// specified as an Amazon Resource Number (ARN). Currently the only action supported is publishing to an Amazon SNS
// topic of an Amazon Auto Scaling policy.
OKActions *[]ActionTarget `lumi:"okActions,optional"`
// The unit for the alarm's associated metric.
Unit *AlarmMetric `lumi:"unit,optional"`
}
// ActionTarget is a strongly typed capability for an action target to avoid string-based ARNs.
// TODO[pulumi/lumi#90]: once we support more resource types, we need to support Auto Scaling policies, etc. It's
// not yet clear whether we should do this using ARNs, or something else.
type ActionTarget sns.Topic
// AlarmComparisonOperator represents the operator (>=, >, <, or <=) used for alarm threshold comparisons.
type AlarmComparisonOperator string
const (
ThresholdGreaterThanOrEqualTo AlarmComparisonOperator = "GreaterThanOrEqualToThreshold"
ThresholdGreaterThan AlarmComparisonOperator = "GreaterThanThreshold"
ThresholdLessThan AlarmComparisonOperator = "LessThanThreshold"
ThresholdLessThanOrEqualTo AlarmComparisonOperator = "LessThanOrEqualToThreshold"
)
// AlarmStatistic represents the legal values for an alarm's statistic.
type AlarmStatistic string
const (
SampleCountStatistic AlarmStatistic = "SampleCount"
AverageStatistic AlarmStatistic = "Average"
SumStatistic AlarmStatistic = "Sum"
MinimumStatistic AlarmStatistic = "Minimum"
MaximumStatistic AlarmStatistic = "Maximum"
)
// AlarmDimension is an embedded property of the alarm type. Dimensions are arbitrary name/value pairs that can be
// associated with a CloudWatch metric. You can specify a maximum of 10 dimensions for a given metric.
type AlarmDimension struct {
Name string `lumi:"name"` // the name of the dimension, from 1-255 characters in length.
// TODO[pulumi/lumi#90]: strongly type this.
Value interface{} `lumi:"value"` // the value representing the dimension measurement, from 1-255 characters in length.
}
// AlarmMetric represents the legal values for an alarm's associated metric.
type AlarmMetric string
const (
SecondsMetric AlarmMetric = "Seconds"
MicrosecondsMetric AlarmMetric = "Microseconds"
MillisecondsMetric AlarmMetric = "Milliseconds"
BytesMetric AlarmMetric = "Bytes"
KilobytesMetric AlarmMetric = "Kilobytes"
MegabytesMetric AlarmMetric = "Megabytes"
GigabytesMetric AlarmMetric = "Gigabytes"
TerabytesMetric AlarmMetric = "Terabytes"
BytesPerSecondMetric AlarmMetric = "Bytes/Second"
KilobytesPerSecondMetric AlarmMetric = "Kilobytes/Second"
MegabytesPerSecondMetric AlarmMetric = "Megabytes/Second"
GigabytesPerSecondMetric AlarmMetric = "Gigabytes/Second"
TerabytesPerSecondMetric AlarmMetric = "Terabytes/Second"
BitsMetric AlarmMetric = "Bits"
KilobitsMetric AlarmMetric = "Kilobits"
MegabitsMetric AlarmMetric = "Megabits"
GigabitsMetric AlarmMetric = "Gigabits"
TerabitsMetric AlarmMetric = "Terabits"
BitsPerSecondMetric AlarmMetric = "Bits/Second"
KilobitsPerSecondMetric AlarmMetric = "Kilobits/Second"
MegabitsPerSecondMetric AlarmMetric = "Megabits/Second"
GigabitsPerSecondMetric AlarmMetric = "Gigabits/Second"
TerabitsPerSecondMetric AlarmMetric = "Terabits/Second"
PercentMetric AlarmMetric = "Percent"
CountMetric AlarmMetric = "Count"
CountPerSecondMetric AlarmMetric = "Count/Second"
NoMetric AlarmMetric = "None"
)

17
lib/aws/idl/cloudwatch/logGroup.go
View file

@ -1,17 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package cloudwatch
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// LogGroup is a CloudWatch Logs log group. For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-logs-loggroup.html.
type LogGroup struct {
idl.NamedResource
// The name of the log group.
LogGroupName *string `lumi:"logGroupName,optional,replaces"`
// The number of days log events are kept in CloudWatch Logs. When a log event expires, CloudWatch Logs automatically deletes it.
RetentionInDays *float64 `lumi:"retentionInDays,optional"`
}

37
lib/aws/idl/cloudwatch/logSubscriptionFilter.go
View file

@ -1,37 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package cloudwatch
import (
aws "github.com/pulumi/lumi/lib/aws/idl"
"github.com/pulumi/lumi/pkg/resource/idl"
)
// LogSubscriptionFilter is a CloudWatch Logs subscription filter. For more information, see
// http://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CreateSubscriptionFilter.html.
type LogSubscriptionFilter struct {
idl.NamedResource
// The name of the log group.
LogGroupName string `lumi:"logGroupName,replaces"`
// A filter pattern for subscribing to a filtered stream of log events.
FilterPattern string `lumi:"filterPattern"`
// The ARN of the destination to deliver matching log events to.
DestinationArn string `lumi:"destinationArn,replaces"`
// The ARN of an IAM role that grants CloudWatch Logs permissions to deliver ingested log events to the
// destination stream. You don't need to provide the ARN when you are working with a logical destination for
// cross-account delivery.
RoleARN *aws.ARN `lumi:"roleArn,optional"`
// The method used to distribute log data to the destination, when the destination is an Amazon Kinesis stream.
// By default, log data is grouped by log stream. For a more even distribution, you can group log data randomly.
Distribution *LogSubscriptionDistribution `lumi:"distribution,optional"`
// The time the log group subscription gilter was created.
CreationTime *float64 `lumi:"creationTime,out"`
}
type LogSubscriptionDistribution string
const (
RandomDistribution LogSubscriptionDistribution = "Random"
ByLogStreamDistribution LogSubscriptionDistribution = "ByLogStream"
)

61
lib/aws/idl/dynamodb/table.go
View file

@ -1,61 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package dynamodb
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// The Table resource creates an AWS DynamoDB Table. For more information, see
// http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/.
type Table struct {
idl.NamedResource
HashKey string `lumi:"hashKey,replaces"`
Attributes []Attribute `lumi:"attributes"`
ReadCapacity float64 `lumi:"readCapacity"`
WriteCapacity float64 `lumi:"writeCapacity"`
RangeKey *string `lumi:"rangeKey,optional,replaces"`
TableName *string `lumi:"tableName,optional,replaces"`
GlobalSecondaryIndexes *[]GlobalSecondaryIndex `lumi:"globalSecondaryIndexes,optional"`
// TODO[pulumi/lumi#216]:
// LocalSecondaryIndexes
// StreamSpecification
}
// Attribute is a DynamoDB Table Attribute definition.
type Attribute struct {
// Name of the DynamoDB Table Attribute.
Name string `lumi:"name"`
// Type of the DynamoDB Table Attribute. You can specify S for string data, N for numeric data, or B for binary data.
Type AttributeType `lumi:"type"`
}
// AttributeType represents the types of DynamoDB Table Attributes.
type AttributeType string
const (
StringAttribute AttributeType = "S"
NumberAttribute AttributeType = "N"
BinaryAttribute AttributeType = "B"
)
// A GlobalSecondaryIndex represents an alternative index at DynamoDB Table
type GlobalSecondaryIndex struct {
IndexName string `lumi:"indexName"`
HashKey string `lumi:"hashKey"`
RangeKey *string `lumi:"rangeKey,optional"`
ReadCapacity float64 `lumi:"readCapacity"`
WriteCapacity float64 `lumi:"writeCapacity"`
NonKeyAttributes []string `lumi:"nonKeyAttributes"`
ProjectionType ProjectionType `lumi:"projectionType"`
}
// ProjectionType represents the types of DynamoDB Table Attributes.
type ProjectionType string
const (
KeysOnlyProjection ProjectionType = "KEYS_ONLY"
IncludeProjection ProjectionType = "INCLUDE"
AllProjection ProjectionType = "ALL"
)

152
lib/aws/idl/ec2/instance.go
View file

@ -1,152 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package ec2
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// Instance ia an EC2 VM instance. For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance.html.
type Instance struct {
idl.NamedResource
// Provides the unique ID of the Amazon Machine Image (AMI) that was assigned during registration.
ImageID string `lumi:"imageId,replaces"`
// The instance type, such as t2.micro. The default type is "m3.medium".
InstanceType *InstanceType `lumi:"instanceType,optional,replaces"`
// A list that contains the Amazon EC2 security groups to assign to the Amazon EC2 instance.
SecurityGroups *[]*SecurityGroup `lumi:"securityGroups,optional,replaces"`
// Provides the name of the Amazon EC2 key pair.
KeyName *string `lumi:"keyName,optional,replaces"`
// Provides a list of tags to attach to the instance.
Tags *[]Tag `lumi:"tags,optional"`
// Output properties:
// The Availability Zone where the specified instance is launched. For example: `us-east-1b`.
AvailabilityZone string `lumi:"availabilityZone,out"`
// The private DNS name of the specified instance. For example: `ip-10-24-34-0.ec2.internal`.
PrivateDNSName *string `lumi:"privateDNSName,out,optional"`
// The public DNS name of the specified instance. For example: `ec2-107-20-50-45.compute-1.amazonaws.com`.
PublicDNSName *string `lumi:"publicDNSName,out,optional"`
// The private IP address of the specified instance. For example: `10.24.34.0`.
PrivateIP *string `lumi:"privateIP,out,optional"`
// The public IP address of the specified instance. For example: `192.0.2.0`.
PublicIP *string `lumi:"publicIP,out,optional"`
}
// A Tag applied to an EC2 instance.
type Tag struct {
Key string `lumi:"key"`
Value string `lumi:"value"`
}
// InstanceType is an enum type with all the names of instance types available in EC2.
type InstanceType string
const (
// GENERAL PURPOSE:
// T2: Instances are Burstable Performance Instances that provide a baseline level of CPU performance with the
// ability to burst above the baseline. The baseline performance and ability to burst are governed by CPU Credits.
// Each T2 instance receives CPU Credits continuously at a set rate depending on the instance size. T2 instances
// accrue CPU Credits when they are idle, and use CPU credits when they are active. T2 instances are a good choice
// for workloads that don’t use the full CPU often or consistently, but occasionally need to burst (e.g. web
// servers, developer environments and databases). For more information see Burstable Performance Instances.
T2InstanceNano InstanceType = "t2.nano"
T2InstanceMicro InstanceType = "t2.micro"
T2InstanceSmall InstanceType = "t2.small"
T2InstanceMedium InstanceType = "t2.medium"
T2InstanceLarge InstanceType = "t2.large"
T2InstanceXLarge InstanceType = "t2.xlarge"
T2Instance2XLarge InstanceType = "t2.2xlarge"
// M4: Instances are the latest generation of General Purpose Instances. This family provides a balance of compute,
// memory, and network resources, and it is a good choice for many applications.
M4InstanceLarge InstanceType = "m4.large"
M4InstanceXLarge InstanceType = "m4.xlarge"
M4Instance2XLarge InstanceType = "m4.2xlarge"
M4Instance4XLarge InstanceType = "m4.4xlarge"
M4Instance10XLarge InstanceType = "m4.10xlarge"
M4Instance16XLarge InstanceType = "m4.16xlarge"
// M3: This family includes the M3 instance types and provides a balance of compute, memory, and network resources,
// and it is a good choice for many applications.
M3InstanceMedium InstanceType = "m3.medium"
M3InstanceLarge InstanceType = "m3.large"
M3InstanceXLarge InstanceType = "m3.xlarge"
M3Instance2XLarge InstanceType = "m3.2xlarge"
// COMPUTE OPTIMIZED:
// C4: Instances are the latest generation of Compute-optimized instances, featuring the highest performing
// processors and the lowest price/compute performance in EC2.
C4InstanceLarge InstanceType = "c4.large"
C4InstanceXLarge InstanceType = "c4.xlarge"
C4Instance2XLarge InstanceType = "c4.2xlarge"
C4Instance4XLarge InstanceType = "c4.4xlarge"
C4Instance8XLarge InstanceType = "c4.8xlarge"
// C3: Instances are the previous generation of Compute-optimized instances.
C3InstanceLarge InstanceType = "c3.large"
C3InstanceXLarge InstanceType = "c3.xlarge"
C3Instance2XLarge InstanceType = "c3.2xlarge"
C3Instance4XLarge InstanceType = "c3.4xlarge"
C3Instance8XLarge InstanceType = "c3.8xlarge"
// MEMORY OPTIMIZED:
// X1: Instances are optimized for large-scale, enterprise-class, in-memory applications and have the lowest price
// per GiB of RAM among Amazon EC2 instance types.
X1Instance32XLarge InstanceType = "x1.32xlarge"
X1Instance16XLarge InstanceType = "x1.16xlarge"
// R4: Instance InstanceType =s are optimized for memory-intensive applications and offer better price per GiB of RAM than R3.
R4InstanceLarge InstanceType = "r4.large"
R4InstanceXLarge InstanceType = "r4.xlarge"
R4Instance2XLarge InstanceType = "r4.2xlarge"
R4Instance4XLarge InstanceType = "r4.4xlarge"
R4Instance8XLarge InstanceType = "r4.8xlarge"
R4Instance16XLarge InstanceType = "r4.16xlarge"
// R3: Instance InstanceType =s are optimized for memory-intensive applications and offer lower price per GiB of RAM.
R3InstanceLarge InstanceType = "r3.large"
R3InstanceXLarge InstanceType = "r3.xlarge"
R3Instance2XLarge InstanceType = "r3.2xlarge"
R3Instance4XLarge InstanceType = "r3.4xlarge"
R3Instance8XLarge InstanceType = "r3.8xlarge"
// ACCELERATED COMPUTING INSTANCES:
// P2: Instance InstanceType =s are intended for general-purpose GPU compute applications.
P2InstanceXLarge InstanceType = "p2.xlarge"
P2Instance8XLarge InstanceType = "p2.8xlarge"
P2Instance16XLarge InstanceType = "p2.16xlarge"
// G2: Instances are optimized for graphics-intensive applications.
G2Instance2XLarge InstanceType = "g2.2xlarge"
G2Instance8XLarge InstanceType = "g2.8xlarge"
// F1: Instances offer customizable hardware acceleration with field programmable gate arrays (FPGAs).
F1Instance2XLarge InstanceType = "f1.2xlarge"
F1Instance16XLarge InstanceType = "f1.16xlarge"
// STORAGE OPTIMIZED:
// I3: This family includes the High Storage Instances that provide Non-Volatile Memory Express (NVMe) SSD backed
// instance storage optimized for low latency, very high random I/O performance, high sequential read throughput and
// provide high IOPS at a low cost.
I3InstanceLarge InstanceType = "i3.large"
I3InstanceXLarge InstanceType = "i3.xlarge"
I3Instance2XLarge InstanceType = "i3.2xlarge"
I3Instance4XLarge InstanceType = "i3.4xlarge"
I3Instance8XLarge InstanceType = "i3.8xlarge"
I3Instance16XLarge InstanceType = "i3.16xlarge"
// D2: Instances feature up to 48 TB of HDD-based local storage, deliver high disk throughput, and offer the lowest
// price per disk throughput performance on Amazon EC2.
D2InstanceXLarge InstanceType = "d2.xlarge"
D2Instance2XLarge InstanceType = "d2.2xlarge"
D2Instance4XLarge InstanceType = "d2.4xlarge"
D2Instance8XLarge InstanceType = "d2.8xlarge"
)

13
lib/aws/idl/ec2/internetGateway.go
View file

@ -1,13 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package ec2
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// An Internet gateway enables your instances to connect to the Internet through the Amazon EC2 edge network. See
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-internet-gateway.html.
type InternetGateway struct {
idl.NamedResource
}

23
lib/aws/idl/ec2/route.go
View file

@ -1,23 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package ec2
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// Route in a route table within a VPC. For more information, see
// https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route.html.
type Route struct {
idl.NamedResource
// The CIDR address block used for the destination match. For example, `0.0.0.0/0`. Routing decisions are based
// on the most specific match.
DestinationCidrBlock string `lumi:"destinationCidrBlock,replaces"`
// The route table where the route will be added.
RouteTable *RouteTable `lumi:"routeTable,replaces"`
// The Internet gateway that is attached to your VPC. For route entries that specify a gateway, you must also
// specify a dependency on the gateway attachment resource (`vpcGatewayAttachment`).
InternetGateway *InternetGateway `lumi:"internetGateway,replaces"`
// The gateway attachment resource that attached the specified gateway to the VPC.
VPCGatewayAttachment *VPCGatewayAttachment `lumi:"vpcGatewayAttachment,replaces"`
}

16
lib/aws/idl/ec2/routeTable.go
View file

@ -1,16 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package ec2
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// RouteTable is a route table within your VPC. After creating a route table, you can add routes and associate the
// table with a subnet. For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-route-table.html.
type RouteTable struct {
idl.NamedResource
// The VPC where the route table will be created.
VPC *VPC `lumi:"vpc,replaces"`
}

41
lib/aws/idl/ec2/securityGroup.go
View file

@ -1,41 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package ec2
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// A SecurityGroup is an Amazon EC2 Security Group. For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-security-group.html.
type SecurityGroup struct {
idl.NamedResource
// A required description about the security group.
GroupDescription string `lumi:"groupDescription,replaces"`
// An optional name for the security group. If you don't specify one, a unique physical ID will be generated and
// used instead. If you specify a name, you cannot perform updates that require replacement of this resource. You
// can perform updates that require no or some interruption. If you must replace the resource, specify a new name.
GroupName *string `lumi:"groupName,optional,replaces"`
// The VPC in which this security group resides (or blank if the default VPC).
VPC *VPC `lumi:"vpc,optional,replaces"`
// A list of Amazon EC2 security group egress rules.
SecurityGroupEgress *[]SecurityGroupRule `lumi:"securityGroupEgress,optional"`
// A list of Amazon EC2 security group ingress rules.
SecurityGroupIngress *[]SecurityGroupRule `lumi:"securityGroupIngress,optional"`
// The group ID of the specified security group, such as `sg-94b3a1f6`.
GroupID string `lumi:"groupID,out"`
}
// A SecurityGroupRule describes an EC2 security group rule embedded within a SecurityGroup.
type SecurityGroupRule struct {
// The IP name or number.
IPProtocol string `lumi:"ipProtocol"`
// Specifies a CIDR range.
CIDRIP *string `lumi:"cidrIp,optional"`
// The start of port range for the TCP and UDP protocols, or an ICMP type number. An ICMP type number of `-1`
// indicates a wildcard (i.e., any ICMP type number).
FromPort *float64 `lumi:"fromPort,optional"`
// The end of port range for the TCP and UDP protocols, or an ICMP code. An ICMP code of `-1` indicates a
// wildcard (i.e., any ICMP code).
ToPort *float64 `lumi:"toPort,optional"`
}

31
lib/aws/idl/ec2/securityGroupEgress.go
View file

@ -1,31 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package ec2
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// SecurityGroupEgress adds an egress (outbound) rule to an Amazon VPC security group. For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-security-group-egress.html.
type SecurityGroupEgress struct {
idl.NamedResource
// Start of port range for the TCP and UDP protocols, or an ICMP type number. If you specify `icmp` for the
// `ipProtocol` property, you can specify `-1` as a wildcard (i.e., any ICMP type number).
FromPort float64 `lumi:"fromPort,replaces"`
// The Amazon VPC security group to modify.
Group *SecurityGroup `lumi:"group,replaces"`
// IP protocol name or number.
IPProtocol string `lumi:"ipProtocol,replaces"`
// End of port range for the TCP and UDP protocols, or an ICMP code. If you specify `icmp` for the `ipProtocol`
// property, you can specify `-1` as a wildcard (i.e., any ICMP code).
ToPort float64 `lumi:"toPort,replaces"`
// An IPv4 CIDR range.
CIDRIP *string `lumi:"cidrIp,replaces,optional"`
// An IPv6 CIDR range.
CIDRIPv6 *string `lumi:"cidrIpv6,replaces,optional"`
// The AWS service prefix of an Amazon VPC endpoint.
DestinationPrefixListId *string `lumi:"destinationPrefixListId,replaces,optional"`
// Specifies the group ID of the destination Amazon VPC security group.
DestinationSecurityGroup *SecurityGroup `lumi:"destinationSecurityGroup,replaces,optional"`
}

39
lib/aws/idl/ec2/securityGroupIngress.go
View file

@ -1,39 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package ec2
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// SecurityGroupIngress dds an ingress (inbound) rule to an Amazon VPC security group. For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-security-group-ingress.html.
type SecurityGroupIngress struct {
idl.NamedResource
// IP protocol name or number.
IPProtocol string `lumi:"ipProtocol,replaces"`
// An IPv4 CIDR range.
CIDRIP *string `lumi:"cidrIp,replaces,optional"`
// An IPv6 CIDR range.
CIDRIPv6 *string `lumi:"cidrIpv6,replaces,optional"`
// Start of port range for the TCP and UDP protocols, or an ICMP type number. If you specify `icmp` for the
// `ipProtocol` property, you can specify `-1` as a wildcard (i.e., any ICMP type number).
FromPort *float64 `lumi:"fromPort,replaces,optional"`
// The Amazon VPC security group to modify.
Group *SecurityGroup `lumi:"group,replaces,optional"`
// Name of the Amazon EC2 security group (non-VPC security group) to modify.
GroupName *string `lumi:"groupName,replaces,optional"`
// Specifies the ID of the source security group or uses the Ref intrinsic function to refer to the logical ID of a
// security group defined in the same template.
SourceSecurityGroup *SecurityGroup `lumi:"sourceSecurityGroup,replaces,optional"`
// Specifies the name of the Amazon EC2 security group (non-VPC security group) to allow access or uses the Ref
// intrinsic function to refer to the logical name of a security group defined in the same template. For instances
// in a VPC, specify the SourceSecurityGroupId property.
SourceSecurityGroupName *string `lumi:"sourceSecurityGroupName,replaces,optional"`
// Specifies the AWS Account ID of the owner of the Amazon EC2 security group specified in the
// SourceSecurityGroupName property.
SourceSecurityGroupOwnerId *string `lumi:"sourceSecurityGroupOwnerId,replaces,optional"`
// End of port range for the TCP and UDP protocols, or an ICMP code. If you specify `icmp` for the `ipProtocol`
// property, you can specify `-1` as a wildcard (i.e., any ICMP code).
ToPort *float64 `lumi:"toPort,replaces,optional"`
}

21
lib/aws/idl/ec2/subnet.go
View file

@ -1,21 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package ec2
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// Subnet is a subnet in an existing VPC. For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-subnet.html.
type Subnet struct {
idl.NamedResource
// The CIDR block that you want the subnet to cover (for example, `"10.0.0.0/24"`).
CIDRBlock string `lumi:"cidrBlock,replaces"`
// The VPC on which you want to create the subnet.
VPC *VPC `lumi:"vpc,replaces"`
// The availability zone in which you want the subnet. By default, AWS selects a zone for you.
AvailabilityZone *string `lumi:"availabilityZone,replaces,optional"`
// Indicates whether instances that are launched in this subnet receive a public IP address. By default, `false`.
MapPublicIpOnLaunch *bool `lumi:"mapPublicIpOnLaunch,optional"`
}

37
lib/aws/idl/ec2/vpc.go
View file

@ -1,37 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package ec2
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// VPC is a Virtual Private Cloud with a specified CIDR block. For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html.
type VPC struct {
idl.NamedResource
// The CIDR block you want the VPC to cover. For example, "10.0.0.0/16".
CIDRBlock string `lumi:"cidrBlock,replaces"`
// The allowed tenancy of instances launched into the VPC. "default" indicates that instances can be launched with
// any tenancy, while "dedicated" indicates that any instance launched into the VPC automatically has dedicated
// tenancy, unless you launch it with the default tenancy.
InstanceTenancy *InstanceTenancy `lumi:"instanceTenancy,optional,replaces"`
// Specifies whether DNS resolution is supported for the VPC. If true, the Amazon DNS server resolves DNS hostnames
// for your instances to their corresponding IP addresses; otherwise, it does not. By default, the value is true.
EnableDNSSupport *bool `lumi:"enableDnsSupport,optional"`
// Specifies whether the instances launched in the VPC get DNS hostnames. If this attribute is true, instances in
// the VPC get DNS hostnames; otherwise, they do not. You can only set enableDnsHostnames to true if you also set
// the enableDnsSupport property to true. By default, the value is set to false.
EnableDNSHostnames *bool `lumi:"enableDnsHostnames,optional"`
}
type InstanceTenancy string
const (
// Your instance runs on shared hardware.
DefaultTenancy InstanceTenancy = "default"
// Your instance runs on single-tenant hardware.
DedicatedTenancy InstanceTenancy = "dedicated"
// Your instance runs on a Dedicated Host, which is an isolated server with configurations that you can control.
HostTenancy InstanceTenancy = "host"
)

17
lib/aws/idl/ec2/vpcGatewayAttachment.go
View file

@ -1,17 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package ec2
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// VPCGatewayAttachment attaches a gateway to a VPC. For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc-gateway-attachment.html.
type VPCGatewayAttachment struct {
idl.NamedResource
// The VPC to associate with this gateway.
VPC *VPC `lumi:"vpc,replaces"`
// The Internet gateway to attach to the VPC.
InternetGateway *InternetGateway `lumi:"internetGateway,replaces"`
}

18
lib/aws/idl/ec2/vpcPeeringConnection.go
View file

@ -1,18 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package ec2
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// VPCPeeringConnection enables a network connection between two virtual private clouds (VPCs) so that you can route
// traffic between them by means of a private IP addresses. For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcpeeringconnection.html.
type VPCPeeringConnection struct {
idl.NamedResource
// The VPC with which you are creating the peering connection.
PeerVPC *VPC `lumi:"peerVpc,replaces"`
// The VPC that is requesting a peering connection.
VPC *VPC `lumi:"vpc,replaces"`
}

17
lib/aws/idl/elasticbeanstalk/application.go
View file

@ -1,17 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package elasticbeanstalk
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// Application is an Elastic Beanstalk application. For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-beanstalk-environment.html.
type Application struct {
idl.NamedResource
// ApplicationName is a name for the application. If you don't specify a name, a unique physical ID is used instead.
ApplicationName *string `lumi:"applicationName,optional,replaces"`
// An optional description of this application.
Description *string `lumi:"description,optional"`
}

26
lib/aws/idl/elasticbeanstalk/applicationVersion.go
View file

@ -1,26 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package elasticbeanstalk
import (
"github.com/pulumi/lumi/lib/aws/idl/s3"
"github.com/pulumi/lumi/pkg/resource/idl"
)
// ApplicationVersion is an application version, an iteration of deployable code, for an Elastic Beanstalk application.
// For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-beanstalk-environment.html.
type ApplicationVersion struct {
idl.NamedResource
// Name of the Elastic Beanstalk application that is associated with this application version.
Application *Application `lumi:"application,replaces"`
// An optional version label name. If you don't specify one, a unique physical ID will be generated and
// used instead. If you specify a name, you cannot perform updates that require replacement of this resource. You
// can perform updates that require no or some interruption. If you must replace the resource, specify a new name.
VersionLabel *string `lumi:"versionLabel,optional,replaces"`
// A description of this application version.
Description *string `lumi:"description,optional"`
// The source bundle for this application version. This supports all the usual Lumi asset schemes, in addition
// to Amazon Simple Storage Service (S3) bucket locations, indicating with a URI scheme of s3//<bucket>/<object>.
SourceBundle *s3.Object `lumi:"sourceBundle,replaces"`
}

78
lib/aws/idl/elasticbeanstalk/environment.go
View file

@ -1,78 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package elasticbeanstalk
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// ApplicationVersion is an application version, an iteration of deployable code, for an Elastic Beanstalk application.
// For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-beanstalk-environment.html.
type Environment struct {
idl.NamedResource
// The name of the application that is associated with this environment.
Application *Application `lumi:"application,replaces"`
// A prefix for your Elastic Beanstalk environment URL.
CNAMEPrefix *string `lumi:"cnamePrefix,optional,replaces"`
// A description that helps you identify this environment.
Description *string `lumi:"description,optional"`
// A name for the Elastic Beanstalk environment.
EnvironmentName *string `lumi:"environmentName,optional,replaces"`
// Key-value pairs defining configuration options for this environment, such as the instance type. These options
// override the values that are defined in the solution stack or the configuration template. If you remove any
// options during a stack update, the removed options revert to default values.
OptionSettings *[]OptionSetting `lumi:"optionSettings,optional"`
// The name of an Elastic Beanstalk solution stack that this configuration will use. For more information, see
// http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/concepts.platforms.html. You must specify either this
// parameter or an Elastic Beanstalk configuration template name.
SolutionStackName *string `lumi:"solutionStackName,optional,replaces"`
// An arbitrary set of tags (key–value pairs) for this environment.
Tags *[]Tag `lumi:"tags,optional,replaces"`
// The name of the Elastic Beanstalk configuration template to use with the environment. You must specify either
// this parameter or a solution stack name.
TemplateName *string `lumi:"templateName,optional"`
// Specifies the tier to use in creating this environment. The environment tier that you choose determines whether
// Elastic Beanstalk provisions resources to support a web application that handles HTTP(S) requests or a web
// application that handles background-processing tasks.
Tier *Tier `lumi:"tier,optional,replaces"`
// The version to associate with the environment.
Version *ApplicationVersion `lumi:"version,optional"`
// The URL to the load balancer for this environment.
EndpointURL string `lumi:"endpointURL,out"`
// Key-value pairs defining all of the configuration options for this environment, including both values provided
// in the OptionSettings input, as well as settings with default values.
AllOptionSettings *[]OptionSetting `lumi:"allOptionSettings,out"`
}
// OptionSetting specifies options for an Elastic Beanstalk environment.
type OptionSetting struct {
// A unique namespace identifying the option's associated AWS resource. For a list of namespaces that you can use,
// see http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/command-options.html.
Namespace string `lumi:"namespace"`
// The name of the configuration option. For a list of options that you can use, see
// http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/command-options.html.
OptionName string `lumi:"optionName"`
// The value of the setting.
Value string `lumi:"value"`
}
// A Tag helps to identify and categorize resources.
type Tag struct {
// The key name of the tag. You can specify a value that is 1 to 127 Unicode characters in length and cannot be
// prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace,
// _, ., /, =, +, and -.
Key string `lumi:"key"`
// The value for the tag. You can specify a value that is 1 to 255 Unicode characters in length and cannot be
// prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace,
// _, ., /, =, +, and -.
Value string `lumi:"value"`
}
// The Tier for an Elastic Beanstalk Environment.
type Tier string
const (
WebServerTier Tier = "WebServer::Standard::1.0"
WorkerTier Tier = "Worker::SQS/HTTP::1.0"
)

29
lib/aws/idl/iam/group.go
View file

@ -1,29 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package iam
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// Group is an AWS Identity and Access Management (IAM) group.
type Group struct {
idl.NamedResource
// groupName is a name for the IAM group. If you don't specify a name, a unique physical ID will be generated.
//
// Important: if you specify a name, you cannot perform updates that require replacement of this resource. You can
// perform updates that require no or some interruption. If you must replace this resource, specify a new name.
//
// If you specify a new name, you must specify the `CAPABILITY_NAMED_IAM` value to acknowledge your capabilities.
//
// Warning: Naming an IAM resource can cause an unrecoverable error if you reuse the same code in multiple regions.
// To prevent this, create a name that includes the region name itself, to create a region-specific name.
GroupName *string `lumi:"groupName,replaces,optional"`
// managedPolicies is one or more managed policies to attach to this role.
ManagedPolicies *[]*Policy `lumi:"managedPolicies,optional"`
// path is the path associated with this role. For more information about paths, see
// http://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html#Identifiers_FriendlyNames.
Path *string `lumi:"path,optional"`
// policies are the policies to associate with this role.
Policies *InlinePolicy `lumi:"policies,optional"`
}

28
lib/aws/idl/iam/instanceprofile.go
View file

@ -1,28 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package iam
import (
aws "github.com/pulumi/lumi/lib/aws/idl"
"github.com/pulumi/lumi/pkg/resource/idl"
)
// InstanceProfile is an AWS Identity and Access Management (IAM) instance profile. Use an IAM instance profile to
// enable applications running on an EC2 instance to securely access your AWS resources. For more information about
// IAM instance profiles, see
// http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html.
type InstanceProfile struct {
idl.NamedResource
// Path is the path associated with this instance profile. For more information about paths, see
// http://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html#Identifiers_FriendlyNames.
Path *string `lumi:"path,replaces,optional"`
// The name of the instance profile that you want to create. This parameter allows a string consisting of upper and
// lowercase alphanumeric characters with no spaces. You can also include any of the following characters: = , . @ -.
InstanceProfileName *string `lumi:"instanceProfileName,replaces,optional"`
// The name of an existing IAM role to associate with this instance profile. Currently, you can assign a maximum
// of one role to an instance profile.
Roles []*Role `lumi:"roles"`
// The Amazon Resource Name (ARN) for the instance profile. For example,
// `arn:aws:iam::1234567890:instance-profile/MyProfile-ASDNSDLKJ`.
ARN aws.ARN `lumi:"arn,out"`
}

33
lib/aws/idl/iam/policy.go
View file

@ -1,33 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package iam
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// Policy associates an IAM policy with IAM users, roles, or groups. For more information about IAM
// policies, see http://docs.aws.amazon.com/IAM/latest/UserGuide/policies_overview.html.
type Policy struct {
idl.NamedResource
// PolicyDocument is a policy document that contains permissions to add to the specified users, roles, or groups.
PolicyDocument interface{} `lumi:"policyDocument"` // IDEA: schematize this.
// PolicyName is the name of the policy. If you specify multiple policies for an entity, specify unique names. For
// example, if you specify a list of policies for an IAM role, each policy must have a unique name.
PolicyName string `lumi:"policyName"`
// Groups are the groups to which you want to add this policy.
Groups *[]*Group `lumi:"groups,optional"`
// Roles are the roles to which you want to attach this policy.
Roles *[]*Role `lumi:"roles,optional"`
// Users are the users for whom you want to add this policy.
Users *[]*User `lumi:"users,optional"`
}
// InlinePolicies are attached to Policies, Groups, and User resources, to describe what actions are allowed on them.
// For more information on policies, please see http://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html.
type InlinePolicy struct {
// PolicyDocument is a policy document that describes what actions are allowed on which resources.
PolicyDocument interface{} `lumi:"policyDocument"` // IDEA: schematize this.
// PolicyName is the unique name of the policy.
PolicyName string `lumi:"policyName"`
}

37
lib/aws/idl/iam/role.go
View file

@ -1,37 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package iam
import (
aws "github.com/pulumi/lumi/lib/aws/idl"
"github.com/pulumi/lumi/pkg/resource/idl"
)
// Role is an AWS Identity and Access Management (IAM) role. Use an IAM role to enable applications running on an EC2
// instance to securely access your AWS resources. For more information about IAM roles, see
// http://docs.aws.amazon.com/IAM/latest/UserGuide/WorkingWithRoles.html.
type Role struct {
idl.NamedResource
// AssumeRolePolicyDocument is the trust policy associated with this role.
AssumeRolePolicyDocument interface{} `lumi:"assumeRolePolicyDocument"` // IDEA: schematize this.
// Path is the path associated with this role. For more information about paths, see
// http://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html#Identifiers_FriendlyNames.
Path *string `lumi:"path,replaces,optional"`
// RoleName is a name for the IAM role. If you don't specify a name, a unique physical ID will be generated.
//
// Important: If you specify a name, you cannot perform updates that require replacement of this resource. You can
// perform updates that require no or some interruption. If you must replace the resource, specify a new name.
//
// If you specify a name, you must specify the `CAPABILITY_NAMED_IAM` value to acknowledge these capabilities.
//
// Warning: Naming an IAM resource can cause an unrecoverable error if you reuse the same code in multiple regions.
// To prevent this, create a name that includes the region name itself, to create a region-specific name.
RoleName *string `lumi:"roleName,replaces,optional"`
// managedPolicies is one or more managed policies to attach to this role.
ManagedPolicyARNs *[]aws.ARN `lumi:"managedPolicyARNs,optional"`
// Policies are the policies to associate with this role.
Policies *[]InlinePolicy `lumi:"policies,optional"`
// The Amazon Resource Name (ARN) for the instance profile. For example,
// `arn:aws:iam::1234567890:role/MyRole-AJJHDSKSDF`.
ARN aws.ARN `lumi:"arn,out"`
}

41
lib/aws/idl/iam/user.go
View file

@ -1,41 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package iam
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// The User resource creates an AWS Identity and Access Management (IAM) user.
type User struct {
idl.NamedResource
// UserName is a name for the IAM group. If you don't specify a name, a unique physical ID will be generated.
//
// Important: if you specify a name, you cannot perform updates that require replacement of this resource. You can
// perform updates that require no or some interruption. If you must replace this resource, specify a new name.
//
// If you specify a new name, you must specify the `CAPABILITY_NAMED_IAM` value to acknowledge your capabilities.
//
// Warning: Naming an IAM resource can cause an unrecoverable error if you reuse the same code in multiple regions.
// To prevent this, create a name that includes the region name itself, to create a region-specific name.
UserName *string `lumi:"userName,replaces,optional"`
// Groups is a list of groups to which you want to add the user.
Groups *[]*Group `lumi:"groups,optional"`
// LoginProfile creates a login profile so that the user can access the AWS Management Console.
LoginProfile *LoginProfile `lumi:"loginProfile,optional"`
// ManagedPolicies is one or more managed policies to attach to this role.
ManagedPolicies *[]*Policy `lumi:"managedPolicies,optional"`
// Path is the path associated with this role. For more information about paths, see
// http://docs.aws.amazon.com/IAM/latest/UserGuide/Using_Identifiers.html#Identifiers_FriendlyNames.
Path *string `lumi:"path,optional"`
// Policies are the policies to associate with this role.
Policies *[]InlinePolicy `lumi:"policies,optional"`
}
type LoginProfile struct {
// Password is the password for the user.
Password string `lumi:"password"`
// PasswordResetRequired specifies whether the user is required to set a new password the next time the user logs
// into the AWS Management Console.
PasswordResetRequired *bool `lumi:"passwordResetRequired,optional"`
}

25
lib/aws/idl/kms/key.go
View file

@ -1,25 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package kms
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// The Key resource creates a customer master key (CMK) in AWS Key Management Service (AWS KMS). Users (customers) can
// use the master key to encrypt their data stored in AWS services that are integrated with AWS KMS or within their
// applications. For more information, see http://docs.aws.amazon.com/kms/latest/developerguide/.
type Key struct {
idl.NamedResource
// KeyPolicy attaches a KMS policy to this key. Use a policy to specify who has permission to use the key and which
// actions they can perform. For more information, see
// http://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html.
KeyPolicy interface{} `lumi:"keyPolicy"` // IDEA: schematize this.
// Description is an optional description of the key. Use a description that helps your users decide whether the
// key is appropriate for a particular task.
Description *string `lumi:"description,optional"`
// Enabled indicates whether the key is available for use. This value is `true` by default.
Enabled *bool `lumi:"enabled,optional"`
// EnableKeyRotation indicates whether AWS KMS rotates the key. This value is `false` by default.
EnableKeyRotation *bool `lumi:"enableKeyRotation,optional"`
}

106
lib/aws/idl/lambda/function.go
View file

@ -1,106 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package lambda
import (
"github.com/pulumi/lumi/pkg/resource/idl"
aws "github.com/pulumi/lumi/lib/aws/idl"
"github.com/pulumi/lumi/lib/aws/idl/ec2"
"github.com/pulumi/lumi/lib/aws/idl/iam"
"github.com/pulumi/lumi/lib/aws/idl/kms"
)
// The Function resource creates an AWS Lambda function that can run code in response to events.
type Function struct {
idl.NamedResource
// code is the source code of your Lambda function. This supports all the usual Lumi asset schemes, in addition
// to Amazon Simple Storage Service (S3) bucket locations, indicating with a URI scheme of s3//<bucket>/<object>.
Code *idl.Archive `lumi:"code"`
// handler is the name of the function (within your source code) that Lambda calls to start running your code.
Handler string `lumi:"handler"`
// role is the AWS Identity and Access Management (IAM) execution role that Lambda assumes when it runs your code
// to access AWS services.
Role *iam.Role `lumi:"role"`
// runtime is the runtime environment for the Lambda function that you are uploading.
Runtime Runtime `lumi:"runtime"`
// functionName is a name for the function. If you don't specify a name, a unique physical ID is used instead.
FunctionName *string `lumi:"functionName,optional"`
// deadLetterConfig configures how Lambda handles events that it can't process. If you don't specify a Dead Letter
// Queue (DLQ) configuration, Lambda discards events after the maximum number of retries.
DeadLetterConfig *DeadLetterConfig `lumi:"deadLetterConfig,optional"`
// description is an optional description of the function.
Description *string `lumi:"description,optional"`
// environment contains key-value pairs that Lambda caches and makes available for your Lambda functions. Use
// environment variables to apply configuration changes, such as test and production environment configurations,
// without changing your Lambda function source code.
Environment *Environment `lumi:"environment,optional"`
// kmsKey is a AWS Key Management Service (AMS KMS) key that Lambda uses to encrypt and decrypt environment
// variables.
KMSKey *kms.Key `lumi:"kmsKey,optional"`
// memorySize is the amount of memory, in MB, that is allocated to your Lambda function. Lambda uses this value to
// proportionally allocate the amount of CPU power. Your function use case determines your CPU and memory
// requirements. For example, a database operation might need less memory than an image processing function. You
// must specify a value that is greater than or equal to `128` and it must be a multiple of `64`. You cannot
// specify a size larger than `1536`. The default value is `128` MB.
MemorySize *float64 `lumi:"memorySize,optional"`
// timeout is the function execution time (in seconds) after which Lambda terminates the function. Because the
// execution time affects cost, set this value based on the function's expected execution time. By default, timeout
// is set to `3` seconds.
Timeout *float64 `lumi:"timeout,optional"`
// vpcConfig specifies a VPC configuration that Lambda uses to set up an elastic network interface (ENI). The ENI
// enables your function to connect to other resources in your VPC, but it doesn't provide public Internet access.
// If your function requires Internet access (for example, to access AWS services that don't have VPC endpoints),
// configure a Network Address Translation (NAT) instance inside your VPC or use an Amazon Virtual Private Cloud
// (Amazon VPC) NAT gateway.
VPCConfig *VPCConfig `lumi:"vpcConfig,optional"`
// The ARN of the Lambda function, such as `arn:aws:lambda:us-west-2:123456789012:MyStack-AMILookUp-NT5EUXTNTXXD`.
ARN aws.ARN `lumi:"arn,out"`
// version is the latest published version of the Lambda function.
Version string `lumi:"version,out"`
// codeSHA256 is the base64-encoded SHA-256 hash of the source code zip file for the Lambda function.
CodeSHA256 string `lumi:"codeSHA256,out"`
// lastModified is the date the Lambda function was last modified.
LastModified string `lumi:"lastModified,out"`
}
// Runtime represents the legal runtime environments for Lambdas.
type Runtime string
const (
NodeJSRuntime Runtime = "nodejs"
NodeJS4d3Runtime Runtime = "nodejs4.3"
NodeJS4d3EdgeRuntime Runtime = "nodejs4.3-edge"
NodeJS6d10Runtime Runtime = "nodejs6.10"
Java8Runtime Runtime = "java8"
Python2d7Runtime Runtime = "python2.7"
DotnetCore1d0Runtime Runtime = "dotnetcore1.0"
)
// DeadLetterConfig is a property of an AWS Lambda Function resource that specifies a Dead Letter Queue (DLQ) that
// events are sent to when functions cannot be processed. For example, you can send unprocessed events to an Amazon
// Simple Notification Service (Amazon SQS) topic, where you can take further action.
type DeadLetterConfig struct {
// The Target resource where Lambda delivers unprocessed events. It may be an Amazon SNS topic or Amazon
// Simple Queue Service (SQS) queue. For the Lambda function-execution role, you must explicitly provide the
// relevant permissions so that access to your DLQ resource is part of the execution role for your Lambda function.
Target *idl.Resource `lumi:"target"` // IDEA: use union types to represent `sns.Topic | sqs.Queue`;
}
// Environment is a property of an AWS Lambda Function resource that specifies key-value pairs that the function can
// access so that you can apply configuration changes, such as test and production environment configurations, without
// changing the function code.
type Environment map[string]string
// VPCConfig is a property of an AWS Lambda Function resource that enables it to access resources in a VPC. For more
// information, see http://docs.aws.amazon.com/lambda/latest/dg/vpc.html.
type VPCConfig struct {
// securityGroups is a list of one or more security groups in the VPC that include the resources to which your
// Lambda function requires access.
SecurityGroups []*ec2.SecurityGroup `lumi:"securityGroups"`
// subnets is a list of one or more subnet IDs in the VPC that includes the resources to which your Lambda function
// requires access.
Subnets []*ec2.Subnet `lumi:"subnets"`
}

36
lib/aws/idl/lambda/permission.go
View file

@ -1,36 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package lambda
import (
"github.com/pulumi/lumi/pkg/resource/idl"
aws "github.com/pulumi/lumi/lib/aws/idl"
)
// The Permission resource associates a policy statement with a specific AWS Lambda function's access policy. The
// function policy grants a specific AWS service or application permission to invoke the function. For more
// information, see http://docs.aws.amazon.com/lambda/latest/dg/API_AddPermission.html.
type Permission struct {
idl.NamedResource
// The Lambda actions that you want to allow in this statement. For example, you can specify lambda:CreateFunction
// to specify a certain action, or use a wildcard (lambda:*) to grant permission to all Lambda actions. For a list
// of actions, see http://docs.aws.amazon.com/IAM/latest/UserGuide/list_lambda.html.
Action string `lumi:"action,replaces"`
// The Lambda function that you want to associate with this statement.
Function *Function `lumi:"function,replaces"`
// The entity for which you are granting permission to invoke the Lambda function. This entity can be any valid AWS
// service principal, such as `s3.amazonaws.com` or `sns.amazonaws.com`, or, if you are granting cross-account
// permission, an AWS account ID. For example, you might want to allow a custom application in another AWS account
// to push events to Lambda by invoking your function.
Principal string `lumi:"principal,replaces"`
// The AWS account ID (without hyphens) of the source owner. For example, if you specify an S3 bucket in the
// sourceARN property, this value is the bucket owner's account ID. You can use this property to ensure that all
// source principals are owned by a specific account.
SourceAccount *string `lumi:"sourceAccount,replaces,optional"`
// The ARN of a resource that is invoking your function. When granting Amazon Simple Storage Service (Amazon S3)
// permission to invoke your function, specify this property with the bucket ARN as its value. This ensures that
// events generated only from the specified bucket, not just any bucket from any AWS account that creates a mapping
// to your function, can invoke the function.
SourceARN *aws.ARN `lumi:"sourceARN,replaces,optional"`
}

25
lib/aws/idl/s3/acl.go
View file

@ -1,25 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package s3
// CannedACL is a predefined Amazon S3 grant. Each canned ACL value has a predefined set of grantees and permissions.
type CannedACL string
const (
// Owner gets `FULL_CONTROL`. Noone else has access rights (default).
PrivateACL CannedACL = "private"
// Owner gets `FULL_CONTROL`. The `AllUsers` group gets `READ` access.
PublicReadACL CannedACL = "public-read"
// Owner gets `FULL_CONTROL`. The `AllUsers` group gets `READ` and `WRITE` access.
PublicReadWriteACL CannedACL = "public-read-write"
// Owner gets `FULL_CONTROL`. Amazon EC2 gets `READ` access to `GET` an AMI bundle.
AWSExecReadACL CannedACL = "aws-exec-read"
// Owner gets `FULL_CONTROL`. The `AuthenticatedUsers` group gets `READ` access.
AuthenticatedReadACL CannedACL = "authenticated-read"
// Object owner gets `FULL_CONTROL`. Bucket owner gets `READ` access.
BucketOwnerReadACL CannedACL = "bucket-owner-read"
// Both object and bucket owner get `FULL_CONTROL` over the object.
BucketOwnerFullControlACL CannedACL = "bucket-owner-full-control"
// The `LogDelivery` group gets `WRITE` and `READ_ACP` permissions on this bucket.
LogDeliveryWriteACL CannedACL = "log-delivery-write"
)

18
lib/aws/idl/s3/bucket.go
View file

@ -1,18 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package s3
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// Bucket represents an Amazon Simple Storage Service (Amazon S3) bucket.
// TODO[pulumi/lumi#218]: support all the various configuration settings (CORS, lifecycle, logging, and so on).
type Bucket struct {
idl.NamedResource
// BucketName is a name for the bucket. If you don't specify a name, a unique physical ID is generated. The name
// must contain only lowercase letters, numbers, periods (`.`), and dashes (`-`).
BucketName *string `lumi:"bucketName,replaces,optional"`
// accessControl is a canned access control list (ACL) that grants predefined permissions to the bucket.
AccessControl *CannedACL `lumi:"accessControl,optional"`
}

33
lib/aws/idl/s3/object.go
View file

@ -1,33 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package s3
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// Object represents an Amazon Simple Storage Service (S3) object (key/value blob).
type Object struct {
idl.Resource
// The Key that uniquely identifies this object.
Key string `lumi:"key,replaces"`
// The Bucket this object belongs to.
Bucket *Bucket `lumi:"bucket,replaces"`
// The Source of content for this object.
Source *idl.Asset `lumi:"source,in"`
// A standard MIME type describing the format of the object data.
ContentType *string `lumi:"contentType,optional"`
// Specifies presentational information for the object.
ContentDisposition *string `lumi:"contentDisposition,optional"`
// Specifies caching behavior along the request/reply chain.
CacheControl *string `lumi:"cacheControl,optional"`
// Specifies what content encodings have been applied to the object and thus
// what decoding mechanisms must be applied to obtain the media-type referenced
// by the Content-Type header field.
ContentEncoding *string `lumi:"contentEncoding,optional"`
// The language the content is in.
ContentLanguage *string `lumi:"contentLanguage,optional"`
// Size of the body in bytes. This parameter is useful when the size of the
// body cannot be determined automatically.
ContentLength *float64 `lumi:"contentLength,optional"`
}

33
lib/aws/idl/sns/subscription.go
View file

@ -1,33 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package sns
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// An Amazon Simple Notification Service (Amazon SNS) topic subscription. For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sns-subscription.html.
type Subscription struct {
idl.NamedResource
// A name for the topic. If you don't specify a name, a unique physical ID will be generated.
Topic *Topic `lumi:"topic,replaces"`
// The subscription's protocol.
Protocol Protocol `lumi:"protocol,replaces"`
// The subscription's endpoint (format depends on the protocol).
Endpoint string `lumi:"endpoint,replaces"`
}
// The protocols supported by the Amazon Simple Notification Service (Amazon SNS).
type Protocol string
const (
HTTSubscription Protocol = "http" // delivery of JSON-encoded message via HTTP POST.
HTTPSSubscription Protocol = "https" // delivery of JSON-encoded message via HTTPS POST.
EmailSubscription Protocol = "email" // delivery of message via SMTP.
EmailJSONSubscription Protocol = "email-json" // delivery of JSON-encoded message via SMTP.
SMSSubscription Protocol = "sms" // delivery of message via SMS.
SQSSubscription Protocol = "sqs" // delivery of JSON-encoded message to an Amazon SQS queue.
ApplicationSubscription Protocol = "application" // delivery of JSON-encoded message to a mobile app or device.
LambdaSubscription Protocol = "lambda" // delivery of JSON-encoded message to an AWS Lambda function.
)

17
lib/aws/idl/sns/topic.go
View file

@ -1,17 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package sns
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// An Amazon Simple Notification Service (Amazon SNS) topic. For more information, see
// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-sns-topic.html.
type Topic struct {
idl.NamedResource
// A name for the topic. If you don't specify a name, a unique physical ID will be generated.
TopicName *string `lumi:"topicName,replaces,optional"`
// A developer-defined string that can be used to identify this SNS topic.
DisplayName *string `lumi:"displayName,optional"`
}

61
lib/aws/idl/sqs/queue.go
View file

@ -1,61 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package sqs
import (
"github.com/pulumi/lumi/pkg/resource/idl"
)
// The Queue resource creates an Amzon Simple Queue Service (Amazon SQS) queue. For more information about creating
// FIFO (first-in-first-out) queues, see http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/.
type Queue struct {
idl.NamedResource
// FIFOQueue indicates whether this queue is a FIFO queue. The default value is `false`.
FIFOQueue *bool `lumi:"fifoQueue,replaces,optional"`
// queueName is a name for the queue. To create a FIFO queue, the name of your FIFO queue must end with the `.fifo`
// suffix. If you don't specify a name, a unique physical ID will be generated and used.
//
// Important: If you specify a name, you cannot perform updates that require replacement of this resource. You can
// perform updates that require no or some interruption. If you must replace the resource, specify a new name.
QueueName *string `lumi:"queueName,replaces,optional"`
// contentBasedDeduplication, for first-in-first-out (FIFO) queues, specifies whether to enable content-based
// deduplication. During the deduplication interval, Amazon SQS treats messages that are sent with identical
// content as duplicates and delivers only one copy of the message.
ContentBasedDeduplication *bool `lumi:"contentBasedDeduplication,optional"`
// delaySeconds is the time in seconds that the delivery of all messages in the queue is delayed. You can specify
// an integer value of `0` to `900` (15 minutes). The default value is `0`.
DelaySeconds *float64 `lumi:"delaySeconds,optional"`
// maximumMessageSize sets a limit of how many bytes that a message can contain before Amazon SQS rejects it. You
// can specify an integer value from `1024` bytes (1 KiB) to `262144` bytes (256 KiB). The default value is
// `262144` bytes (256 KiB).
MaximumMessageSize *float64 `lumi:"maximumMessageSize,optional"`
// messageRetentionPeriod is the number of seconds that Amazon SQS retains a message. You can specify an integer
// value from `60` seconds (1 minute) to `1209600` seconds (14 days). The default value is `345600` (4 days).
MessageRetentionPeriod *float64 `lumi:"messageRetentionPeriod,optional"`
// receiveMessageWaitTimeSeconds specifies the duration, in seconds, that receiving a message waits until a message
// is in the queue in order to include it in the response, as opposed to returning an empty response if a message is
// not yet available. You can specify an integer from `1` to `20`. The short polling is used as the default
// or when you specify `0` for this property. For more information about SQS Long Polling, see
// http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html.
ReceiveMessageWaitTimeSeconds *float64 `lumi:"receiveMessageWaitTimeSeconds,optional"`
// redrivePolicy specifies an existing dead letter queue to receive messages after the source queue (this queue)
// fails to process a message a specified number of times.
RedrivePolicy *RedrivePolicy `lumi:"redrivePolicy,optional"`
// visibilityTimeout specifies the length of time during which a message will be unavailable after a message is
// delivered from the queue. This blocks other components from receiving the same message and gives the initial
// component time to process and delete the message from the queue.
//
// Values must be from `0` to `43200` seconds (12 hours). The default value if unspecified is `30` seconds.
//
// For more information about Amazon SQS queue visibility timeouts, see Visibility Timeouts in
// http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html.
VisibilityTimeout *float64 `lumi:"visibilityTimeout,optional"`
}
type RedrivePolicy struct {
// deadLetterTarget is the dead letter queue to which the messages are sent after maxReceiveCount has been exceeded.
DeadLetterTarget *Queue `lumi:"deadLetterTarget"`
// maxReceiveCount is the number of times a message is delivered to the source queue before being sent to the dead
// letter queue.
MaxReceiveCount float64 `lumi:"maxReceiveCount"`
}

65
lib/aws/idl/types.go
View file

@ -1,65 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
package aws
// Amazon Resource Names (ARNs) uniquely identify AWS resources. An ARN is required when you need to specify a
// resource unambiguously across all of AWS, such as in IAM policies, Amazon Relational Database Service (Amazon RDS)
// tags, and API calls.
//
// Here are some example ARNs:
//
// * Elastic Beanstalk application version:
// arn:aws:elasticbeanstalk:us-east-1:123456789012:environment/My App/MyEnvironment
// * IAM user name:
// arn:aws:iam::123456789012:user/David
// * Amazon RDS instance used for tagging:
// arn:aws:rds:eu-west-1:123456789012:db:mysql-db
// * Object in an Amazon S3 bucket:
// arn:aws:s3:::my_corporate_bucket/exampleobject.png
//
// The following are the general formats for ARNs; the specific components and values depend on the AWS service:
//
// arn:partition:service:region:account-id:resource
// arn:partition:service:region:account-id:resourcetype/resource
// arn:partition:service:region:account-id:resourcetype:resource
//
// The component parts are:
//
// * `partition`: The partition that the resource is in. For standard AWS regions, the partition is `aws`. If you
// have resources in other partitions, the partition is `aws-partitionname`. For example, the partition for
// resources in the China (Beijing) region is `aws-cn`.
// * `service`: The service namespace that identifies the AWS product (for example, Amazon S3, IAM, or Amazon RDS).
// For a list of namespaces, see
// http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#genref-aws-service-namespaces.
// * `region`: The region the resource resides in. Note that the ARNs for some resources do not require a region,
// so this component might be omitted.
// * `account`: The ID of the AWS account that owns the resource, without the hyphens. For example, 123456789012.
// Note that the ARNs for some resources don't require an account number, so this component might be omitted.
// * `resource`, `resourcetype/resource`, or `resourcetype:resource`: The content of this part of the ARN varies by
// service. It often includes an indicator of the type of resource—for example, an IAM user or Amazon RDS
// database -- followed by a slash (/) or a colon (:), followed by the resource name itself. Some services
// allows paths for resource names, as described in
// http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arns-paths.
//
// For more information on ARNs, please see http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html.
type ARN string
// Region contains all the valid AWS regions in a convenient union type.
type Region string
const (
USEast1Region Region = "us-east-1" // US East (N. Virginia)
USEast2Region Region = "us-east-2" // US East (Ohio)
USWest1Region Region = "us-west-1" // US West (N. California)
USWest2Region Region = "us-west-2" // US West (Oregon)
CACentralRegion Region = "ca-central" // Canada (Central)
APSouth1Region Region = "ap-south-1" // Asia Pacific (Mumbai)
APNortheast1Region Region = "ap-northeast-1" // Asia Pacific (Tokyo)
APNortheast2Region Region = "ap-northeast-2" // Asia Pacific (Seoul)
APSoutheast1Region Region = "ap-southeast-1" // Asia Pacific (Singapore)
APSouthEast2Region Region = "ap-southeast-2" // Asia Pacific (Sydney)
EUCentral1Region Region = "eu-central-1" // EU (Frankfurt)
EUWest1Region Region = "eu-west-1" // EU (Ireland)
EUWest2Region Region = "eu-west-2" // EU (London)
SAEast1Region Region = "sa-east-1" // South America (Sao Paulo)
)

3
lib/aws/pack/.gitignore vendored
View file

@ -1,3 +0,0 @@
.lumi/
node_modules/

6
lib/aws/pack/Lumi.yaml
View file

@ -1,6 +0,0 @@
name: aws
description: A collection of AWS resources as Lumi stacks.
dependencies:
lumi: "*"
lumirt: "*"

32
lib/aws/pack/apigateway/account.ts
View file

@ -1,32 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {Role} from "../iam/role";
export class Account extends lumi.NamedResource implements AccountArgs {
public cloudWatchRole?: Role;
public static get(id: lumi.ID): Account {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Account[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args?: AccountArgs) {
super(name);
if (args !== undefined) {
this.cloudWatchRole = args.cloudWatchRole;
}
}
}
export interface AccountArgs {
cloudWatchRole?: Role;
}

47
lib/aws/pack/apigateway/apiKey.ts
View file

@ -1,47 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {RestAPI} from "./restAPI";
import {Stage} from "./stage";
export class APIKey extends lumi.NamedResource implements APIKeyArgs {
public readonly keyName?: string;
public description?: string;
public enabled?: boolean;
public stageKeys?: StageKey;
public static get(id: lumi.ID): APIKey {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): APIKey[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args?: APIKeyArgs) {
super(name);
if (args !== undefined) {
this.keyName = args.keyName;
this.description = args.description;
this.enabled = args.enabled;
this.stageKeys = args.stageKeys;
}
}
}
export interface APIKeyArgs {
readonly keyName?: string;
description?: string;
enabled?: boolean;
stageKeys?: StageKey;
}
export interface StageKey {
restAPI?: RestAPI;
stage?: Stage;
}

62
lib/aws/pack/apigateway/authorizer.ts
View file

@ -1,62 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {RestAPI} from "./restAPI";
import {Role} from "../iam/role";
export let CognitoAuthorizer: AuthorizerType = "COGNITO_USER_POOLS";
export let TokenAuthorizer: AuthorizerType = "TOKEN";
export class Authorizer extends lumi.NamedResource implements AuthorizerArgs {
public type: AuthorizerType;
public authorizerCredentials?: Role;
public authorizerResultTTLInSeconds?: number;
public authorizerURI?: string;
public identitySource?: string;
public identityValidationExpression?: string;
public providers?: lumi.Resource[];
public restAPI?: RestAPI;
public static get(id: lumi.ID): Authorizer {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Authorizer[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: AuthorizerArgs) {
super(name);
if (lumirt.defaultIfComputed(args.type, "") === undefined) {
throw new Error("Missing required argument 'type'");
}
this.type = args.type;
this.authorizerCredentials = args.authorizerCredentials;
this.authorizerResultTTLInSeconds = args.authorizerResultTTLInSeconds;
this.authorizerURI = args.authorizerURI;
this.identitySource = args.identitySource;
this.identityValidationExpression = args.identityValidationExpression;
this.providers = args.providers;
this.restAPI = args.restAPI;
}
}
export interface AuthorizerArgs {
type: AuthorizerType;
authorizerCredentials?: Role;
authorizerResultTTLInSeconds?: number;
authorizerURI?: string;
identitySource?: string;
identityValidationExpression?: string;
providers?: lumi.Resource[];
restAPI?: RestAPI;
}
export type AuthorizerType =
"COGNITO_USER_POOLS" |
"TOKEN";

46
lib/aws/pack/apigateway/basePathMapping.ts
View file

@ -1,46 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {RestAPI} from "./restAPI";
import {Stage} from "./stage";
export class BasePathMapping extends lumi.NamedResource implements BasePathMappingArgs {
public domainName: string;
public restAPI: RestAPI;
public basePath?: string;
public stage?: Stage;
public static get(id: lumi.ID): BasePathMapping {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): BasePathMapping[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: BasePathMappingArgs) {
super(name);
if (lumirt.defaultIfComputed(args.domainName, "") === undefined) {
throw new Error("Missing required argument 'domainName'");
}
this.domainName = args.domainName;
if (lumirt.defaultIfComputed(args.restAPI, "") === undefined) {
throw new Error("Missing required argument 'restAPI'");
}
this.restAPI = args.restAPI;
this.basePath = args.basePath;
this.stage = args.stage;
}
}
export interface BasePathMappingArgs {
domainName: string;
restAPI: RestAPI;
basePath?: string;
stage?: Stage;
}

30
lib/aws/pack/apigateway/clientCertificate.ts
View file

@ -1,30 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
export class ClientCertificate extends lumi.NamedResource implements ClientCertificateArgs {
public description?: string;
public static get(id: lumi.ID): ClientCertificate {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): ClientCertificate[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args?: ClientCertificateArgs) {
super(name);
if (args !== undefined) {
this.description = args.description;
}
}
}
export interface ClientCertificateArgs {
description?: string;
}

38
lib/aws/pack/apigateway/deployment.ts
View file

@ -1,38 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {RestAPI} from "./restAPI";
export class Deployment extends lumi.NamedResource implements DeploymentArgs {
public readonly restAPI: RestAPI;
public description?: string;
public id: string;
public createdDate: string;
public static get(id: lumi.ID): Deployment {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Deployment[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: DeploymentArgs) {
super(name);
if (lumirt.defaultIfComputed(args.restAPI, "") === undefined) {
throw new Error("Missing required argument 'restAPI'");
}
this.restAPI = args.restAPI;
this.description = args.description;
}
}
export interface DeploymentArgs {
readonly restAPI: RestAPI;
description?: string;
}

16
lib/aws/pack/apigateway/index.ts
View file

@ -1,16 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
export * from "./account";
export * from "./apiKey";
export * from "./authorizer";
export * from "./basePathMapping";
export * from "./clientCertificate";
export * from "./deployment";
export * from "./method";
export * from "./model";
export * from "./resource";
export * from "./restAPI";
export * from "./stage";
export * from "./usagePlan";
export * from "./usagePlanKey";

147
lib/aws/pack/apigateway/method.ts
View file

@ -1,147 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {Authorizer} from "./authorizer";
import {Model} from "./model";
import {Resource} from "./resource";
import {RestAPI} from "./restAPI";
export let AWSIAMAuthorization: AuthorizationType = "AWS_IAM";
export let AWSIntegration: IntegrationType = "AWS";
export let AWSProxyIntegration: IntegrationType = "AWS_PROXY";
export let CognitoAuthorization: AuthorizationType = "COGNITO_USER_POOLS";
export let CustomAuthorization: AuthorizationType = "CUSTOM";
export let HTTPIntegration: IntegrationType = "HTTP";
export let HTTPProxyIntegration: IntegrationType = "HTTP_PROXY";
export let LoggingErrorLevel: LoggingLevel = "ERROR";
export let LoggingInfoLevel: LoggingLevel = "INFO";
export let LoggingOff: LoggingLevel = "OFF";
export let MockIntegration: IntegrationType = "MOCK";
export let NoAuthorization: AuthorizationType = "NONE";
export let PassthroughNever: PassthroughBehavior = "NEVER";
export let PassthroughWhenNoMatch: PassthroughBehavior = "WHEN_NO_MATCH";
export let PassthroughWhenNoTemplates: PassthroughBehavior = "WHEN_NO_TEMPLATES";
export type AuthorizationType =
"AWS_IAM" |
"COGNITO_USER_POOLS" |
"CUSTOM" |
"NONE";
export interface Integration {
type: IntegrationType;
cacheKeyParameters?: string[];
cacheNamespace?: string;
credentials?: string;
integrationHTTPMethod?: string;
integrationResponse?: IntegrationResponse[];
passthroughBehavior?: PassthroughBehavior;
requestParameters?: {[key: string]: string};
requestTemplates?: {[key: string]: string};
uri?: string;
}
export interface IntegrationResponse {
responseParameters?: {[key: string]: string};
responseTemplates?: {[key: string]: string};
selectionPattern?: string;
statusCode?: string;
}
export type IntegrationType =
"AWS" |
"AWS_PROXY" |
"HTTP" |
"HTTP_PROXY" |
"MOCK";
export type LoggingLevel =
"ERROR" |
"INFO" |
"OFF";
export class Method extends lumi.NamedResource implements MethodArgs {
public httpMethod: string;
public apiResource: Resource;
public restAPI: RestAPI;
public apiKeyRequired?: boolean;
public authorizationType?: AuthorizationType;
public authorizer?: Authorizer;
public integration?: Integration;
public methodResponses?: MethodResponse[];
public requestModels?: {[key: string]: Model};
public requestParameters?: {[key: string]: boolean};
public static get(id: lumi.ID): Method {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Method[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: MethodArgs) {
super(name);
if (lumirt.defaultIfComputed(args.httpMethod, "") === undefined) {
throw new Error("Missing required argument 'httpMethod'");
}
this.httpMethod = args.httpMethod;
if (lumirt.defaultIfComputed(args.apiResource, "") === undefined) {
throw new Error("Missing required argument 'apiResource'");
}
this.apiResource = args.apiResource;
if (lumirt.defaultIfComputed(args.restAPI, "") === undefined) {
throw new Error("Missing required argument 'restAPI'");
}
this.restAPI = args.restAPI;
this.apiKeyRequired = args.apiKeyRequired;
this.authorizationType = args.authorizationType;
this.authorizer = args.authorizer;
this.integration = args.integration;
this.methodResponses = args.methodResponses;
this.requestModels = args.requestModels;
this.requestParameters = args.requestParameters;
}
}
export interface MethodArgs {
httpMethod: string;
apiResource: Resource;
restAPI: RestAPI;
apiKeyRequired?: boolean;
authorizationType?: AuthorizationType;
authorizer?: Authorizer;
integration?: Integration;
methodResponses?: MethodResponse[];
requestModels?: {[key: string]: Model};
requestParameters?: {[key: string]: boolean};
}
export interface MethodResponse {
statusCode: string;
responseModels?: {[key: string]: Model};
responseParameters?: {[key: string]: boolean};
}
export interface MethodSetting {
cacheDataEncrypted?: boolean;
cacheTTLInSeconds?: number;
cachingEnabled?: boolean;
dataTraceEnabled?: boolean;
httpMethod?: string;
loggingLevel?: LoggingLevel;
metricsEnabled?: boolean;
resourcePath?: string;
throttlingBurstLimit?: number;
throttlingRateLimit?: number;
}
export type PassthroughBehavior =
"NEVER" |
"WHEN_NO_MATCH" |
"WHEN_NO_TEMPLATES";

51
lib/aws/pack/apigateway/model.ts
View file

@ -1,51 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {RestAPI} from "./restAPI";
export class Model extends lumi.NamedResource implements ModelArgs {
public readonly contentType: string;
public readonly restAPI: RestAPI;
public schema: any;
public readonly modelName?: string;
public description?: string;
public static get(id: lumi.ID): Model {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Model[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: ModelArgs) {
super(name);
if (lumirt.defaultIfComputed(args.contentType, "") === undefined) {
throw new Error("Missing required argument 'contentType'");
}
this.contentType = args.contentType;
if (lumirt.defaultIfComputed(args.restAPI, "") === undefined) {
throw new Error("Missing required argument 'restAPI'");
}
this.restAPI = args.restAPI;
if (lumirt.defaultIfComputed(args.schema, "") === undefined) {
throw new Error("Missing required argument 'schema'");
}
this.schema = args.schema;
this.modelName = args.modelName;
this.description = args.description;
}
}
export interface ModelArgs {
readonly contentType: string;
readonly restAPI: RestAPI;
schema: any;
readonly modelName?: string;
description?: string;
}

45
lib/aws/pack/apigateway/resource.ts
View file

@ -1,45 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {RestAPI} from "./restAPI";
export class Resource extends lumi.NamedResource implements ResourceArgs {
public readonly parent: Resource;
public readonly pathPart: string;
public readonly restAPI: RestAPI;
public static get(id: lumi.ID): Resource {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Resource[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: ResourceArgs) {
super(name);
if (lumirt.defaultIfComputed(args.parent, "") === undefined) {
throw new Error("Missing required argument 'parent'");
}
this.parent = args.parent;
if (lumirt.defaultIfComputed(args.pathPart, "") === undefined) {
throw new Error("Missing required argument 'pathPart'");
}
this.pathPart = args.pathPart;
if (lumirt.defaultIfComputed(args.restAPI, "") === undefined) {
throw new Error("Missing required argument 'restAPI'");
}
this.restAPI = args.restAPI;
}
}
export interface ResourceArgs {
readonly parent: Resource;
readonly pathPart: string;
readonly restAPI: RestAPI;
}

61
lib/aws/pack/apigateway/restAPI.ts
View file

@ -1,61 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {Object} from "../s3/object";
export class RestAPI extends lumi.NamedResource implements RestAPIArgs {
public body?: any;
public bodyS3Location?: S3Location;
public cloneFrom?: RestAPI;
public description?: string;
public failOnWarnings?: boolean;
public apiName?: string;
public parameters?: string[];
public id: string;
public createdDate: string;
public version: string;
public warnings: string[];
public binaryMediaTypes: string[];
public static get(id: lumi.ID): RestAPI {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): RestAPI[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args?: RestAPIArgs) {
super(name);
if (args !== undefined) {
this.body = args.body;
this.bodyS3Location = args.bodyS3Location;
this.cloneFrom = args.cloneFrom;
this.description = args.description;
this.failOnWarnings = args.failOnWarnings;
this.apiName = args.apiName;
this.parameters = args.parameters;
}
}
}
export interface RestAPIArgs {
body?: any;
bodyS3Location?: S3Location;
cloneFrom?: RestAPI;
description?: string;
failOnWarnings?: boolean;
apiName?: string;
parameters?: string[];
}
export interface S3Location {
object: Object;
etag?: string;
version?: string;
}

70
lib/aws/pack/apigateway/stage.ts
View file

@ -1,70 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {ClientCertificate} from "./clientCertificate";
import {Deployment} from "./deployment";
import {MethodSetting} from "./method";
import {RestAPI} from "./restAPI";
export class Stage extends lumi.NamedResource implements StageArgs {
public readonly restAPI: RestAPI;
public readonly stageName: string;
public deployment: Deployment;
public cacheClusterEnabled?: boolean;
public cacheClusterSize?: string;
public clientCertificate?: ClientCertificate;
public description?: string;
public methodSettings?: MethodSetting[];
public variables?: {[key: string]: string};
public createdDate: string;
public lastUpdatedDate: string;
public url: string;
public executionARN: string;
public static get(id: lumi.ID): Stage {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Stage[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: StageArgs) {
super(name);
if (lumirt.defaultIfComputed(args.restAPI, "") === undefined) {
throw new Error("Missing required argument 'restAPI'");
}
this.restAPI = args.restAPI;
if (lumirt.defaultIfComputed(args.stageName, "") === undefined) {
throw new Error("Missing required argument 'stageName'");
}
this.stageName = args.stageName;
if (lumirt.defaultIfComputed(args.deployment, "") === undefined) {
throw new Error("Missing required argument 'deployment'");
}
this.deployment = args.deployment;
this.cacheClusterEnabled = args.cacheClusterEnabled;
this.cacheClusterSize = args.cacheClusterSize;
this.clientCertificate = args.clientCertificate;
this.description = args.description;
this.methodSettings = args.methodSettings;
this.variables = args.variables;
}
}
export interface StageArgs {
readonly restAPI: RestAPI;
readonly stageName: string;
deployment: Deployment;
cacheClusterEnabled?: boolean;
cacheClusterSize?: string;
clientCertificate?: ClientCertificate;
description?: string;
methodSettings?: MethodSetting[];
variables?: {[key: string]: string};
}

70
lib/aws/pack/apigateway/usagePlan.ts
View file

@ -1,70 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {RestAPI} from "./restAPI";
import {Stage} from "./stage";
export let QuotaDayPeriod: QuotaPeriod = "DAY";
export let QuotaMonthPeriod: QuotaPeriod = "MONTH";
export let QuotaWeekPeriod: QuotaPeriod = "WEEK";
export interface APIStage {
api?: RestAPI;
stage?: Stage;
}
export type QuotaPeriod =
"DAY" |
"MONTH" |
"WEEK";
export interface QuotaSettings {
limit?: number;
offset?: number;
period?: QuotaPeriod;
}
export interface ThrottleSettings {
burstRateLimit?: number;
rateLimit?: number;
}
export class UsagePlan extends lumi.NamedResource implements UsagePlanArgs {
public apiStages?: APIStage[];
public description?: string;
public quota?: QuotaSettings;
public throttle?: ThrottleSettings;
public usagePlanName?: string;
public static get(id: lumi.ID): UsagePlan {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): UsagePlan[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args?: UsagePlanArgs) {
super(name);
if (args !== undefined) {
this.apiStages = args.apiStages;
this.description = args.description;
this.quota = args.quota;
this.throttle = args.throttle;
this.usagePlanName = args.usagePlanName;
}
}
}
export interface UsagePlanArgs {
apiStages?: APIStage[];
description?: string;
quota?: QuotaSettings;
throttle?: ThrottleSettings;
usagePlanName?: string;
}

40
lib/aws/pack/apigateway/usagePlanKey.ts
View file

@ -1,40 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {APIKey} from "./apiKey";
import {UsagePlan} from "./usagePlan";
export class UsagePlanKey extends lumi.NamedResource implements UsagePlanKeyArgs {
public readonly key: APIKey;
public readonly usagePlan: UsagePlan;
public static get(id: lumi.ID): UsagePlanKey {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): UsagePlanKey[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: UsagePlanKeyArgs) {
super(name);
if (lumirt.defaultIfComputed(args.key, "") === undefined) {
throw new Error("Missing required argument 'key'");
}
this.key = args.key;
if (lumirt.defaultIfComputed(args.usagePlan, "") === undefined) {
throw new Error("Missing required argument 'usagePlan'");
}
this.usagePlan = args.usagePlan;
}
}
export interface UsagePlanKeyArgs {
readonly key: APIKey;
readonly usagePlan: UsagePlan;
}

201
lib/aws/pack/cloudwatch/alarm.ts
View file

@ -1,201 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
export let AverageStatistic: AlarmStatistic = "Average";
export let BitsMetric: AlarmMetric = "Bits";
export let BitsPerSecondMetric: AlarmMetric = "Bits/Second";
export let BytesMetric: AlarmMetric = "Bytes";
export let BytesPerSecondMetric: AlarmMetric = "Bytes/Second";
export let CountMetric: AlarmMetric = "Count";
export let CountPerSecondMetric: AlarmMetric = "Count/Second";
export let GigabitsMetric: AlarmMetric = "Gigabits";
export let GigabitsPerSecondMetric: AlarmMetric = "Gigabits/Second";
export let GigabytesMetric: AlarmMetric = "Gigabytes";
export let GigabytesPerSecondMetric: AlarmMetric = "Gigabytes/Second";
export let KilobitsMetric: AlarmMetric = "Kilobits";
export let KilobitsPerSecondMetric: AlarmMetric = "Kilobits/Second";
export let KilobytesMetric: AlarmMetric = "Kilobytes";
export let KilobytesPerSecondMetric: AlarmMetric = "Kilobytes/Second";
export let MaximumStatistic: AlarmStatistic = "Maximum";
export let MegabitsMetric: AlarmMetric = "Megabits";
export let MegabitsPerSecondMetric: AlarmMetric = "Megabits/Second";
export let MegabytesMetric: AlarmMetric = "Megabytes";
export let MegabytesPerSecondMetric: AlarmMetric = "Megabytes/Second";
export let MicrosecondsMetric: AlarmMetric = "Microseconds";
export let MillisecondsMetric: AlarmMetric = "Milliseconds";
export let MinimumStatistic: AlarmStatistic = "Minimum";
export let NoMetric: AlarmMetric = "None";
export let PercentMetric: AlarmMetric = "Percent";
export let SampleCountStatistic: AlarmStatistic = "SampleCount";
export let SecondsMetric: AlarmMetric = "Seconds";
export let SumStatistic: AlarmStatistic = "Sum";
export let TerabitsMetric: AlarmMetric = "Terabits";
export let TerabitsPerSecondMetric: AlarmMetric = "Terabits/Second";
export let TerabytesMetric: AlarmMetric = "Terabytes";
export let TerabytesPerSecondMetric: AlarmMetric = "Terabytes/Second";
export let ThresholdGreaterThan: AlarmComparisonOperator = "GreaterThanThreshold";
export let ThresholdGreaterThanOrEqualTo: AlarmComparisonOperator = "GreaterThanOrEqualToThreshold";
export let ThresholdLessThan: AlarmComparisonOperator = "LessThanThreshold";
export let ThresholdLessThanOrEqualTo: AlarmComparisonOperator = "LessThanOrEqualToThreshold";
export class ActionTarget extends lumi.NamedResource implements ActionTargetArgs {
public readonly topicName?: string;
public displayName?: string;
public static get(id: lumi.ID): ActionTarget {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): ActionTarget[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args?: ActionTargetArgs) {
super(name);
if (args !== undefined) {
this.topicName = args.topicName;
this.displayName = args.displayName;
}
}
}
export interface ActionTargetArgs {
readonly topicName?: string;
displayName?: string;
}
export class Alarm extends lumi.NamedResource implements AlarmArgs {
public comparisonOperator: AlarmComparisonOperator;
public evaluationPerids: number;
public metricName: string;
public namespace: string;
public period: number;
public statistic: AlarmStatistic;
public threshold: number;
public actionsEnabled?: boolean;
public alarmActions?: ActionTarget[];
public alarmDescription?: string;
public readonly alarmName?: string;
public dimensions?: AlarmDimension[];
public insufficientDataActions?: ActionTarget[];
public okActions?: ActionTarget[];
public unit?: AlarmMetric;
public static get(id: lumi.ID): Alarm {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Alarm[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: AlarmArgs) {
super(name);
if (lumirt.defaultIfComputed(args.comparisonOperator, "") === undefined) {
throw new Error("Missing required argument 'comparisonOperator'");
}
this.comparisonOperator = args.comparisonOperator;
if (lumirt.defaultIfComputed(args.evaluationPerids, "") === undefined) {
throw new Error("Missing required argument 'evaluationPerids'");
}
this.evaluationPerids = args.evaluationPerids;
if (lumirt.defaultIfComputed(args.metricName, "") === undefined) {
throw new Error("Missing required argument 'metricName'");
}
this.metricName = args.metricName;
if (lumirt.defaultIfComputed(args.namespace, "") === undefined) {
throw new Error("Missing required argument 'namespace'");
}
this.namespace = args.namespace;
if (lumirt.defaultIfComputed(args.period, "") === undefined) {
throw new Error("Missing required argument 'period'");
}
this.period = args.period;
if (lumirt.defaultIfComputed(args.statistic, "") === undefined) {
throw new Error("Missing required argument 'statistic'");
}
this.statistic = args.statistic;
if (lumirt.defaultIfComputed(args.threshold, "") === undefined) {
throw new Error("Missing required argument 'threshold'");
}
this.threshold = args.threshold;
this.actionsEnabled = args.actionsEnabled;
this.alarmActions = args.alarmActions;
this.alarmDescription = args.alarmDescription;
this.alarmName = args.alarmName;
this.dimensions = args.dimensions;
this.insufficientDataActions = args.insufficientDataActions;
this.okActions = args.okActions;
this.unit = args.unit;
}
}
export interface AlarmArgs {
comparisonOperator: AlarmComparisonOperator;
evaluationPerids: number;
metricName: string;
namespace: string;
period: number;
statistic: AlarmStatistic;
threshold: number;
actionsEnabled?: boolean;
alarmActions?: ActionTarget[];
alarmDescription?: string;
readonly alarmName?: string;
dimensions?: AlarmDimension[];
insufficientDataActions?: ActionTarget[];
okActions?: ActionTarget[];
unit?: AlarmMetric;
}
export type AlarmComparisonOperator =
"GreaterThanThreshold" |
"GreaterThanOrEqualToThreshold" |
"LessThanThreshold" |
"LessThanOrEqualToThreshold";
export interface AlarmDimension {
name: string;
value: any;
}
export type AlarmMetric =
"Bits" |
"Bits/Second" |
"Bytes" |
"Bytes/Second" |
"Count" |
"Count/Second" |
"Gigabits" |
"Gigabits/Second" |
"Gigabytes" |
"Gigabytes/Second" |
"Kilobits" |
"Kilobits/Second" |
"Kilobytes" |
"Kilobytes/Second" |
"Megabits" |
"Megabits/Second" |
"Megabytes" |
"Megabytes/Second" |
"Microseconds" |
"Milliseconds" |
"None" |
"Percent" |
"Seconds" |
"Terabits" |
"Terabits/Second" |
"Terabytes" |
"Terabytes/Second";
export type AlarmStatistic =
"Average" |
"Maximum" |
"Minimum" |
"SampleCount" |
"Sum";

6
lib/aws/pack/cloudwatch/index.ts
View file

@ -1,6 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
export * from "./alarm";
export * from "./logGroup";
export * from "./logSubscriptionFilter";

33
lib/aws/pack/cloudwatch/logGroup.ts
View file

@ -1,33 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
export class LogGroup extends lumi.NamedResource implements LogGroupArgs {
public readonly logGroupName?: string;
public retentionInDays?: number;
public static get(id: lumi.ID): LogGroup {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): LogGroup[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args?: LogGroupArgs) {
super(name);
if (args !== undefined) {
this.logGroupName = args.logGroupName;
this.retentionInDays = args.retentionInDays;
}
}
}
export interface LogGroupArgs {
readonly logGroupName?: string;
retentionInDays?: number;
}

59
lib/aws/pack/cloudwatch/logSubscriptionFilter.ts
View file

@ -1,59 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {ARN} from "../types";
export let ByLogStreamDistribution: LogSubscriptionDistribution = "ByLogStream";
export let RandomDistribution: LogSubscriptionDistribution = "Random";
export type LogSubscriptionDistribution =
"ByLogStream" |
"Random";
export class LogSubscriptionFilter extends lumi.NamedResource implements LogSubscriptionFilterArgs {
public readonly logGroupName: string;
public filterPattern: string;
public readonly destinationArn: string;
public roleArn?: ARN;
public distribution?: LogSubscriptionDistribution;
public creationTime: number;
public static get(id: lumi.ID): LogSubscriptionFilter {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): LogSubscriptionFilter[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: LogSubscriptionFilterArgs) {
super(name);
if (lumirt.defaultIfComputed(args.logGroupName, "") === undefined) {
throw new Error("Missing required argument 'logGroupName'");
}
this.logGroupName = args.logGroupName;
if (lumirt.defaultIfComputed(args.filterPattern, "") === undefined) {
throw new Error("Missing required argument 'filterPattern'");
}
this.filterPattern = args.filterPattern;
if (lumirt.defaultIfComputed(args.destinationArn, "") === undefined) {
throw new Error("Missing required argument 'destinationArn'");
}
this.destinationArn = args.destinationArn;
this.roleArn = args.roleArn;
this.distribution = args.distribution;
}
}
export interface LogSubscriptionFilterArgs {
readonly logGroupName: string;
filterPattern: string;
readonly destinationArn: string;
roleArn?: ARN;
distribution?: LogSubscriptionDistribution;
}

24
lib/aws/pack/config/index.ts
View file

@ -1,24 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
import {Region} from "../types";
// region configures the target region for a deployment. The provider explicitly does not recognize AWS_REGION,
// to minimize the possibility of accidental deployment differences due to a changing environment variable.
export let region: Region | undefined;
// requireRegion fetches the AWS region, requiring that it exists; if it has not been configured, an error is thrown.
export function requireRegion(): Region {
if (region === undefined) {
throw new Error("No AWS region has been configured");
}
return region;
}
// accessKeyId configures the access key ID used to access AWS. This is a secret. If not provided, the
// provider will look in the standard places (~/.aws/credentials, AWS_ACCESS_KEY_ID, etc).
export let accessKeyId: string | undefined;
// secretAcessKey configures the secret access key used to access AWS. This is a secret. If not provided, the
// provider will look in the standard places (~/.aws/credentials, AWS_SECRET_ACCESS_KEY, etc).
export let secretAccessKey: string | undefined; // the secret access key used to access AWS.

4
lib/aws/pack/dynamodb/index.ts
View file

@ -1,4 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
export * from "./table";

90
lib/aws/pack/dynamodb/table.ts
View file

@ -1,90 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
export let AllProjection: ProjectionType = "ALL";
export let BinaryAttribute: AttributeType = "B";
export let IncludeProjection: ProjectionType = "INCLUDE";
export let KeysOnlyProjection: ProjectionType = "KEYS_ONLY";
export let NumberAttribute: AttributeType = "N";
export let StringAttribute: AttributeType = "S";
export interface Attribute {
name: string;
type: AttributeType;
}
export type AttributeType =
"B" |
"N" |
"S";
export interface GlobalSecondaryIndex {
indexName: string;
hashKey: string;
rangeKey?: string;
readCapacity: number;
writeCapacity: number;
nonKeyAttributes: string[];
projectionType: ProjectionType;
}
export type ProjectionType =
"ALL" |
"INCLUDE" |
"KEYS_ONLY";
export class Table extends lumi.NamedResource implements TableArgs {
public readonly hashKey: string;
public attributes: Attribute[];
public readCapacity: number;
public writeCapacity: number;
public readonly rangeKey?: string;
public readonly tableName?: string;
public globalSecondaryIndexes?: GlobalSecondaryIndex[];
public static get(id: lumi.ID): Table {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Table[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: TableArgs) {
super(name);
if (lumirt.defaultIfComputed(args.hashKey, "") === undefined) {
throw new Error("Missing required argument 'hashKey'");
}
this.hashKey = args.hashKey;
if (lumirt.defaultIfComputed(args.attributes, "") === undefined) {
throw new Error("Missing required argument 'attributes'");
}
this.attributes = args.attributes;
if (lumirt.defaultIfComputed(args.readCapacity, "") === undefined) {
throw new Error("Missing required argument 'readCapacity'");
}
this.readCapacity = args.readCapacity;
if (lumirt.defaultIfComputed(args.writeCapacity, "") === undefined) {
throw new Error("Missing required argument 'writeCapacity'");
}
this.writeCapacity = args.writeCapacity;
this.rangeKey = args.rangeKey;
this.tableName = args.tableName;
this.globalSecondaryIndexes = args.globalSecondaryIndexes;
}
}
export interface TableArgs {
readonly hashKey: string;
attributes: Attribute[];
readCapacity: number;
writeCapacity: number;
readonly rangeKey?: string;
readonly tableName?: string;
globalSecondaryIndexes?: GlobalSecondaryIndex[];
}

15
lib/aws/pack/ec2/index.ts
View file

@ -1,15 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
export * from "./instance";
export * from "./instanceMaps";
export * from "./internetGateway";
export * from "./route";
export * from "./routeTable";
export * from "./securityGroup";
export * from "./securityGroupEgress";
export * from "./securityGroupIngress";
export * from "./subnet";
export * from "./vpc";
export * from "./vpcGatewayAttachment";
export * from "./vpcPeeringConnection";

172
lib/aws/pack/ec2/instance.ts
View file

@ -1,172 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {SecurityGroup} from "./securityGroup";
export let C3Instance2XLarge: InstanceType = "c3.2xlarge";
export let C3Instance4XLarge: InstanceType = "c3.4xlarge";
export let C3Instance8XLarge: InstanceType = "c3.8xlarge";
export let C3InstanceLarge: InstanceType = "c3.large";
export let C3InstanceXLarge: InstanceType = "c3.xlarge";
export let C4Instance2XLarge: InstanceType = "c4.2xlarge";
export let C4Instance4XLarge: InstanceType = "c4.4xlarge";
export let C4Instance8XLarge: InstanceType = "c4.8xlarge";
export let C4InstanceLarge: InstanceType = "c4.large";
export let C4InstanceXLarge: InstanceType = "c4.xlarge";
export let D2Instance2XLarge: InstanceType = "d2.2xlarge";
export let D2Instance4XLarge: InstanceType = "d2.4xlarge";
export let D2Instance8XLarge: InstanceType = "d2.8xlarge";
export let D2InstanceXLarge: InstanceType = "d2.xlarge";
export let F1Instance16XLarge: InstanceType = "f1.16xlarge";
export let F1Instance2XLarge: InstanceType = "f1.2xlarge";
export let G2Instance2XLarge: InstanceType = "g2.2xlarge";
export let G2Instance8XLarge: InstanceType = "g2.8xlarge";
export let I3Instance16XLarge: InstanceType = "i3.16xlarge";
export let I3Instance2XLarge: InstanceType = "i3.2xlarge";
export let I3Instance4XLarge: InstanceType = "i3.4xlarge";
export let I3Instance8XLarge: InstanceType = "i3.8xlarge";
export let I3InstanceLarge: InstanceType = "i3.large";
export let I3InstanceXLarge: InstanceType = "i3.xlarge";
export let M3Instance2XLarge: InstanceType = "m3.2xlarge";
export let M3InstanceLarge: InstanceType = "m3.large";
export let M3InstanceMedium: InstanceType = "m3.medium";
export let M3InstanceXLarge: InstanceType = "m3.xlarge";
export let M4Instance10XLarge: InstanceType = "m4.10xlarge";
export let M4Instance16XLarge: InstanceType = "m4.16xlarge";
export let M4Instance2XLarge: InstanceType = "m4.2xlarge";
export let M4Instance4XLarge: InstanceType = "m4.4xlarge";
export let M4InstanceLarge: InstanceType = "m4.large";
export let M4InstanceXLarge: InstanceType = "m4.xlarge";
export let P2Instance16XLarge: InstanceType = "p2.16xlarge";
export let P2Instance8XLarge: InstanceType = "p2.8xlarge";
export let P2InstanceXLarge: InstanceType = "p2.xlarge";
export let R3Instance2XLarge: InstanceType = "r3.2xlarge";
export let R3Instance4XLarge: InstanceType = "r3.4xlarge";
export let R3Instance8XLarge: InstanceType = "r3.8xlarge";
export let R3InstanceLarge: InstanceType = "r3.large";
export let R3InstanceXLarge: InstanceType = "r3.xlarge";
export let R4Instance16XLarge: InstanceType = "r4.16xlarge";
export let R4Instance2XLarge: InstanceType = "r4.2xlarge";
export let R4Instance4XLarge: InstanceType = "r4.4xlarge";
export let R4Instance8XLarge: InstanceType = "r4.8xlarge";
export let R4InstanceLarge: InstanceType = "r4.large";
export let R4InstanceXLarge: InstanceType = "r4.xlarge";
export let T2Instance2XLarge: InstanceType = "t2.2xlarge";
export let T2InstanceLarge: InstanceType = "t2.large";
export let T2InstanceMedium: InstanceType = "t2.medium";
export let T2InstanceMicro: InstanceType = "t2.micro";
export let T2InstanceNano: InstanceType = "t2.nano";
export let T2InstanceSmall: InstanceType = "t2.small";
export let T2InstanceXLarge: InstanceType = "t2.xlarge";
export let X1Instance16XLarge: InstanceType = "x1.16xlarge";
export let X1Instance32XLarge: InstanceType = "x1.32xlarge";
export class Instance extends lumi.NamedResource implements InstanceArgs {
public readonly imageId: string;
public readonly instanceType?: InstanceType;
public readonly securityGroups?: SecurityGroup[];
public readonly keyName?: string;
public tags?: Tag[];
public availabilityZone: string;
public privateDNSName?: string;
public publicDNSName?: string;
public privateIP?: string;
public publicIP?: string;
public static get(id: lumi.ID): Instance {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Instance[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: InstanceArgs) {
super(name);
if (lumirt.defaultIfComputed(args.imageId, "") === undefined) {
throw new Error("Missing required argument 'imageId'");
}
this.imageId = args.imageId;
this.instanceType = args.instanceType;
this.securityGroups = args.securityGroups;
this.keyName = args.keyName;
this.tags = args.tags;
}
}
export interface InstanceArgs {
readonly imageId: string;
readonly instanceType?: InstanceType;
readonly securityGroups?: SecurityGroup[];
readonly keyName?: string;
tags?: Tag[];
}
export type InstanceType =
"c3.2xlarge" |
"c3.4xlarge" |
"c3.8xlarge" |
"c3.large" |
"c3.xlarge" |
"c4.2xlarge" |
"c4.4xlarge" |
"c4.8xlarge" |
"c4.large" |
"c4.xlarge" |
"d2.2xlarge" |
"d2.4xlarge" |
"d2.8xlarge" |
"d2.xlarge" |
"f1.16xlarge" |
"f1.2xlarge" |
"g2.2xlarge" |
"g2.8xlarge" |
"i3.16xlarge" |
"i3.2xlarge" |
"i3.4xlarge" |
"i3.8xlarge" |
"i3.large" |
"i3.xlarge" |
"m3.2xlarge" |
"m3.large" |
"m3.medium" |
"m3.xlarge" |
"m4.10xlarge" |
"m4.16xlarge" |
"m4.2xlarge" |
"m4.4xlarge" |
"m4.large" |
"m4.xlarge" |
"p2.16xlarge" |
"p2.8xlarge" |
"p2.xlarge" |
"r3.2xlarge" |
"r3.4xlarge" |
"r3.8xlarge" |
"r3.large" |
"r3.xlarge" |
"r4.16xlarge" |
"r4.2xlarge" |
"r4.4xlarge" |
"r4.8xlarge" |
"r4.large" |
"r4.xlarge" |
"t2.2xlarge" |
"t2.large" |
"t2.medium" |
"t2.micro" |
"t2.nano" |
"t2.small" |
"t2.xlarge" |
"x1.16xlarge" |
"x1.32xlarge";
export interface Tag {
key: string;
value: string;
}

156
lib/aws/pack/ec2/instanceMaps.ts
View file

@ -1,156 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
// This file defines some maps that correspond to the recommended AWS Marketplace values:
// http://docs.aws.amazon.com/servicecatalog/latest/adminguide/catalogs_marketplace-products.html
// Ultimately, this lets us choose a recommended Amazon Linux AMI; see:
// https://aws.amazon.com/amazon-linux-ami/instance-type-matrix/
import * as config from "../config";
// instanceTypeArch is a map of instance type to its architecture.
export let instanceTypeArch: {
[instanceType: string]: string,
} = {
"t1.micro" : "PV64" ,
"t2.nano" : "HVM64",
"t2.micro" : "HVM64",
"t2.small" : "HVM64",
"t2.medium" : "HVM64",
"t2.large" : "HVM64",
"m1.small" : "PV64" ,
"m1.medium" : "PV64" ,
"m1.large" : "PV64" ,
"m1.xlarge" : "PV64" ,
"m2.xlarge" : "PV64" ,
"m2.2xlarge" : "PV64" ,
"m2.4xlarge" : "PV64" ,
"m3.medium" : "HVM64",
"m3.large" : "HVM64",
"m3.xlarge" : "HVM64",
"m3.2xlarge" : "HVM64",
"m4.large" : "HVM64",
"m4.xlarge" : "HVM64",
"m4.2xlarge" : "HVM64",
"m4.4xlarge" : "HVM64",
"m4.10xlarge": "HVM64",
"c1.medium" : "PV64" ,
"c1.xlarge" : "PV64" ,
"c3.large" : "HVM64",
"c3.xlarge" : "HVM64",
"c3.2xlarge" : "HVM64",
"c3.4xlarge" : "HVM64",
"c3.8xlarge" : "HVM64",
"c4.large" : "HVM64",
"c4.xlarge" : "HVM64",
"c4.2xlarge" : "HVM64",
"c4.4xlarge" : "HVM64",
"c4.8xlarge" : "HVM64",
"g2.2xlarge" : "HVMG2",
"g2.8xlarge" : "HVMG2",
"r3.large" : "HVM64",
"r3.xlarge" : "HVM64",
"r3.2xlarge" : "HVM64",
"r3.4xlarge" : "HVM64",
"r3.8xlarge" : "HVM64",
"i2.xlarge" : "HVM64",
"i2.2xlarge" : "HVM64",
"i2.4xlarge" : "HVM64",
"i2.8xlarge" : "HVM64",
"d2.xlarge" : "HVM64",
"d2.2xlarge" : "HVM64",
"d2.4xlarge" : "HVM64",
"d2.8xlarge" : "HVM64",
"hi1.4xlarge": "HVM64",
"hs1.8xlarge": "HVM64",
"cr1.8xlarge": "HVM64",
"cc2.8xlarge": "HVM64",
};
// regionArchLinuxAMI is a map from region to inner maps from architecture to the recommended Linux AMI.
export let regionArchLinuxAMI: {
[region: string]: { [arch: string]: string; },
} = {
"us-east-1": {
"PV64" : "ami-2a69aa47",
"HVM64": "ami-6869aa05",
"HVMG2": "ami-648d9973",
},
"us-west-2": {
"PV64" : "ami-7f77b31f",
"HVM64": "ami-7172b611",
"HVMG2": "ami-09cd7a69",
},
"us-west-1": {
"PV64" : "ami-a2490dc2",
"HVM64": "ami-31490d51",
"HVMG2": "ami-1e5f0e7e",
},
"eu-west-1": {
"PV64" : "ami-4cdd453f",
"HVM64": "ami-f9dd458a",
"HVMG2": "ami-b4694ac7",
},
"eu-west-2": {
"PV64" : "NOT_SUPPORTED",
"HVM64": "ami-886369ec",
"HVMG2": "NOT_SUPPORTED",
},
"eu-central-1": {
"PV64" : "ami-6527cf0a",
"HVM64": "ami-ea26ce85",
"HVMG2": "ami-de5191b1",
},
"ap-northeast-1": {
"PV64" : "ami-3e42b65f",
"HVM64": "ami-374db956",
"HVMG2": "ami-df9ff4b8",
},
"ap-northeast-2": {
"PV64" : "NOT_SUPPORTED",
"HVM64": "ami-2b408b45",
"HVMG2": "NOT_SUPPORTED",
},
"ap-southeast-1": {
"PV64" : "ami-df9e4cbc",
"HVM64": "ami-a59b49c6",
"HVMG2": "ami-8d8d23ee",
},
"ap-southeast-2": {
"PV64" : "ami-63351d00",
"HVM64": "ami-dc361ebf",
"HVMG2": "ami-cbaf94a8",
},
"ap-south-1": {
"PV64" : "NOT_SUPPORTED",
"HVM64": "ami-ffbdd790",
"HVMG2": "ami-decdbab1",
},
"us-east-2": {
"PV64" : "NOT_SUPPORTED",
"HVM64": "ami-f6035893",
"HVMG2": "NOT_SUPPORTED",
},
"ca-central-1": {
"PV64" : "NOT_SUPPORTED",
"HVM64": "ami-730ebd17",
"HVMG2": "NOT_SUPPORTED",
},
"sa-east-1": {
"PV64" : "ami-1ad34676",
"HVM64": "ami-6dd04501",
"HVMG2": "NOT_SUPPORTED",
},
"cn-north-1": {
"PV64" : "ami-77559f1a",
"HVM64": "ami-8e6aa0e3",
"HVMG2": "NOT_SUPPORTED",
},
};
// getLinuxAMI gets the recommended Linux AMI for the given instance in the current AWS region.
export function getLinuxAMI(instanceType: string): string {
let region = config.requireRegion();
let arch = instanceTypeArch[instanceType];
return regionArchLinuxAMI[region][arch];
}

25
lib/aws/pack/ec2/internetGateway.ts
View file

@ -1,25 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
export class InternetGateway extends lumi.NamedResource implements InternetGatewayArgs {
public static get(id: lumi.ID): InternetGateway {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): InternetGateway[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args?: InternetGatewayArgs) {
super(name);
}
}
export interface InternetGatewayArgs {
}

53
lib/aws/pack/ec2/route.ts
View file

@ -1,53 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {InternetGateway} from "./internetGateway";
import {RouteTable} from "./routeTable";
import {VPCGatewayAttachment} from "./vpcGatewayAttachment";
export class Route extends lumi.NamedResource implements RouteArgs {
public readonly destinationCidrBlock: string;
public readonly routeTable: RouteTable;
public readonly internetGateway: InternetGateway;
public readonly vpcGatewayAttachment: VPCGatewayAttachment;
public static get(id: lumi.ID): Route {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Route[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: RouteArgs) {
super(name);
if (lumirt.defaultIfComputed(args.destinationCidrBlock, "") === undefined) {
throw new Error("Missing required argument 'destinationCidrBlock'");
}
this.destinationCidrBlock = args.destinationCidrBlock;
if (lumirt.defaultIfComputed(args.routeTable, "") === undefined) {
throw new Error("Missing required argument 'routeTable'");
}
this.routeTable = args.routeTable;
if (lumirt.defaultIfComputed(args.internetGateway, "") === undefined) {
throw new Error("Missing required argument 'internetGateway'");
}
this.internetGateway = args.internetGateway;
if (lumirt.defaultIfComputed(args.vpcGatewayAttachment, "") === undefined) {
throw new Error("Missing required argument 'vpcGatewayAttachment'");
}
this.vpcGatewayAttachment = args.vpcGatewayAttachment;
}
}
export interface RouteArgs {
readonly destinationCidrBlock: string;
readonly routeTable: RouteTable;
readonly internetGateway: InternetGateway;
readonly vpcGatewayAttachment: VPCGatewayAttachment;
}

33
lib/aws/pack/ec2/routeTable.ts
View file

@ -1,33 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {VPC} from "./vpc";
export class RouteTable extends lumi.NamedResource implements RouteTableArgs {
public readonly vpc: VPC;
public static get(id: lumi.ID): RouteTable {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): RouteTable[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: RouteTableArgs) {
super(name);
if (lumirt.defaultIfComputed(args.vpc, "") === undefined) {
throw new Error("Missing required argument 'vpc'");
}
this.vpc = args.vpc;
}
}
export interface RouteTableArgs {
readonly vpc: VPC;
}

53
lib/aws/pack/ec2/securityGroup.ts
View file

@ -1,53 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {VPC} from "./vpc";
export class SecurityGroup extends lumi.NamedResource implements SecurityGroupArgs {
public readonly groupDescription: string;
public readonly groupName?: string;
public readonly vpc?: VPC;
public securityGroupEgress?: SecurityGroupRule[];
public securityGroupIngress?: SecurityGroupRule[];
public groupID: string;
public static get(id: lumi.ID): SecurityGroup {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): SecurityGroup[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: SecurityGroupArgs) {
super(name);
if (lumirt.defaultIfComputed(args.groupDescription, "") === undefined) {
throw new Error("Missing required argument 'groupDescription'");
}
this.groupDescription = args.groupDescription;
this.groupName = args.groupName;
this.vpc = args.vpc;
this.securityGroupEgress = args.securityGroupEgress;
this.securityGroupIngress = args.securityGroupIngress;
}
}
export interface SecurityGroupArgs {
readonly groupDescription: string;
readonly groupName?: string;
readonly vpc?: VPC;
securityGroupEgress?: SecurityGroupRule[];
securityGroupIngress?: SecurityGroupRule[];
}
export interface SecurityGroupRule {
ipProtocol: string;
cidrIp?: string;
fromPort?: number;
toPort?: number;
}

63
lib/aws/pack/ec2/securityGroupEgress.ts
View file

@ -1,63 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {SecurityGroup} from "./securityGroup";
export class SecurityGroupEgress extends lumi.NamedResource implements SecurityGroupEgressArgs {
public readonly fromPort: number;
public readonly group: SecurityGroup;
public readonly ipProtocol: string;
public readonly toPort: number;
public readonly cidrIp?: string;
public readonly cidrIpv6?: string;
public readonly destinationPrefixListId?: string;
public readonly destinationSecurityGroup?: SecurityGroup;
public static get(id: lumi.ID): SecurityGroupEgress {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): SecurityGroupEgress[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: SecurityGroupEgressArgs) {
super(name);
if (lumirt.defaultIfComputed(args.fromPort, "") === undefined) {
throw new Error("Missing required argument 'fromPort'");
}
this.fromPort = args.fromPort;
if (lumirt.defaultIfComputed(args.group, "") === undefined) {
throw new Error("Missing required argument 'group'");
}
this.group = args.group;
if (lumirt.defaultIfComputed(args.ipProtocol, "") === undefined) {
throw new Error("Missing required argument 'ipProtocol'");
}
this.ipProtocol = args.ipProtocol;
if (lumirt.defaultIfComputed(args.toPort, "") === undefined) {
throw new Error("Missing required argument 'toPort'");
}
this.toPort = args.toPort;
this.cidrIp = args.cidrIp;
this.cidrIpv6 = args.cidrIpv6;
this.destinationPrefixListId = args.destinationPrefixListId;
this.destinationSecurityGroup = args.destinationSecurityGroup;
}
}
export interface SecurityGroupEgressArgs {
readonly fromPort: number;
readonly group: SecurityGroup;
readonly ipProtocol: string;
readonly toPort: number;
readonly cidrIp?: string;
readonly cidrIpv6?: string;
readonly destinationPrefixListId?: string;
readonly destinationSecurityGroup?: SecurityGroup;
}

60
lib/aws/pack/ec2/securityGroupIngress.ts
View file

@ -1,60 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {SecurityGroup} from "./securityGroup";
export class SecurityGroupIngress extends lumi.NamedResource implements SecurityGroupIngressArgs {
public readonly ipProtocol: string;
public readonly cidrIp?: string;
public readonly cidrIpv6?: string;
public readonly fromPort?: number;
public readonly group?: SecurityGroup;
public readonly groupName?: string;
public readonly sourceSecurityGroup?: SecurityGroup;
public readonly sourceSecurityGroupName?: string;
public readonly sourceSecurityGroupOwnerId?: string;
public readonly toPort?: number;
public static get(id: lumi.ID): SecurityGroupIngress {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): SecurityGroupIngress[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: SecurityGroupIngressArgs) {
super(name);
if (lumirt.defaultIfComputed(args.ipProtocol, "") === undefined) {
throw new Error("Missing required argument 'ipProtocol'");
}
this.ipProtocol = args.ipProtocol;
this.cidrIp = args.cidrIp;
this.cidrIpv6 = args.cidrIpv6;
this.fromPort = args.fromPort;
this.group = args.group;
this.groupName = args.groupName;
this.sourceSecurityGroup = args.sourceSecurityGroup;
this.sourceSecurityGroupName = args.sourceSecurityGroupName;
this.sourceSecurityGroupOwnerId = args.sourceSecurityGroupOwnerId;
this.toPort = args.toPort;
}
}
export interface SecurityGroupIngressArgs {
readonly ipProtocol: string;
readonly cidrIp?: string;
readonly cidrIpv6?: string;
readonly fromPort?: number;
readonly group?: SecurityGroup;
readonly groupName?: string;
readonly sourceSecurityGroup?: SecurityGroup;
readonly sourceSecurityGroupName?: string;
readonly sourceSecurityGroupOwnerId?: string;
readonly toPort?: number;
}

45
lib/aws/pack/ec2/subnet.ts
View file

@ -1,45 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {VPC} from "./vpc";
export class Subnet extends lumi.NamedResource implements SubnetArgs {
public readonly cidrBlock: string;
public readonly vpc: VPC;
public readonly availabilityZone?: string;
public mapPublicIpOnLaunch?: boolean;
public static get(id: lumi.ID): Subnet {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Subnet[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: SubnetArgs) {
super(name);
if (lumirt.defaultIfComputed(args.cidrBlock, "") === undefined) {
throw new Error("Missing required argument 'cidrBlock'");
}
this.cidrBlock = args.cidrBlock;
if (lumirt.defaultIfComputed(args.vpc, "") === undefined) {
throw new Error("Missing required argument 'vpc'");
}
this.vpc = args.vpc;
this.availabilityZone = args.availabilityZone;
this.mapPublicIpOnLaunch = args.mapPublicIpOnLaunch;
}
}
export interface SubnetArgs {
readonly cidrBlock: string;
readonly vpc: VPC;
readonly availabilityZone?: string;
mapPublicIpOnLaunch?: boolean;
}

49
lib/aws/pack/ec2/vpc.ts
View file

@ -1,49 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
export let DedicatedTenancy: InstanceTenancy = "dedicated";
export let DefaultTenancy: InstanceTenancy = "default";
export let HostTenancy: InstanceTenancy = "host";
export type InstanceTenancy =
"dedicated" |
"default" |
"host";
export class VPC extends lumi.NamedResource implements VPCArgs {
public readonly cidrBlock: string;
public readonly instanceTenancy?: InstanceTenancy;
public enableDnsSupport?: boolean;
public enableDnsHostnames?: boolean;
public static get(id: lumi.ID): VPC {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): VPC[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: VPCArgs) {
super(name);
if (lumirt.defaultIfComputed(args.cidrBlock, "") === undefined) {
throw new Error("Missing required argument 'cidrBlock'");
}
this.cidrBlock = args.cidrBlock;
this.instanceTenancy = args.instanceTenancy;
this.enableDnsSupport = args.enableDnsSupport;
this.enableDnsHostnames = args.enableDnsHostnames;
}
}
export interface VPCArgs {
readonly cidrBlock: string;
readonly instanceTenancy?: InstanceTenancy;
enableDnsSupport?: boolean;
enableDnsHostnames?: boolean;
}

40
lib/aws/pack/ec2/vpcGatewayAttachment.ts
View file

@ -1,40 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {InternetGateway} from "./internetGateway";
import {VPC} from "./vpc";
export class VPCGatewayAttachment extends lumi.NamedResource implements VPCGatewayAttachmentArgs {
public readonly vpc: VPC;
public readonly internetGateway: InternetGateway;
public static get(id: lumi.ID): VPCGatewayAttachment {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): VPCGatewayAttachment[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: VPCGatewayAttachmentArgs) {
super(name);
if (lumirt.defaultIfComputed(args.vpc, "") === undefined) {
throw new Error("Missing required argument 'vpc'");
}
this.vpc = args.vpc;
if (lumirt.defaultIfComputed(args.internetGateway, "") === undefined) {
throw new Error("Missing required argument 'internetGateway'");
}
this.internetGateway = args.internetGateway;
}
}
export interface VPCGatewayAttachmentArgs {
readonly vpc: VPC;
readonly internetGateway: InternetGateway;
}

39
lib/aws/pack/ec2/vpcPeeringConnection.ts
View file

@ -1,39 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {VPC} from "./vpc";
export class VPCPeeringConnection extends lumi.NamedResource implements VPCPeeringConnectionArgs {
public readonly peerVpc: VPC;
public readonly vpc: VPC;
public static get(id: lumi.ID): VPCPeeringConnection {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): VPCPeeringConnection[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: VPCPeeringConnectionArgs) {
super(name);
if (lumirt.defaultIfComputed(args.peerVpc, "") === undefined) {
throw new Error("Missing required argument 'peerVpc'");
}
this.peerVpc = args.peerVpc;
if (lumirt.defaultIfComputed(args.vpc, "") === undefined) {
throw new Error("Missing required argument 'vpc'");
}
this.vpc = args.vpc;
}
}
export interface VPCPeeringConnectionArgs {
readonly peerVpc: VPC;
readonly vpc: VPC;
}

33
lib/aws/pack/elasticbeanstalk/application.ts
View file

@ -1,33 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
export class Application extends lumi.NamedResource implements ApplicationArgs {
public readonly applicationName?: string;
public description?: string;
public static get(id: lumi.ID): Application {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Application[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args?: ApplicationArgs) {
super(name);
if (args !== undefined) {
this.applicationName = args.applicationName;
this.description = args.description;
}
}
}
export interface ApplicationArgs {
readonly applicationName?: string;
description?: string;
}

46
lib/aws/pack/elasticbeanstalk/applicationVersion.ts
View file

@ -1,46 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {Application} from "./application";
import {Object} from "../s3/object";
export class ApplicationVersion extends lumi.NamedResource implements ApplicationVersionArgs {
public readonly application: Application;
public readonly versionLabel?: string;
public description?: string;
public readonly sourceBundle: Object;
public static get(id: lumi.ID): ApplicationVersion {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): ApplicationVersion[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: ApplicationVersionArgs) {
super(name);
if (lumirt.defaultIfComputed(args.application, "") === undefined) {
throw new Error("Missing required argument 'application'");
}
this.application = args.application;
this.versionLabel = args.versionLabel;
this.description = args.description;
if (lumirt.defaultIfComputed(args.sourceBundle, "") === undefined) {
throw new Error("Missing required argument 'sourceBundle'");
}
this.sourceBundle = args.sourceBundle;
}
}
export interface ApplicationVersionArgs {
readonly application: Application;
readonly versionLabel?: string;
description?: string;
readonly sourceBundle: Object;
}

81
lib/aws/pack/elasticbeanstalk/environment.ts
View file

@ -1,81 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {Application} from "./application";
import {ApplicationVersion} from "./applicationVersion";
export let WebServerTier: Tier = "WebServer::Standard::1.0";
export let WorkerTier: Tier = "Worker::SQS/HTTP::1.0";
export class Environment extends lumi.NamedResource implements EnvironmentArgs {
public readonly application: Application;
public readonly cnamePrefix?: string;
public description?: string;
public readonly environmentName?: string;
public optionSettings?: OptionSetting[];
public readonly solutionStackName?: string;
public readonly tags?: Tag[];
public templateName?: string;
public readonly tier?: Tier;
public version?: ApplicationVersion;
public endpointURL: string;
public allOptionSettings: OptionSetting[];
public static get(id: lumi.ID): Environment {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Environment[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: EnvironmentArgs) {
super(name);
if (lumirt.defaultIfComputed(args.application, "") === undefined) {
throw new Error("Missing required argument 'application'");
}
this.application = args.application;
this.cnamePrefix = args.cnamePrefix;
this.description = args.description;
this.environmentName = args.environmentName;
this.optionSettings = args.optionSettings;
this.solutionStackName = args.solutionStackName;
this.tags = args.tags;
this.templateName = args.templateName;
this.tier = args.tier;
this.version = args.version;
}
}
export interface EnvironmentArgs {
readonly application: Application;
readonly cnamePrefix?: string;
description?: string;
readonly environmentName?: string;
optionSettings?: OptionSetting[];
readonly solutionStackName?: string;
readonly tags?: Tag[];
templateName?: string;
readonly tier?: Tier;
version?: ApplicationVersion;
}
export interface OptionSetting {
namespace: string;
optionName: string;
value: string;
}
export interface Tag {
key: string;
value: string;
}
export type Tier =
"WebServer::Standard::1.0" |
"Worker::SQS/HTTP::1.0";

6
lib/aws/pack/elasticbeanstalk/index.ts
View file

@ -1,6 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
export * from "./application";
export * from "./applicationVersion";
export * from "./environment";

264
lib/aws/pack/iam/awsmanagedpolicies.ts
View file

@ -1,264 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
/* tslint:disable:max-line-length ordered-imports variable-name */
import {ARN} from "../types";
export const AWSAccountActivityAccess: ARN = "arn:aws:iam::aws:policy/AWSAccountActivityAccess";
export const AWSAccountUsageReportAccess: ARN = "arn:aws:iam::aws:policy/AWSAccountUsageReportAccess";
export const AWSAgentlessDiscoveryService: ARN = "arn:aws:iam::aws:policy/AWSAgentlessDiscoveryService";
export const AWSApplicationDiscoveryAgentAccess: ARN = "arn:aws:iam::aws:policy/AWSApplicationDiscoveryAgentAccess";
export const AWSApplicationDiscoveryServiceFullAccess: ARN = "arn:aws:iam::aws:policy/AWSApplicationDiscoveryServiceFullAccess";
export const AWSBatchFullAccess: ARN = "arn:aws:iam::aws:policy/AWSBatchFullAccess";
export const AWSBatchServiceRole: ARN = "arn:aws:iam::aws:policy/service-role/AWSBatchServiceRole";
export const AWSCertificateManagerFullAccess: ARN = "arn:aws:iam::aws:policy/AWSCertificateManagerFullAccess";
export const AWSCertificateManagerReadOnly: ARN = "arn:aws:iam::aws:policy/AWSCertificateManagerReadOnly";
export const AWSCloudFormationReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSCloudFormationReadOnlyAccess";
export const AWSCloudHSMFullAccess: ARN = "arn:aws:iam::aws:policy/AWSCloudHSMFullAccess";
export const AWSCloudHSMReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSCloudHSMReadOnlyAccess";
export const AWSCloudHSMRole: ARN = "arn:aws:iam::aws:policy/service-role/AWSCloudHSMRole";
export const AWSCloudTrailFullAccess: ARN = "arn:aws:iam::aws:policy/AWSCloudTrailFullAccess";
export const AWSCloudTrailReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSCloudTrailReadOnlyAccess";
export const AWSCodeBuildAdminAccess: ARN = "arn:aws:iam::aws:policy/AWSCodeBuildAdminAccess";
export const AWSCodeBuildDeveloperAccess: ARN = "arn:aws:iam::aws:policy/AWSCodeBuildDeveloperAccess";
export const AWSCodeBuildReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSCodeBuildReadOnlyAccess";
export const AWSCodeCommitFullAccess: ARN = "arn:aws:iam::aws:policy/AWSCodeCommitFullAccess";
export const AWSCodeCommitPowerUser: ARN = "arn:aws:iam::aws:policy/AWSCodeCommitPowerUser";
export const AWSCodeCommitReadOnly: ARN = "arn:aws:iam::aws:policy/AWSCodeCommitReadOnly";
export const AWSCodeDeployDeployerAccess: ARN = "arn:aws:iam::aws:policy/AWSCodeDeployDeployerAccess";
export const AWSCodeDeployFullAccess: ARN = "arn:aws:iam::aws:policy/AWSCodeDeployFullAccess";
export const AWSCodeDeployReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSCodeDeployReadOnlyAccess";
export const AWSCodeDeployRole: ARN = "arn:aws:iam::aws:policy/service-role/AWSCodeDeployRole";
export const AWSCodePipelineApproverAccess: ARN = "arn:aws:iam::aws:policy/AWSCodePipelineApproverAccess";
export const AWSCodePipelineCustomActionAccess: ARN = "arn:aws:iam::aws:policy/AWSCodePipelineCustomActionAccess";
export const AWSCodePipelineFullAccess: ARN = "arn:aws:iam::aws:policy/AWSCodePipelineFullAccess";
export const AWSCodePipelineReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSCodePipelineReadOnlyAccess";
export const AWSCodeStarFullAccess: ARN = "arn:aws:iam::aws:policy/AWSCodeStarFullAccess";
export const AWSCodeStarServiceRole: ARN = "arn:aws:iam::aws:policy/service-role/AWSCodeStarServiceRole";
export const AWSConfigRole: ARN = "arn:aws:iam::aws:policy/service-role/AWSConfigRole";
export const AWSConfigRulesExecutionRole: ARN = "arn:aws:iam::aws:policy/service-role/AWSConfigRulesExecutionRole";
export const AWSConfigUserAccess: ARN = "arn:aws:iam::aws:policy/AWSConfigUserAccess";
export const AWSConnector: ARN = "arn:aws:iam::aws:policy/AWSConnector";
export const AWSDataPipelineRole: ARN = "arn:aws:iam::aws:policy/service-role/AWSDataPipelineRole";
export const AWSDataPipeline_FullAccess: ARN = "arn:aws:iam::aws:policy/AWSDataPipeline_FullAccess";
export const AWSDataPipeline_PowerUser: ARN = "arn:aws:iam::aws:policy/AWSDataPipeline_PowerUser";
export const AWSDeviceFarmFullAccess: ARN = "arn:aws:iam::aws:policy/AWSDeviceFarmFullAccess";
export const AWSDirectConnectFullAccess: ARN = "arn:aws:iam::aws:policy/AWSDirectConnectFullAccess";
export const AWSDirectConnectReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSDirectConnectReadOnlyAccess";
export const AWSDirectoryServiceFullAccess: ARN = "arn:aws:iam::aws:policy/AWSDirectoryServiceFullAccess";
export const AWSDirectoryServiceReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSDirectoryServiceReadOnlyAccess";
export const AWSElasticBeanstalkCustomPlatformforEC2Role: ARN = "arn:aws:iam::aws:policy/AWSElasticBeanstalkCustomPlatformforEC2Role";
export const AWSElasticBeanstalkEnhancedHealth: ARN = "arn:aws:iam::aws:policy/service-role/AWSElasticBeanstalkEnhancedHealth";
export const AWSElasticBeanstalkFullAccess: ARN = "arn:aws:iam::aws:policy/AWSElasticBeanstalkFullAccess";
export const AWSElasticBeanstalkMulticontainerDocker: ARN = "arn:aws:iam::aws:policy/AWSElasticBeanstalkMulticontainerDocker";
export const AWSElasticBeanstalkReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSElasticBeanstalkReadOnlyAccess";
export const AWSElasticBeanstalkService: ARN = "arn:aws:iam::aws:policy/service-role/AWSElasticBeanstalkService";
export const AWSElasticBeanstalkWebTier: ARN = "arn:aws:iam::aws:policy/AWSElasticBeanstalkWebTier";
export const AWSElasticBeanstalkWorkerTier: ARN = "arn:aws:iam::aws:policy/AWSElasticBeanstalkWorkerTier";
export const AWSGreengrassFullAccess: ARN = "arn:aws:iam::aws:policy/AWSGreengrassFullAccess";
export const AWSGreengrassResourceAccessRolePolicy: ARN = "arn:aws:iam::aws:policy/service-role/AWSGreengrassResourceAccessRolePolicy";
export const AWSHealthFullAccess: ARN = "arn:aws:iam::aws:policy/AWSHealthFullAccess";
export const AWSImportExportFullAccess: ARN = "arn:aws:iam::aws:policy/AWSImportExportFullAccess";
export const AWSImportExportReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSImportExportReadOnlyAccess";
export const AWSIoTConfigAccess: ARN = "arn:aws:iam::aws:policy/AWSIoTConfigAccess";
export const AWSIoTConfigReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSIoTConfigReadOnlyAccess";
export const AWSIoTDataAccess: ARN = "arn:aws:iam::aws:policy/AWSIoTDataAccess";
export const AWSIoTFullAccess: ARN = "arn:aws:iam::aws:policy/AWSIoTFullAccess";
export const AWSIoTLogging: ARN = "arn:aws:iam::aws:policy/service-role/AWSIoTLogging";
export const AWSIoTRuleActions: ARN = "arn:aws:iam::aws:policy/service-role/AWSIoTRuleActions";
export const AWSKeyManagementServicePowerUser: ARN = "arn:aws:iam::aws:policy/AWSKeyManagementServicePowerUser";
export const AWSLambdaBasicExecutionRole: ARN = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole";
export const AWSLambdaDynamoDBExecutionRole: ARN = "arn:aws:iam::aws:policy/service-role/AWSLambdaDynamoDBExecutionRole";
export const AWSLambdaENIManagementAccess: ARN = "arn:aws:iam::aws:policy/service-role/AWSLambdaENIManagementAccess";
export const AWSLambdaExecute: ARN = "arn:aws:iam::aws:policy/AWSLambdaExecute";
export const AWSLambdaFullAccess: ARN = "arn:aws:iam::aws:policy/AWSLambdaFullAccess";
export const AWSLambdaInvocationDynamoDB: ARN = "arn:aws:iam::aws:policy/AWSLambdaInvocation-DynamoDB";
export const AWSLambdaKinesisExecutionRole: ARN = "arn:aws:iam::aws:policy/service-role/AWSLambdaKinesisExecutionRole";
export const AWSLambdaReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSLambdaReadOnlyAccess";
export const AWSLambdaRole: ARN = "arn:aws:iam::aws:policy/service-role/AWSLambdaRole";
export const AWSLambdaVPCAccessExecutionRole: ARN = "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole";
export const AWSMarketplaceFullAccess: ARN = "arn:aws:iam::aws:policy/AWSMarketplaceFullAccess";
export const AWSMarketplaceGetEntitlements: ARN = "arn:aws:iam::aws:policy/AWSMarketplaceGetEntitlements";
export const AWSMarketplaceManageSubscriptions: ARN = "arn:aws:iam::aws:policy/AWSMarketplaceManageSubscriptions";
export const AWSMarketplaceMeteringFullAccess: ARN = "arn:aws:iam::aws:policy/AWSMarketplaceMeteringFullAccess";
export const AWSMarketplaceReadonly: ARN = "arn:aws:iam::aws:policy/AWSMarketplaceRead-only";
export const AWSMobileHub_FullAccess: ARN = "arn:aws:iam::aws:policy/AWSMobileHub_FullAccess";
export const AWSMobileHub_ReadOnly: ARN = "arn:aws:iam::aws:policy/AWSMobileHub_ReadOnly";
export const AWSMobileHub_ServiceUseOnly: ARN = "arn:aws:iam::aws:policy/service-role/AWSMobileHub_ServiceUseOnly";
export const AWSOpsWorksCMInstanceProfileRole: ARN = "arn:aws:iam::aws:policy/AWSOpsWorksCMInstanceProfileRole";
export const AWSOpsWorksCMServiceRole: ARN = "arn:aws:iam::aws:policy/service-role/AWSOpsWorksCMServiceRole";
export const AWSOpsWorksCloudWatchLogs: ARN = "arn:aws:iam::aws:policy/AWSOpsWorksCloudWatchLogs";
export const AWSOpsWorksFullAccess: ARN = "arn:aws:iam::aws:policy/AWSOpsWorksFullAccess";
export const AWSOpsWorksInstanceRegistration: ARN = "arn:aws:iam::aws:policy/AWSOpsWorksInstanceRegistration";
export const AWSOpsWorksRegisterCLI: ARN = "arn:aws:iam::aws:policy/AWSOpsWorksRegisterCLI";
export const AWSOpsWorksRole: ARN = "arn:aws:iam::aws:policy/service-role/AWSOpsWorksRole";
export const AWSQuickSightDescribeRDS: ARN = "arn:aws:iam::aws:policy/service-role/AWSQuickSightDescribeRDS";
export const AWSQuickSightDescribeRedshift: ARN = "arn:aws:iam::aws:policy/service-role/AWSQuickSightDescribeRedshift";
export const AWSQuickSightListIAM: ARN = "arn:aws:iam::aws:policy/service-role/AWSQuickSightListIAM";
export const AWSQuicksightAthenaAccess: ARN = "arn:aws:iam::aws:policy/service-role/AWSQuicksightAthenaAccess";
export const AWSStepFunctionsConsoleFullAccess: ARN = "arn:aws:iam::aws:policy/AWSStepFunctionsConsoleFullAccess";
export const AWSStepFunctionsFullAccess: ARN = "arn:aws:iam::aws:policy/AWSStepFunctionsFullAccess";
export const AWSStepFunctionsReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSStepFunctionsReadOnlyAccess";
export const AWSStorageGatewayFullAccess: ARN = "arn:aws:iam::aws:policy/AWSStorageGatewayFullAccess";
export const AWSStorageGatewayReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSStorageGatewayReadOnlyAccess";
export const AWSSupportAccess: ARN = "arn:aws:iam::aws:policy/AWSSupportAccess";
export const AWSWAFFullAccess: ARN = "arn:aws:iam::aws:policy/AWSWAFFullAccess";
export const AWSWAFReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSWAFReadOnlyAccess";
export const AWSXrayFullAccess: ARN = "arn:aws:iam::aws:policy/AWSXrayFullAccess";
export const AWSXrayReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSXrayReadOnlyAccess";
export const AWSXrayWriteOnlyAccess: ARN = "arn:aws:iam::aws:policy/AWSXrayWriteOnlyAccess";
export const AdministratorAccess: ARN = "arn:aws:iam::aws:policy/AdministratorAccess";
export const AmazonAPIGatewayAdministrator: ARN = "arn:aws:iam::aws:policy/AmazonAPIGatewayAdministrator";
export const AmazonAPIGatewayInvokeFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonAPIGatewayInvokeFullAccess";
export const AmazonAPIGatewayPushToCloudWatchLogs: ARN = "arn:aws:iam::aws:policy/service-role/AmazonAPIGatewayPushToCloudWatchLogs";
export const AmazonAppStreamFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonAppStreamFullAccess";
export const AmazonAppStreamReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonAppStreamReadOnlyAccess";
export const AmazonAppStreamServiceAccess: ARN = "arn:aws:iam::aws:policy/service-role/AmazonAppStreamServiceAccess";
export const AmazonAthenaFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonAthenaFullAccess";
export const AmazonCloudDirectoryFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonCloudDirectoryFullAccess";
export const AmazonCloudDirectoryReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonCloudDirectoryReadOnlyAccess";
export const AmazonCognitoDeveloperAuthenticatedIdentities: ARN = "arn:aws:iam::aws:policy/AmazonCognitoDeveloperAuthenticatedIdentities";
export const AmazonCognitoPowerUser: ARN = "arn:aws:iam::aws:policy/AmazonCognitoPowerUser";
export const AmazonCognitoReadOnly: ARN = "arn:aws:iam::aws:policy/AmazonCognitoReadOnly";
export const AmazonDMSCloudWatchLogsRole: ARN = "arn:aws:iam::aws:policy/service-role/AmazonDMSCloudWatchLogsRole";
export const AmazonDMSRedshiftS3Role: ARN = "arn:aws:iam::aws:policy/service-role/AmazonDMSRedshiftS3Role";
export const AmazonDMSVPCManagementRole: ARN = "arn:aws:iam::aws:policy/service-role/AmazonDMSVPCManagementRole";
export const AmazonDRSVPCManagement: ARN = "arn:aws:iam::aws:policy/AmazonDRSVPCManagement";
export const AmazonDynamoDBFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonDynamoDBFullAccess";
export const AmazonDynamoDBFullAccesswithDataPipeline: ARN = "arn:aws:iam::aws:policy/AmazonDynamoDBFullAccesswithDataPipeline";
export const AmazonDynamoDBReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonDynamoDBReadOnlyAccess";
export const AmazonEC2ContainerRegistryFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess";
export const AmazonEC2ContainerRegistryPowerUser: ARN = "arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryPowerUser";
export const AmazonEC2ContainerRegistryReadOnly: ARN = "arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly";
export const AmazonEC2ContainerServiceAutoscaleRole: ARN = "arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceAutoscaleRole";
export const AmazonEC2ContainerServiceFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonEC2ContainerServiceFullAccess";
export const AmazonEC2ContainerServiceRole: ARN = "arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceRole";
export const AmazonEC2ContainerServiceforEC2Role: ARN = "arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role";
export const AmazonEC2FullAccess: ARN = "arn:aws:iam::aws:policy/AmazonEC2FullAccess";
export const AmazonEC2ReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonEC2ReadOnlyAccess";
export const AmazonEC2ReportsAccess: ARN = "arn:aws:iam::aws:policy/AmazonEC2ReportsAccess";
export const AmazonEC2RoleforAWSCodeDeploy: ARN = "arn:aws:iam::aws:policy/service-role/AmazonEC2RoleforAWSCodeDeploy";
export const AmazonEC2RoleforDataPipelineRole: ARN = "arn:aws:iam::aws:policy/service-role/AmazonEC2RoleforDataPipelineRole";
export const AmazonEC2RoleforSSM: ARN = "arn:aws:iam::aws:policy/service-role/AmazonEC2RoleforSSM";
export const AmazonEC2SpotFleetAutoscaleRole: ARN = "arn:aws:iam::aws:policy/service-role/AmazonEC2SpotFleetAutoscaleRole";
export const AmazonEC2SpotFleetRole: ARN = "arn:aws:iam::aws:policy/service-role/AmazonEC2SpotFleetRole";
export const AmazonESFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonESFullAccess";
export const AmazonESReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonESReadOnlyAccess";
export const AmazonElastiCacheFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonElastiCacheFullAccess";
export const AmazonElastiCacheReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonElastiCacheReadOnlyAccess";
export const AmazonElasticFileSystemFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonElasticFileSystemFullAccess";
export const AmazonElasticFileSystemReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonElasticFileSystemReadOnlyAccess";
export const AmazonElasticMapReduceFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonElasticMapReduceFullAccess";
export const AmazonElasticMapReduceReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonElasticMapReduceReadOnlyAccess";
export const AmazonElasticMapReduceRole: ARN = "arn:aws:iam::aws:policy/service-role/AmazonElasticMapReduceRole";
export const AmazonElasticMapReduceforAutoScalingRole: ARN = "arn:aws:iam::aws:policy/service-role/AmazonElasticMapReduceforAutoScalingRole";
export const AmazonElasticMapReduceforEC2Role: ARN = "arn:aws:iam::aws:policy/service-role/AmazonElasticMapReduceforEC2Role";
export const AmazonElasticTranscoderFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonElasticTranscoderFullAccess";
export const AmazonElasticTranscoderJobsSubmitter: ARN = "arn:aws:iam::aws:policy/AmazonElasticTranscoderJobsSubmitter";
export const AmazonElasticTranscoderReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonElasticTranscoderReadOnlyAccess";
export const AmazonElasticTranscoderRole: ARN = "arn:aws:iam::aws:policy/service-role/AmazonElasticTranscoderRole";
export const AmazonGlacierFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonGlacierFullAccess";
export const AmazonGlacierReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonGlacierReadOnlyAccess";
export const AmazonInspectorFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonInspectorFullAccess";
export const AmazonInspectorReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonInspectorReadOnlyAccess";
export const AmazonKinesisAnalyticsFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonKinesisAnalyticsFullAccess";
export const AmazonKinesisAnalyticsReadOnly: ARN = "arn:aws:iam::aws:policy/AmazonKinesisAnalyticsReadOnly";
export const AmazonKinesisFirehoseFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonKinesisFirehoseFullAccess";
export const AmazonKinesisFirehoseReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonKinesisFirehoseReadOnlyAccess";
export const AmazonKinesisFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonKinesisFullAccess";
export const AmazonKinesisReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonKinesisReadOnlyAccess";
export const AmazonLexFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonLexFullAccess";
export const AmazonLexReadOnly: ARN = "arn:aws:iam::aws:policy/AmazonLexReadOnly";
export const AmazonLexRunBotsOnly: ARN = "arn:aws:iam::aws:policy/AmazonLexRunBotsOnly";
export const AmazonMachineLearningBatchPredictionsAccess: ARN = "arn:aws:iam::aws:policy/AmazonMachineLearningBatchPredictionsAccess";
export const AmazonMachineLearningCreateOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonMachineLearningCreateOnlyAccess";
export const AmazonMachineLearningFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonMachineLearningFullAccess";
export const AmazonMachineLearningManageRealTimeEndpointOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonMachineLearningManageRealTimeEndpointOnlyAccess";
export const AmazonMachineLearningReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonMachineLearningReadOnlyAccess";
export const AmazonMachineLearningRealTimePredictionOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonMachineLearningRealTimePredictionOnlyAccess";
export const AmazonMachineLearningRoleforRedshiftDataSource: ARN = "arn:aws:iam::aws:policy/service-role/AmazonMachineLearningRoleforRedshiftDataSource";
export const AmazonMechanicalTurkFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonMechanicalTurkFullAccess";
export const AmazonMechanicalTurkReadOnly: ARN = "arn:aws:iam::aws:policy/AmazonMechanicalTurkReadOnly";
export const AmazonMobileAnalyticsFinancialReportAccess: ARN = "arn:aws:iam::aws:policy/AmazonMobileAnalyticsFinancialReportAccess";
export const AmazonMobileAnalyticsFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonMobileAnalyticsFullAccess";
export const AmazonMobileAnalyticsNonfinancialReportAccess: ARN = "arn:aws:iam::aws:policy/AmazonMobileAnalyticsNon-financialReportAccess";
export const AmazonMobileAnalyticsWriteOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonMobileAnalyticsWriteOnlyAccess";
export const AmazonPollyFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonPollyFullAccess";
export const AmazonPollyReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonPollyReadOnlyAccess";
export const AmazonRDSDirectoryServiceAccess: ARN = "arn:aws:iam::aws:policy/service-role/AmazonRDSDirectoryServiceAccess";
export const AmazonRDSEnhancedMonitoringRole: ARN = "arn:aws:iam::aws:policy/service-role/AmazonRDSEnhancedMonitoringRole";
export const AmazonRDSFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonRDSFullAccess";
export const AmazonRDSReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonRDSReadOnlyAccess";
export const AmazonRedshiftFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonRedshiftFullAccess";
export const AmazonRedshiftReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonRedshiftReadOnlyAccess";
export const AmazonRekognitionFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonRekognitionFullAccess";
export const AmazonRekognitionReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonRekognitionReadOnlyAccess";
export const AmazonRoute53DomainsFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonRoute53DomainsFullAccess";
export const AmazonRoute53DomainsReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonRoute53DomainsReadOnlyAccess";
export const AmazonRoute53FullAccess: ARN = "arn:aws:iam::aws:policy/AmazonRoute53FullAccess";
export const AmazonRoute53ReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonRoute53ReadOnlyAccess";
export const AmazonS3FullAccess: ARN = "arn:aws:iam::aws:policy/AmazonS3FullAccess";
export const AmazonS3ReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess";
export const AmazonSESFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonSESFullAccess";
export const AmazonSESReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonSESReadOnlyAccess";
export const AmazonSNSFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonSNSFullAccess";
export const AmazonSNSReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonSNSReadOnlyAccess";
export const AmazonSNSRole: ARN = "arn:aws:iam::aws:policy/service-role/AmazonSNSRole";
export const AmazonSQSFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonSQSFullAccess";
export const AmazonSQSReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonSQSReadOnlyAccess";
export const AmazonSSMAutomationRole: ARN = "arn:aws:iam::aws:policy/service-role/AmazonSSMAutomationRole";
export const AmazonSSMFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonSSMFullAccess";
export const AmazonSSMMaintenanceWindowRole: ARN = "arn:aws:iam::aws:policy/service-role/AmazonSSMMaintenanceWindowRole";
export const AmazonSSMReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonSSMReadOnlyAccess";
export const AmazonVPCFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonVPCFullAccess";
export const AmazonVPCReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonVPCReadOnlyAccess";
export const AmazonWorkMailFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonWorkMailFullAccess";
export const AmazonWorkMailReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonWorkMailReadOnlyAccess";
export const AmazonWorkSpacesAdmin: ARN = "arn:aws:iam::aws:policy/AmazonWorkSpacesAdmin";
export const AmazonWorkSpacesApplicationManagerAdminAccess: ARN = "arn:aws:iam::aws:policy/AmazonWorkSpacesApplicationManagerAdminAccess";
export const AmazonZocaloFullAccess: ARN = "arn:aws:iam::aws:policy/AmazonZocaloFullAccess";
export const AmazonZocaloReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AmazonZocaloReadOnlyAccess";
export const ApplicationAutoScalingForAmazonAppStreamAccess: ARN = "arn:aws:iam::aws:policy/service-role/ApplicationAutoScalingForAmazonAppStreamAccess";
export const AutoScalingConsoleFullAccess: ARN = "arn:aws:iam::aws:policy/AutoScalingConsoleFullAccess";
export const AutoScalingConsoleReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AutoScalingConsoleReadOnlyAccess";
export const AutoScalingFullAccess: ARN = "arn:aws:iam::aws:policy/AutoScalingFullAccess";
export const AutoScalingNotificationAccessRole: ARN = "arn:aws:iam::aws:policy/service-role/AutoScalingNotificationAccessRole";
export const AutoScalingReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/AutoScalingReadOnlyAccess";
export const Billing: ARN = "arn:aws:iam::aws:policy/job-function/Billing";
export const CloudFrontFullAccess: ARN = "arn:aws:iam::aws:policy/CloudFrontFullAccess";
export const CloudFrontReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/CloudFrontReadOnlyAccess";
export const CloudSearchFullAccess: ARN = "arn:aws:iam::aws:policy/CloudSearchFullAccess";
export const CloudSearchReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/CloudSearchReadOnlyAccess";
export const CloudWatchActionsEC2Access: ARN = "arn:aws:iam::aws:policy/CloudWatchActionsEC2Access";
export const CloudWatchEventsBuiltInTargetExecutionAccess: ARN = "arn:aws:iam::aws:policy/service-role/CloudWatchEventsBuiltInTargetExecutionAccess";
export const CloudWatchEventsFullAccess: ARN = "arn:aws:iam::aws:policy/CloudWatchEventsFullAccess";
export const CloudWatchEventsInvocationAccess: ARN = "arn:aws:iam::aws:policy/service-role/CloudWatchEventsInvocationAccess";
export const CloudWatchEventsReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/CloudWatchEventsReadOnlyAccess";
export const CloudWatchFullAccess: ARN = "arn:aws:iam::aws:policy/CloudWatchFullAccess";
export const CloudWatchLogsFullAccess: ARN = "arn:aws:iam::aws:policy/CloudWatchLogsFullAccess";
export const CloudWatchLogsReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/CloudWatchLogsReadOnlyAccess";
export const CloudWatchReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/CloudWatchReadOnlyAccess";
export const DataScientist: ARN = "arn:aws:iam::aws:policy/job-function/DataScientist";
export const DatabaseAdministrator: ARN = "arn:aws:iam::aws:policy/job-function/DatabaseAdministrator";
export const IAMFullAccess: ARN = "arn:aws:iam::aws:policy/IAMFullAccess";
export const IAMReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/IAMReadOnlyAccess";
export const IAMSelfManageServiceSpecificCredentials: ARN = "arn:aws:iam::aws:policy/IAMSelfManageServiceSpecificCredentials";
export const IAMUserChangePassword: ARN = "arn:aws:iam::aws:policy/IAMUserChangePassword";
export const IAMUserSSHKeys: ARN = "arn:aws:iam::aws:policy/IAMUserSSHKeys";
export const NetworkAdministrator: ARN = "arn:aws:iam::aws:policy/job-function/NetworkAdministrator";
export const PowerUserAccess: ARN = "arn:aws:iam::aws:policy/PowerUserAccess";
export const RDSCloudHsmAuthorizationRole: ARN = "arn:aws:iam::aws:policy/service-role/RDSCloudHsmAuthorizationRole";
export const ReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/ReadOnlyAccess";
export const ResourceGroupsandTagEditorFullAccess: ARN = "arn:aws:iam::aws:policy/ResourceGroupsandTagEditorFullAccess";
export const ResourceGroupsandTagEditorReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/ResourceGroupsandTagEditorReadOnlyAccess";
export const SecurityAudit: ARN = "arn:aws:iam::aws:policy/SecurityAudit";
export const ServerMigrationConnector: ARN = "arn:aws:iam::aws:policy/ServerMigrationConnector";
export const ServerMigrationServiceRole: ARN = "arn:aws:iam::aws:policy/service-role/ServerMigrationServiceRole";
export const ServiceCatalogAdminFullAccess: ARN = "arn:aws:iam::aws:policy/ServiceCatalogAdminFullAccess";
export const ServiceCatalogAdminReadOnlyAccess: ARN = "arn:aws:iam::aws:policy/ServiceCatalogAdminReadOnlyAccess";
export const ServiceCatalogEndUserAccess: ARN = "arn:aws:iam::aws:policy/ServiceCatalogEndUserAccess";
export const ServiceCatalogEndUserFullAccess: ARN = "arn:aws:iam::aws:policy/ServiceCatalogEndUserFullAccess";
export const SimpleWorkflowFullAccess: ARN = "arn:aws:iam::aws:policy/SimpleWorkflowFullAccess";
export const SupportUser: ARN = "arn:aws:iam::aws:policy/job-function/SupportUser";
export const SystemAdministrator: ARN = "arn:aws:iam::aws:policy/job-function/SystemAdministrator";
export const VMImportExportRoleForAWSConnector: ARN = "arn:aws:iam::aws:policy/service-role/VMImportExportRoleForAWSConnector";
export const ViewOnlyAccess: ARN = "arn:aws:iam::aws:policy/job-function/ViewOnlyAccess";

41
lib/aws/pack/iam/group.ts
View file

@ -1,41 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {InlinePolicy, Policy} from "./policy";
export class Group extends lumi.NamedResource implements GroupArgs {
public readonly groupName?: string;
public managedPolicies?: Policy[];
public path?: string;
public policies?: InlinePolicy;
public static get(id: lumi.ID): Group {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Group[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args?: GroupArgs) {
super(name);
if (args !== undefined) {
this.groupName = args.groupName;
this.managedPolicies = args.managedPolicies;
this.path = args.path;
this.policies = args.policies;
}
}
}
export interface GroupArgs {
readonly groupName?: string;
managedPolicies?: Policy[];
path?: string;
policies?: InlinePolicy;
}

9
lib/aws/pack/iam/index.ts
View file

@ -1,9 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
export * from "./awsmanagedpolicies";
export * from "./group";
export * from "./instanceprofile";
export * from "./policy";
export * from "./role";
export * from "./user";

41
lib/aws/pack/iam/instanceprofile.ts
View file

@ -1,41 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {ARN} from "../types";
import {Role} from "./role";
export class InstanceProfile extends lumi.NamedResource implements InstanceProfileArgs {
public readonly path?: string;
public readonly instanceProfileName?: string;
public roles: Role[];
public arn: ARN;
public static get(id: lumi.ID): InstanceProfile {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): InstanceProfile[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: InstanceProfileArgs) {
super(name);
this.path = args.path;
this.instanceProfileName = args.instanceProfileName;
if (lumirt.defaultIfComputed(args.roles, "") === undefined) {
throw new Error("Missing required argument 'roles'");
}
this.roles = args.roles;
}
}
export interface InstanceProfileArgs {
readonly path?: string;
readonly instanceProfileName?: string;
roles: Role[];
}

55
lib/aws/pack/iam/policy.ts
View file

@ -1,55 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {Group} from "./group";
import {Role} from "./role";
import {User} from "./user";
export interface InlinePolicy {
policyDocument: any;
policyName: string;
}
export class Policy extends lumi.NamedResource implements PolicyArgs {
public policyDocument: any;
public policyName: string;
public groups?: Group[];
public roles?: Role[];
public users?: User[];
public static get(id: lumi.ID): Policy {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Policy[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: PolicyArgs) {
super(name);
if (lumirt.defaultIfComputed(args.policyDocument, "") === undefined) {
throw new Error("Missing required argument 'policyDocument'");
}
this.policyDocument = args.policyDocument;
if (lumirt.defaultIfComputed(args.policyName, "") === undefined) {
throw new Error("Missing required argument 'policyName'");
}
this.policyName = args.policyName;
this.groups = args.groups;
this.roles = args.roles;
this.users = args.users;
}
}
export interface PolicyArgs {
policyDocument: any;
policyName: string;
groups?: Group[];
roles?: Role[];
users?: User[];
}

47
lib/aws/pack/iam/role.ts
View file

@ -1,47 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {ARN} from "../types";
import {InlinePolicy} from "./policy";
export class Role extends lumi.NamedResource implements RoleArgs {
public assumeRolePolicyDocument: any;
public readonly path?: string;
public readonly roleName?: string;
public managedPolicyARNs?: ARN[];
public policies?: InlinePolicy[];
public arn: ARN;
public static get(id: lumi.ID): Role {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): Role[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args: RoleArgs) {
super(name);
if (lumirt.defaultIfComputed(args.assumeRolePolicyDocument, "") === undefined) {
throw new Error("Missing required argument 'assumeRolePolicyDocument'");
}
this.assumeRolePolicyDocument = args.assumeRolePolicyDocument;
this.path = args.path;
this.roleName = args.roleName;
this.managedPolicyARNs = args.managedPolicyARNs;
this.policies = args.policies;
}
}
export interface RoleArgs {
assumeRolePolicyDocument: any;
readonly path?: string;
readonly roleName?: string;
managedPolicyARNs?: ARN[];
policies?: InlinePolicy[];
}

53
lib/aws/pack/iam/user.ts
View file

@ -1,53 +0,0 @@
// *** WARNING: this file was generated by the Lumi IDL Compiler (LUMIDL). ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
/* tslint:disable:ordered-imports variable-name */
import * as lumi from "@lumi/lumi";
import * as lumirt from "@lumi/lumirt";
import {Group} from "./group";
import {InlinePolicy, Policy} from "./policy";
export interface LoginProfile {
password: string;
passwordResetRequired?: boolean;
}
export class User extends lumi.NamedResource implements UserArgs {
public readonly userName?: string;
public groups?: Group[];
public loginProfile?: LoginProfile;
public managedPolicies?: Policy[];
public path?: string;
public policies?: InlinePolicy[];
public static get(id: lumi.ID): User {
return <any>undefined; // functionality provided by the runtime
}
public static query(q: any): User[] {
return <any>undefined; // functionality provided by the runtime
}
constructor(name: string, args?: UserArgs) {
super(name);
if (args !== undefined) {
this.userName = args.userName;
this.groups = args.groups;
this.loginProfile = args.loginProfile;
this.managedPolicies = args.managedPolicies;
this.path = args.path;
this.policies = args.policies;
}
}
}
export interface UserArgs {
readonly userName?: string;
groups?: Group[];
loginProfile?: LoginProfile;
managedPolicies?: Policy[];
path?: string;
policies?: InlinePolicy[];
}

19
lib/aws/pack/index.ts
View file

@ -1,19 +0,0 @@
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
export * from "./types";
import * as apigateway from "./apigateway";
import * as cloudwatch from "./cloudwatch";
import * as config from "./config";
import * as dynamodb from "./dynamodb";
import * as ec2 from "./ec2";
import * as elasticbeanstalk from "./elasticbeanstalk";
import * as iam from "./iam";
import * as kms from "./kms";
import * as lambda from "./lambda";
import * as s3 from "./s3";
import * as serverless from "./serverless";
import * as sns from "./sns";
import * as sqs from "./sqs";
export {apigateway, cloudwatch, config, dynamodb, ec2, elasticbeanstalk, iam, kms, lambda, s3, serverless, sns, sqs};

Some files were not shown because too many files have changed in this diff Show more