// NewCustomResourceProvisioner returns a new CustomResourceProvisioner with an
// sqs client configured from config.
func NewCustomResourceProvisioner(db *sql.DB, config client.ConfigProvider) *CustomResourceProvisioner {
p := &CustomResourceProvisioner{
Provisioners: make(map[string]customresources.Provisioner),
sendResponse: customresources.SendResponse,
sqs: sqs.New(config),
}
p.add("Custom::InstancePort", &InstancePortsProvisioner{
ports: lb.NewDBPortAllocator(db),
})
p.add("Custom::ECSService", &ECSServiceResource{
ecs: ecs.New(config),
})
store := &dbEnvironmentStore{db}
p.add("Custom::ECSEnvironment", newECSEnvironmentProvisioner(&ECSEnvironmentResource{
environmentStore: store,
}))
p.add("Custom::ECSTaskDefinition", newECSTaskDefinitionProvisioner(&ECSTaskDefinitionResource{
ecs: ecs.New(config),
environmentStore: store,
}))
return p
}
func init() {
if iid, err := ec2.GetInstanceIdentityDocument(); err == nil {
ECS = ecs.New(&aws.Config{Region: iid.Region})
} else {
ECS = ecs.New(nil)
}
Cluster = "ecs-functional-tests"
if envCluster := os.Getenv("ECS_CLUSTER"); envCluster != "" {
Cluster = envCluster
}
}
func ExampleECS_DescribeTasks() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := ecs.New(sess)
params := &ecs.DescribeTasksInput{
Tasks: []*string{ // Required
aws.String("String"), // Required
// More values...
},
Cluster: aws.String("String"),
}
resp, err := svc.DescribeTasks(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleECS_CreateService() {
svc := ecs.New(session.New())
params := &ecs.CreateServiceInput{
DesiredCount: aws.Int64(1), // Required
ServiceName: aws.String("String"), // Required
TaskDefinition: aws.String("String"), // Required
ClientToken: aws.String("String"),
Cluster: aws.String("String"),
LoadBalancers: []*ecs.LoadBalancer{
{ // Required
ContainerName: aws.String("String"),
ContainerPort: aws.Int64(1),
LoadBalancerName: aws.String("String"),
},
// More values...
},
Role: aws.String("String"),
}
resp, err := svc.CreateService(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func main() {
kingpin.Version("0.0.1")
kingpin.CommandLine.Help = "Dashboard - An AWS ECS visualiser."
kingpin.Parse()
clientECS = ecs.New(&aws.Config{Region: *cliRegion})
r := render.New(render.Options{
Directory: "src/github.com/nickschuch/dashboard/templates",
Asset: Asset,
AssetNames: AssetNames,
IsDevelopment: false,
})
mux := http.NewServeMux()
mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
params := Cluster{
Name: *cliCluster,
Region: *cliRegion,
Instances: getInstances(),
}
r.HTML(w, http.StatusOK, "cluster", params)
})
http.ListenAndServe(":"+*cliPort, mux)
}
func ExampleECS_UpdateService() {
svc := ecs.New(nil)
params := &ecs.UpdateServiceInput{
Service: aws.String("String"), // Required
Cluster: aws.String("String"),
DesiredCount: aws.Long(1),
TaskDefinition: aws.String("String"),
}
resp, err := svc.UpdateService(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func init() {
Before("@ecs", func() {
// FIXME remove custom region
World["client"] = ecs.New(smoke.Session,
aws.NewConfig().WithRegion("us-west-2"))
})
}
func ExampleECS_SubmitTaskStateChange() {
svc := ecs.New(nil)
params := &ecs.SubmitTaskStateChangeInput{
Cluster: aws.String("String"),
Reason: aws.String("String"),
Status: aws.String("String"),
Task: aws.String("String"),
}
resp, err := svc.SubmitTaskStateChange(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.Prettify(resp))
}
func ExampleECS_ListTasks() {
svc := ecs.New(session.New())
params := &ecs.ListTasksInput{
Cluster: aws.String("String"),
ContainerInstance: aws.String("String"),
DesiredStatus: aws.String("DesiredStatus"),
Family: aws.String("String"),
MaxResults: aws.Int64(1),
NextToken: aws.String("String"),
ServiceName: aws.String("String"),
StartedBy: aws.String("String"),
}
resp, err := svc.ListTasks(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
// Exec the cmd on the container instances for the cluster.
func Exec(cluster *string, cmd *[]string) {
session := session.New(&aws.Config{Region: aws.String(os.Getenv("AWS_REGION"))})
ecs := ecspkg.New(session)
ec2 := ec2pkg.New(session)
containers := containerInstances(ecs, cluster)
ids := instanceIds(ecs, containers)
ips := privateIps(ec2, ids)
var wg sync.WaitGroup
for _, ip := range ips {
wg.Add(1)
go func(ip string) {
defer wg.Done()
l := log.New(os.Stderr, log.INFO, ip)
args := []string{ip}
args = append(args, *cmd...)
cmd := exec.Command("ssh", args...)
cmd.Stdout = l
cmd.Stderr = l
err := cmd.Run()
if err != nil {
l.Error("failed: %s", err)
}
}(*ip)
}
wg.Wait()
}
func ExampleECS_UpdateContainerAgent() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := ecs.New(sess)
params := &ecs.UpdateContainerAgentInput{
ContainerInstance: aws.String("String"), // Required
Cluster: aws.String("String"),
}
resp, err := svc.UpdateContainerAgent(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleECS_SubmitTaskStateChange() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := ecs.New(sess)
params := &ecs.SubmitTaskStateChangeInput{
Cluster: aws.String("String"),
Reason: aws.String("String"),
Status: aws.String("String"),
Task: aws.String("String"),
}
resp, err := svc.SubmitTaskStateChange(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleECS_SubmitContainerStateChange() {
svc := ecs.New(session.New())
params := &ecs.SubmitContainerStateChangeInput{
Cluster: aws.String("String"),
ContainerName: aws.String("String"),
ExitCode: aws.Int64(1),
NetworkBindings: []*ecs.NetworkBinding{
{ // Required
BindIP: aws.String("String"),
ContainerPort: aws.Int64(1),
HostPort: aws.Int64(1),
Protocol: aws.String("TransportProtocol"),
},
// More values...
},
Reason: aws.String("String"),
Status: aws.String("String"),
Task: aws.String("String"),
}
resp, err := svc.SubmitContainerStateChange(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleECS_ListTaskDefinitions() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := ecs.New(sess)
params := &ecs.ListTaskDefinitionsInput{
FamilyPrefix: aws.String("String"),
MaxResults: aws.Int64(1),
NextToken: aws.String("String"),
Sort: aws.String("SortOrder"),
Status: aws.String("TaskDefinitionStatus"),
}
resp, err := svc.ListTaskDefinitions(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleECS_ListContainerInstances() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := ecs.New(sess)
params := &ecs.ListContainerInstancesInput{
Cluster: aws.String("String"),
MaxResults: aws.Int64(1),
NextToken: aws.String("String"),
}
resp, err := svc.ListContainerInstances(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleECS_DescribeTasks() {
svc := ecs.New(nil)
params := &ecs.DescribeTasksInput{
Tasks: []*string{ // Required
aws.String("String"), // Required
// More values...
},
Cluster: aws.String("String"),
}
resp, err := svc.DescribeTasks(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.Prettify(resp))
}
func ExampleECS_ListTaskDefinitions() {
svc := ecs.New(nil)
params := &ecs.ListTaskDefinitionsInput{
FamilyPrefix: aws.String("String"),
MaxResults: aws.Int64(1),
NextToken: aws.String("String"),
Sort: aws.String("SortOrder"),
Status: aws.String("TaskDefinitionStatus"),
}
resp, err := svc.ListTaskDefinitions(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.Prettify(resp))
}
func ExampleECS_UpdateService() {
svc := ecs.New(session.New())
params := &ecs.UpdateServiceInput{
Service: aws.String("String"), // Required
Cluster: aws.String("String"),
DeploymentConfiguration: &ecs.DeploymentConfiguration{
MaximumPercent: aws.Int64(1),
MinimumHealthyPercent: aws.Int64(1),
},
DesiredCount: aws.Int64(1),
TaskDefinition: aws.String("String"),
}
resp, err := svc.UpdateService(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func ExampleECS_ListTasks() {
svc := ecs.New(nil)
params := &ecs.ListTasksInput{
Cluster: aws.String("String"),
ContainerInstance: aws.String("String"),
DesiredStatus: aws.String("DesiredStatus"),
Family: aws.String("String"),
MaxResults: aws.Long(1),
NextToken: aws.String("String"),
ServiceName: aws.String("String"),
StartedBy: aws.String("String"),
}
resp, err := svc.ListTasks(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func ExampleECS_DiscoverPollEndpoint() {
svc := ecs.New(nil)
params := &ecs.DiscoverPollEndpointInput{
Cluster: aws.String("String"),
ContainerInstance: aws.String("String"),
}
resp, err := svc.DiscoverPollEndpoint(params)
if err != nil {
if awsErr, ok := err.(awserr.Error); ok {
// Generic AWS error with Code, Message, and original error (if any)
fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr())
if reqErr, ok := err.(awserr.RequestFailure); ok {
// A service error occurred
fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID())
}
} else {
// This case should never be hit, the SDK should always return an
// error which satisfies the awserr.Error interface.
fmt.Println(err.Error())
}
}
// Pretty-print the response data.
fmt.Println(awsutil.StringValue(resp))
}
func newECS(region string) *ecs.ECS {
session := session.New()
return ecs.New(session, &aws.Config{
Credentials: creds,
Region: aws.String(region),
})
}
// NewScheduler returns a new Scheduler instance.
func NewScheduler(db *sql.DB, config client.ConfigProvider) *Scheduler {
return &Scheduler{
cloudformation: cloudformation.New(config),
ecs: ecs.New(config),
s3: s3.New(config),
db: db,
}
}
func newInteractor(c configInteractor) *ecsInteractor {
svc := ecs.New(aws.NewConfig().WithRegion(c.region))
return &ecsInteractor{
ecs: svc,
cluster: c.cluster,
}
}
func New(region *string, logger *log.Logger) *Client {
sess := session.New(&aws.Config{Region: region})
svc := ecs.New(sess)
return &Client{
svc: svc,
pollInterval: time.Second * 5,
logger: logger,
}
}
// NewScheduler returns a new Scheduler instance.
func NewScheduler(db *sql.DB, config client.ConfigProvider) *Scheduler {
return &Scheduler{
cloudformation: cloudformation.New(config),
ecs: ecsWithCaching(ecs.New(config)),
s3: s3.New(config),
db: db,
after: time.After,
}
}
func (self *ECSManager) RegisterTaskDefinition(taskName string, containers []*schema.ContainerDefinition) (*ecs.RegisterTaskDefinitionOutput, error) {
svc := ecs.New(&aws.Config{
Region: self.Region,
Credentials: self.Credentials,
})
conDefs := []*ecs.ContainerDefinition{}
for _, con := range containers {
var commands []*string
if len(con.Command) > 0 {
for _, token := range strings.Split(con.Command, " ") {
commands = append(commands, aws.String(token))
}
} else {
commands = nil
}
var entryPoints []*string
if len(con.EntryPoint) > 0 {
for _, token := range strings.Split(con.EntryPoint, " ") {
entryPoints = append(entryPoints, aws.String(token))
}
} else {
entryPoints = nil
}
conDef := &ecs.ContainerDefinition{
CPU: aws.Long(con.CpuUnits),
Command: commands,
EntryPoint: entryPoints,
Environment: toKeyValuePairs(con.Environment),
Essential: aws.Boolean(con.Essential),
Image: aws.String(con.Image),
Links: util.ConvertPointerString(con.Links),
Memory: aws.Long(con.Memory),
// MountPoints
Name: aws.String(con.Name),
PortMappings: toPortMappings(con.Ports),
// VolumesFrom
}
conDefs = append(conDefs, conDef)
}
params := &ecs.RegisterTaskDefinitionInput{
ContainerDefinitions: conDefs,
Family: aws.String(taskName),
Volumes: []*ecs.Volume{},
}
return svc.RegisterTaskDefinition(params)
}
func main() {
kingpin.Parse()
clientECS = ecs.New(&aws.Config{Region: aws.String(*cliRegion)})
clientEC2 = ec2.New(&aws.Config{Region: aws.String(*cliRegion)})
for {
Push(*cliMarco)
time.Sleep(time.Duration(*cliFrequency) * time.Second)
}
}
func ExampleECS_RegisterContainerInstance() {
sess, err := session.NewSession()
if err != nil {
fmt.Println("failed to create session,", err)
return
}
svc := ecs.New(sess)
params := &ecs.RegisterContainerInstanceInput{
Attributes: []*ecs.Attribute{
{ // Required
Name: aws.String("String"), // Required
Value: aws.String("String"),
},
// More values...
},
Cluster: aws.String("String"),
ContainerInstanceArn: aws.String("String"),
InstanceIdentityDocument: aws.String("String"),
InstanceIdentityDocumentSignature: aws.String("String"),
TotalResources: []*ecs.Resource{
{ // Required
DoubleValue: aws.Float64(1.0),
IntegerValue: aws.Int64(1),
LongValue: aws.Int64(1),
Name: aws.String("String"),
StringSetValue: []*string{
aws.String("String"), // Required
// More values...
},
Type: aws.String("String"),
},
// More values...
},
VersionInfo: &ecs.VersionInfo{
AgentHash: aws.String("String"),
AgentVersion: aws.String("String"),
DockerVersion: aws.String("String"),
},
}
resp, err := svc.RegisterContainerInstance(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
func NewClient(cluster string, accessKeyID string, secretAccessKey string) *Client {
awsConfig := &aws.Config{
Region: aws.String("us-west-1"),
MaxRetries: aws.Int(10),
Credentials: credentials.NewStaticCredentials(accessKeyID, secretAccessKey, ""),
}
svc := ecs.New(session.New(), awsConfig)
return &Client{
client: svc,
cluster: cluster,
}
}
// GetClient configure and return initialized client.
func GetClient() *Client {
if client != nil {
return client
}
var c Client
fmt.Println("[INFO] Initializing ECS Connection")
c.ecs = ecs.New(&aws.Config{
Credentials: credentials.NewEnvCredentials(),
})
client = &c
return client
}