func EnvironmentSet(rw http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
app := vars["app"]
body, err := ioutil.ReadAll(r.Body)
if err != nil {
helpers.Error(nil, err)
RenderError(rw, err)
return
}
err = models.PutEnvironment(app, models.LoadEnvironment(body))
if err != nil {
helpers.Error(nil, err)
RenderError(rw, err)
return
}
RenderText(rw, "ok")
}
func ECSTaskDefinitionCreate(req Request) (string, map[string]string, error) {
// return "", fmt.Errorf("fail")
tasks := req.ResourceProperties["Tasks"].([]interface{})
r := &ecs.RegisterTaskDefinitionInput{
Family: aws.String(req.ResourceProperties["Name"].(string)),
}
// download environment
var env models.Environment
if envUrl, ok := req.ResourceProperties["Environment"].(string); ok && envUrl != "" {
res, err := http.Get(envUrl)
if err != nil {
return "", nil, err
}
defer res.Body.Close()
data, err := ioutil.ReadAll(res.Body)
if key, ok := req.ResourceProperties["Key"].(string); ok && key != "" {
cr := crypt.New(Region(&req), os.Getenv("AWS_ACCESS_KEY_ID"), os.Getenv("AWS_SECRET_ACCESS_KEY"))
cr.AwsToken = os.Getenv("AWS_SESSION_TOKEN")
dec, err := cr.Decrypt(key, data)
if err != nil {
return "", nil, err
}
data = dec
}
env = models.LoadEnvironment(data)
}
r.ContainerDefinitions = make([]*ecs.ContainerDefinition, len(tasks))
for i, itask := range tasks {
task := itask.(map[string]interface{})
cpu, _ := strconv.Atoi(task["CPU"].(string))
memory, _ := strconv.Atoi(task["Memory"].(string))
r.ContainerDefinitions[i] = &ecs.ContainerDefinition{
Name: aws.String(task["Name"].(string)),
Essential: aws.Boolean(true),
Image: aws.String(task["Image"].(string)),
CPU: aws.Long(int64(cpu)),
Memory: aws.Long(int64(memory)),
}
if command, ok := task["Command"].(string); ok && command != "" {
r.ContainerDefinitions[i].Command = []*string{aws.String("sh"), aws.String("-c"), aws.String(command)}
}
// set environment
for key, val := range env {
r.ContainerDefinitions[i].Environment = append(r.ContainerDefinitions[i].Environment, &ecs.KeyValuePair{
Name: aws.String(key),
Value: aws.String(val),
})
}
// set task environment overrides
if oenv, ok := task["Environment"].(map[string]interface{}); ok {
for key, val := range oenv {
r.ContainerDefinitions[i].Environment = append(r.ContainerDefinitions[i].Environment, &ecs.KeyValuePair{
Name: aws.String(key),
Value: aws.String(val.(string)),
})
}
}
// put release in environment
if release, ok := req.ResourceProperties["Release"].(string); ok {
r.ContainerDefinitions[i].Environment = append(r.ContainerDefinitions[i].Environment, &ecs.KeyValuePair{
Name: aws.String("RELEASE"),
Value: aws.String(release),
})
}
// link to Service Stacks via environment
if task["Services"] != nil {
services := task["Services"].([]interface{})
for _, service := range services {
parts := strings.Split(service.(string), ":")
res, err := CloudFormation(req).DescribeStacks(&cloudformation.DescribeStacksInput{StackName: aws.String(parts[0])})
if err != nil {
return "", nil, fmt.Errorf("SERVICE CREATION: %s", err)
}
s := models.ServiceFromStack(res.Stacks[0])
// convert Port5432TcpAddr to POSTGRES_PORT_5432_TCP_ADDR
re := regexp.MustCompile("([a-z])([A-Z0-9])") // lower case letter followed by upper case or number, i.e. Port5432
re2 := regexp.MustCompile("([0-9])([A-Z])") // number followed by upper case letter, i.e. 5432Tcp
for k, v := range s.Outputs {
u := re.ReplaceAllString(k, "${1}_${2}")
u = re2.ReplaceAllString(u, "${1}_${2}")
u = parts[1] + "_" + u
u = strings.ToUpper(u)
r.ContainerDefinitions[i].Environment = append(r.ContainerDefinitions[i].Environment, &ecs.KeyValuePair{
Name: aws.String(u),
Value: aws.String(v),
})
}
}
}
// set links
if links, ok := task["Links"].([]interface{}); ok {
r.ContainerDefinitions[i].Links = make([]*string, len(links))
for j, link := range links {
r.ContainerDefinitions[i].Links[j] = aws.String(link.(string))
}
}
// set portmappings
if ports, ok := task["PortMappings"].([]interface{}); ok {
r.ContainerDefinitions[i].PortMappings = make([]*ecs.PortMapping, len(ports))
for j, port := range ports {
parts := strings.Split(port.(string), ":")
host, _ := strconv.Atoi(parts[0])
container, _ := strconv.Atoi(parts[1])
r.ContainerDefinitions[i].PortMappings[j] = &ecs.PortMapping{
ContainerPort: aws.Long(int64(container)),
HostPort: aws.Long(int64(host)),
}
}
}
// set volumes
if volumes, ok := task["Volumes"].([]interface{}); ok {
for j, volume := range volumes {
name := fmt.Sprintf("%s-%d-%d", task["Name"].(string), i, j)
parts := strings.Split(volume.(string), ":")
r.Volumes = append(r.Volumes, &ecs.Volume{
Name: aws.String(name),
Host: &ecs.HostVolumeProperties{
SourcePath: aws.String(parts[0]),
},
})
r.ContainerDefinitions[i].MountPoints = append(r.ContainerDefinitions[i].MountPoints, &ecs.MountPoint{
SourceVolume: aws.String(name),
ContainerPath: aws.String(parts[1]),
ReadOnly: aws.Boolean(false),
})
}
}
}
res, err := ECS(req).RegisterTaskDefinition(r)
if err != nil {
return "", nil, err
}
return *res.TaskDefinition.TaskDefinitionARN, nil, nil
}