func cmdList() {
vs, err := version.All()
if err != nil {
fmt.Printf("error: %v\n", err.Error())
os.Exit(1)
}
v, err := vs.Latest()
if err != nil {
fmt.Printf("error: %v\n", err.Error())
if err.Error() == "no published versions" {
fmt.Printf("\nLast non-published versions are:\n")
n := 5
if len(vs) < 5 {
n = len(vs)
}
for i := len(vs) - 1; i >= len(vs)-n; i-- {
fmt.Printf("%v\n", vs[i].Display())
}
}
os.Exit(1)
}
fmt.Printf("%v\n", v.Display())
}
func cmdRackUpdate(c *cli.Context) {
versions, err := version.All()
if err != nil {
stdcli.Error(err)
return
}
specified := "stable"
if len(c.Args()) > 0 {
specified = c.Args()[0]
}
version, err := versions.Resolve(specified)
if err != nil {
stdcli.Error(err)
return
}
system, err := rackClient(c).UpdateSystem(version.Version)
if err != nil {
stdcli.Error(err)
return
}
fmt.Printf("Name %s\n", system.Name)
fmt.Printf("Status %s\n", system.Status)
fmt.Printf("Version %s\n", system.Version)
fmt.Printf("Count %d\n", system.Count)
fmt.Printf("Type %s\n", system.Type)
}
func cmdRackReleases(c *cli.Context) {
vs, err := version.All()
if err != nil {
return
}
selected := version.Versions{}
for _, v := range vs {
switch {
case !v.Published && c.Bool("unpublished"):
selected = append(selected, v)
case v.Published:
selected = append(selected, v)
}
}
sort.Sort(sort.Reverse(selected))
if len(selected) > 20 {
selected = selected[0:20]
}
for _, v := range selected {
fmt.Println(v.Version)
}
}
func TestRackUpdateStable(t *testing.T) {
versions, err := version.All()
require.Nil(t, err)
stable, err := versions.Resolve("stable")
require.Nil(t, err)
ts := testServer(t,
test.Http{Method: "PUT", Body: fmt.Sprintf("version=%s", stable.Version), Path: "/system", Code: 200, Response: client.System{
Name: "mysystem",
Version: "ver",
Count: 1,
Type: "type",
}},
)
defer ts.Close()
test.Runs(t,
test.ExecRun{
Command: "convox rack update",
Exit: 0,
Stdout: "Name mysystem\nStatus \nVersion ver\nCount 1\nType type\n",
},
)
}
func cmdInstall(c *cli.Context) {
region := c.String("region")
if !lambdaRegions[region] {
stdcli.Error(fmt.Errorf("Convox is not currently supported in %s", region))
}
tenancy := "default"
instanceType := c.String("instance-type")
if c.Bool("dedicated") {
tenancy = "dedicated"
if strings.HasPrefix(instanceType, "t2") {
stdcli.Error(fmt.Errorf("t2 instance types aren't supported in dedicated tenancy, please set --instance-type."))
}
}
fmt.Println(Banner)
distinctId, err := currentId()
access, secret, token, err := readCredentials(c)
if err != nil {
handleError("install", distinctId, err)
return
}
development := "No"
if c.Bool("development") {
isDevelopment = true
development = "Yes"
}
ami := c.String("ami")
key := c.String("key")
stackName := c.String("stack-name")
versions, err := version.All()
if err != nil {
handleError("install", distinctId, err)
return
}
version, err := versions.Resolve(c.String("version"))
if err != nil {
handleError("install", distinctId, err)
return
}
versionName := version.Version
formationUrl := fmt.Sprintf(FormationUrl, versionName)
instanceCount := fmt.Sprintf("%d", c.Int("instance-count"))
fmt.Printf("Installing Convox (%s)...\n", versionName)
if isDevelopment {
fmt.Println("(Development Mode)")
}
access = strings.TrimSpace(access)
secret = strings.TrimSpace(secret)
token = strings.TrimSpace(token)
password := randomString(30)
CloudFormation := cloudformation.New(&aws.Config{
Region: aws.String(region),
Credentials: credentials.NewStaticCredentials(access, secret, token),
})
res, err := CloudFormation.CreateStack(&cloudformation.CreateStackInput{
Capabilities: []*string{aws.String("CAPABILITY_IAM")},
Parameters: []*cloudformation.Parameter{
&cloudformation.Parameter{ParameterKey: aws.String("Ami"), ParameterValue: aws.String(ami)},
&cloudformation.Parameter{ParameterKey: aws.String("ClientId"), ParameterValue: aws.String(distinctId)},
&cloudformation.Parameter{ParameterKey: aws.String("Development"), ParameterValue: aws.String(development)},
&cloudformation.Parameter{ParameterKey: aws.String("InstanceCount"), ParameterValue: aws.String(instanceCount)},
&cloudformation.Parameter{ParameterKey: aws.String("InstanceType"), ParameterValue: aws.String(instanceType)},
&cloudformation.Parameter{ParameterKey: aws.String("Key"), ParameterValue: aws.String(key)},
&cloudformation.Parameter{ParameterKey: aws.String("Password"), ParameterValue: aws.String(password)},
&cloudformation.Parameter{ParameterKey: aws.String("Tenancy"), ParameterValue: aws.String(tenancy)},
&cloudformation.Parameter{ParameterKey: aws.String("Version"), ParameterValue: aws.String(versionName)},
},
StackName: aws.String(stackName),
TemplateURL: aws.String(formationUrl),
})
if err != nil {
sendMixpanelEvent(fmt.Sprintf("convox-install-error"), err.Error())
if awsErr, ok := err.(awserr.Error); ok {
if awsErr.Code() == "AlreadyExistsException" {
stdcli.Error(fmt.Errorf("Stack %q already exists. Run `convox uninstall` then try again.", stackName))
}
}
stdcli.Error(err)
}
sendMixpanelEvent("convox-install-start", "")
host, err := waitForCompletion(*res.StackId, CloudFormation, false)
if err != nil {
handleError("install", distinctId, err)
return
}
fmt.Println("Waiting for load balancer...")
waitForAvailability(fmt.Sprintf("http://%s/", host))
fmt.Println("Logging in...")
addLogin(host, password)
switchHost(host)
fmt.Println("Success, try `convox apps`")
sendMixpanelEvent("convox-install-success", "")
}
func cmdInstall(c *cli.Context) {
region := c.String("region")
if !lambdaRegions[region] {
stdcli.Error(fmt.Errorf("Convox is not currently supported in %s", region))
}
tenancy := "default"
instanceType := c.String("instance-type")
if c.Bool("dedicated") {
tenancy = "dedicated"
if strings.HasPrefix(instanceType, "t2") {
stdcli.Error(fmt.Errorf("t2 instance types aren't supported in dedicated tenancy, please set --instance-type."))
}
}
fmt.Println(Banner)
distinctId, err := currentId()
creds, err := readCredentials(c)
if err != nil {
handleError("install", distinctId, err)
return
}
if creds == nil {
err = fmt.Errorf("error reading credentials")
handleError("install", distinctId, err)
return
}
reader := bufio.NewReader(os.Stdin)
if email := c.String("email"); email != "" {
distinctId = email
updateId(distinctId)
} else if terminal.IsTerminal(int(os.Stdin.Fd())) {
fmt.Print("Email Address (optional, to receive project updates): ")
email, err := reader.ReadString('\n')
if err != nil {
handleError("install", distinctId, err)
return
}
if strings.TrimSpace(email) != "" {
distinctId = email
updateId(email)
}
}
development := "No"
if c.Bool("development") {
isDevelopment = true
development = "Yes"
}
encryption := "Yes"
if c.Bool("disable-encryption") {
encryption = "No"
}
ami := c.String("ami")
key := c.String("key")
stackName := c.String("stack-name")
versions, err := version.All()
if err != nil {
handleError("install", distinctId, err)
return
}
version, err := versions.Resolve(c.String("version"))
if err != nil {
handleError("install", distinctId, err)
return
}
versionName := version.Version
formationUrl := fmt.Sprintf(FormationUrl, versionName)
instanceCount := fmt.Sprintf("%d", c.Int("instance-count"))
fmt.Printf("Installing Convox (%s)...\n", versionName)
if isDevelopment {
fmt.Println("(Development Mode)")
}
password := randomString(30)
CloudFormation := cloudformation.New(&aws.Config{
Region: aws.String(region),
Credentials: credentials.NewStaticCredentials(creds.Access, creds.Secret, creds.Session),
})
req := &cloudformation.CreateStackInput{
Capabilities: []*string{aws.String("CAPABILITY_IAM")},
Parameters: []*cloudformation.Parameter{
&cloudformation.Parameter{ParameterKey: aws.String("Ami"), ParameterValue: aws.String(ami)},
&cloudformation.Parameter{ParameterKey: aws.String("ClientId"), ParameterValue: aws.String(distinctId)},
&cloudformation.Parameter{ParameterKey: aws.String("Development"), ParameterValue: aws.String(development)},
&cloudformation.Parameter{ParameterKey: aws.String("Encryption"), ParameterValue: aws.String(encryption)},
&cloudformation.Parameter{ParameterKey: aws.String("InstanceCount"), ParameterValue: aws.String(instanceCount)},
&cloudformation.Parameter{ParameterKey: aws.String("InstanceType"), ParameterValue: aws.String(instanceType)},
&cloudformation.Parameter{ParameterKey: aws.String("Key"), ParameterValue: aws.String(key)},
&cloudformation.Parameter{ParameterKey: aws.String("Password"), ParameterValue: aws.String(password)},
&cloudformation.Parameter{ParameterKey: aws.String("Tenancy"), ParameterValue: aws.String(tenancy)},
&cloudformation.Parameter{ParameterKey: aws.String("Version"), ParameterValue: aws.String(versionName)},
},
StackName: aws.String(stackName),
TemplateURL: aws.String(formationUrl),
}
if tf := os.Getenv("TEMPLATE_FILE"); tf != "" {
dat, err := ioutil.ReadFile(tf)
if err != nil {
handleError("install", distinctId, err)
}
req.TemplateURL = nil
req.TemplateBody = aws.String(string(dat))
}
res, err := CloudFormation.CreateStack(req)
// NOTE: we start making lots of network requests here
// so we're just going to return for testability
if os.Getenv("AWS_REGION") == "test" {
fmt.Println(*res.StackId)
return
}
if err != nil {
sendMixpanelEvent(fmt.Sprintf("convox-install-error"), err.Error())
if awsErr, ok := err.(awserr.Error); ok {
if awsErr.Code() == "AlreadyExistsException" {
stdcli.Error(fmt.Errorf("Stack %q already exists. Run `convox uninstall` then try again.", stackName))
}
}
stdcli.Error(err)
}
sendMixpanelEvent("convox-install-start", "")
host, err := waitForCompletion(*res.StackId, CloudFormation, false)
if err != nil {
handleError("install", distinctId, err)
return
}
fmt.Println("Waiting for load balancer...")
waitForAvailability(fmt.Sprintf("http://%s/", host))
fmt.Println("Logging in...")
addLogin(host, password)
switchHost(host)
fmt.Println("Success, try `convox apps`")
sendMixpanelEvent("convox-install-success", "")
}