func ServiceStream(rw http.ResponseWriter, r *http.Request) {
log := servicesLogger("stream").Start()
service, err := models.GetServiceFromName(mux.Vars(r)["service"])
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
logs := make(chan []byte)
done := make(chan bool)
service.SubscribeLogs(logs, done)
ws, err := upgrader.Upgrade(rw, r, nil)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
log.Success("step=upgrade service=%q", service.Name)
defer ws.Close()
for data := range logs {
ws.WriteMessage(websocket.TextMessage, data)
}
log.Success("step=ended service=%q", service.Name)
}
func ServiceCreate(rw http.ResponseWriter, r *http.Request) {
log := servicesLogger("create").Start()
name := GetForm(r, "name")
t := GetForm(r, "type")
password, err := rand_password(20)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
service := &models.Service{
Name: name,
Password: password,
Type: t,
}
err = service.Create()
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
Redirect(rw, r, "/services")
}
func ReleasePromote(rw http.ResponseWriter, r *http.Request) {
log := releasesLogger("promote").Start()
vars := mux.Vars(r)
app := vars["app"]
release := vars["release"]
rel, err := models.GetRelease(app, release)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
err = rel.Promote()
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
log.Success("step=release.promote app=%q", app)
RenderText(rw, "ok")
}
func AppCreate(rw http.ResponseWriter, r *http.Request) {
log := appsLogger("create").Start()
name := GetForm(r, "name")
repo := GetForm(r, "repo")
app := &models.App{
Name: name,
Repository: repo,
}
err := app.Create()
if awsError(err) == "AlreadyExistsException" {
err = fmt.Errorf("There is already an app named %s", name)
helpers.Error(log, err)
RenderError(rw, err)
return
}
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
Redirect(rw, r, fmt.Sprintf("/apps/%s", name))
}
func ProcessRunAttached(ws *websocket.Conn) {
defer ws.Close()
log := processesLogger("run.attached").Start()
vars := mux.Vars(ws.Request())
app := vars["app"]
process := vars["process"]
command := ws.Request().Header.Get("Command")
ps, err := models.GetProcess(app, process)
if err != nil {
helpers.Error(log, err)
ws.Write([]byte(fmt.Sprintf("error: %s\n", err)))
return
}
log.Success("step=upgrade app=%q", ps.App)
defer ws.Close()
err = ps.RunAttached(command, ws)
if err != nil {
helpers.Error(log, err)
ws.Write([]byte(fmt.Sprintf("error: %s\n", err)))
return
}
log.Success("step=ended app=%q", ps.App)
}
func EnvironmentDelete(rw http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
app := vars["app"]
name := vars["name"]
env, err := models.GetEnvironment(app)
if awsError(err) == "ValidationError" {
RenderNotFound(rw, fmt.Sprintf("no such app: %s", app))
return
}
if err != nil {
helpers.Error(nil, err)
RenderError(rw, err)
return
}
delete(env, name)
err = models.PutEnvironment(app, env)
if err != nil {
helpers.Error(nil, err)
RenderError(rw, err)
return
}
RenderText(rw, "ok")
}
func EnvironmentCreate(rw http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
app := vars["app"]
name := vars["name"]
value := GetForm(r, "value")
env, err := models.GetEnvironment(app)
if err != nil {
helpers.Error(nil, err)
RenderError(rw, err)
return
}
env[strings.ToUpper(name)] = value
err = models.PutEnvironment(app, env)
if err != nil {
helpers.Error(nil, err)
RenderError(rw, err)
return
}
RenderText(rw, "ok")
}
func ServiceDelete(rw http.ResponseWriter, r *http.Request) {
log := servicesLogger("delete").Start()
vars := mux.Vars(r)
name := vars["service"]
service, err := models.GetServiceFromName(name)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
log.Success("step=services.get service=%q", service.Name)
err = service.Delete()
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
log.Success("step=service.delete service=%q", service.Name)
RenderText(rw, "ok")
}
func AppDelete(rw http.ResponseWriter, r *http.Request) {
log := appsLogger("delete").Start()
vars := mux.Vars(r)
name := vars["app"]
app, err := models.GetApp(name)
if awsError(err) == "ValidationError" {
RenderNotFound(rw, fmt.Sprintf("no such app: %s", name))
return
}
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
log.Success("step=app.get app=%q", app.Name)
err = app.Delete()
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
log.Success("step=app.delete app=%q", app.Name)
RenderText(rw, "ok")
}
func BuildLogs(ws *websocket.Conn) {
defer ws.Close()
log := buildsLogger("logs").Start()
vars := mux.Vars(ws.Request())
id := vars["build"]
log.Success("step=upgrade build=%q", id)
defer ws.Close()
// proxy to docker container logs
// https://docs.docker.com/reference/api/docker_remote_api_v1.19/#get-container-logs
client, err := docker.NewClient("unix:///var/run/docker.sock")
if err != nil {
helpers.Error(log, err)
ws.Write([]byte(fmt.Sprintf("error: %s\n", err)))
return
}
r, w := io.Pipe()
quit := make(chan bool)
go scanLines(r, ws)
go keepAlive(ws, quit)
err = client.Logs(docker.LogsOptions{
Container: fmt.Sprintf("build-%s", id),
Follow: true,
Stdout: true,
Stderr: true,
Tail: "all",
RawTerminal: false,
OutputStream: w,
ErrorStream: w,
})
quit <- true
if err != nil {
helpers.Error(log, err)
ws.Write([]byte(fmt.Sprintf("error: %s\n", err)))
return
}
}
func SystemShow(rw http.ResponseWriter, r *http.Request) {
log := systemLogger("show").Start()
rack := os.Getenv("RACK")
a, err := models.GetApp(rack)
if awsError(err) == "ValidationError" {
RenderNotFound(rw, fmt.Sprintf("no such stack: %s", rack))
return
}
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
switch r.Header.Get("Content-Type") {
case "application/json":
RenderJson(rw, a)
default:
RenderTemplate(rw, "app", a)
}
}
func AppShow(rw http.ResponseWriter, r *http.Request) {
log := appsLogger("show").Start()
app := mux.Vars(r)["app"]
a, err := models.GetApp(app)
if awsError(err) == "ValidationError" {
RenderNotFound(rw, fmt.Sprintf("no such app: %s", app))
return
}
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
switch r.Header.Get("Content-Type") {
case "application/json":
RenderJson(rw, a)
default:
RenderTemplate(rw, "app", a)
}
}
func AppEnvironment(rw http.ResponseWriter, r *http.Request) {
log := appsLogger("environment").Start()
app := mux.Vars(r)["app"]
env, err := models.GetEnvironment(app)
if awsError(err) == "ValidationError" {
RenderNotFound(rw, fmt.Sprintf("no such app: %s", app))
return
}
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
params := map[string]interface{}{
"App": app,
"Environment": env,
}
switch r.Header.Get("Content-Type") {
case "application/json":
RenderJson(rw, params["Environment"])
default:
RenderPartial(rw, "app", "environment", params)
}
}
func AppEvents(rw http.ResponseWriter, r *http.Request) {
log := appsLogger("events").Start()
app := mux.Vars(r)["app"]
events, err := models.ListECSEvents(app)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
for i, _ := range events {
match := regexServiceCleaner.FindStringSubmatch(events[i].Message)
if len(match) == 3 {
events[i].Message = fmt.Sprintf("[ECS] (%s) %s", match[1], match[2])
}
}
es, err := models.ListEvents(app)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
for _, e := range es {
events = append(events, models.ServiceEvent{
Message: fmt.Sprintf("[CFM] (%s) %s %s", e.Name, e.Status, e.Reason),
CreatedAt: e.Time,
})
}
sort.Sort(sort.Reverse(events))
data := ""
for _, e := range events {
data += fmt.Sprintf("%s: %s\n", e.CreatedAt.Format(time.RFC3339), e.Message)
}
RenderText(rw, data)
}
func AppReleases(rw http.ResponseWriter, r *http.Request) {
log := appsLogger("releases").Start()
vars := mux.Vars(r)
app := vars["app"]
l := map[string]string{
"id": r.URL.Query().Get("id"),
"created": r.URL.Query().Get("created"),
}
a, err := models.GetApp(app)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
releases, err := models.ListReleases(app, l)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
params := map[string]interface{}{
"App": a,
"Releases": releases,
}
if len(releases) > 0 {
params["Last"] = releases[len(releases)-1]
}
switch r.Header.Get("Content-Type") {
case "application/json":
RenderJson(rw, releases)
default:
RenderPartial(rw, "app", "releases", params)
}
}
func SettingsUpdate(rw http.ResponseWriter, r *http.Request) {
err := models.SettingSet("github", GetForm(r, "github"))
if err != nil {
helpers.Error(nil, err)
RenderError(rw, err)
return
}
err = models.SettingSet("heroku", GetForm(r, "heroku"))
if err != nil {
helpers.Error(nil, err)
RenderError(rw, err)
return
}
Redirect(rw, r, "/settings")
}
func AppStream(rw http.ResponseWriter, r *http.Request) {
log := appsLogger("stream").Start()
app := mux.Vars(r)["app"]
ws, err := upgrader.Upgrade(rw, r, nil)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
log.Success("step=upgrade app=%q", app)
defer ws.Close()
a, err := models.GetApp(mux.Vars(r)["app"])
if awsError(err) == "ValidationError" {
ws.WriteMessage(websocket.TextMessage, []byte(fmt.Sprintf("ERROR: no such app: %s\n", app)))
return
}
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
logs := make(chan []byte)
done := make(chan bool)
a.SubscribeLogs(logs, done)
for data := range logs {
ws.WriteMessage(websocket.TextMessage, data)
}
log.Success("step=ended app=%q", app)
}
func ProcessRun(rw http.ResponseWriter, r *http.Request) {
log := processesLogger("run").Start()
vars := mux.Vars(r)
app := vars["app"]
process := vars["process"]
command := GetForm(r, "command")
_, err := models.GetApp(app)
if awsError(err) == "ValidationError" {
RenderNotFound(rw, fmt.Sprintf("no such app: %s", app))
return
}
ps, err := models.GetProcess(app, process)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
if ps == nil {
RenderNotFound(rw, fmt.Sprintf("no such process: %s", process))
return
}
err = ps.Run(models.ProcessRunOptions{
Command: command,
Process: process,
})
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
RenderText(rw, "ok")
}
func ServiceList(rw http.ResponseWriter, r *http.Request) {
log := servicesLogger("list").Start()
services, err := models.ListServiceStacks()
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
RenderJson(rw, services)
}
func AppStatus(rw http.ResponseWriter, r *http.Request) {
log := appsLogger("status").Start()
app, err := models.GetApp(mux.Vars(r)["app"])
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
RenderText(rw, app.Status)
}
func ServiceStatus(rw http.ResponseWriter, r *http.Request) {
log := servicesLogger("show").Start()
name := mux.Vars(r)["service"]
service, err := models.GetServiceFromName(name)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
RenderText(rw, service.Status)
}
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 ProcessTop(rw http.ResponseWriter, r *http.Request) {
log := processesLogger("info").Start()
vars := mux.Vars(r)
app := vars["app"]
id := vars["id"]
_, err := models.GetApp(app)
if awsError(err) == "ValidationError" {
RenderNotFound(rw, fmt.Sprintf("no such app: %s", app))
return
}
ps, err := models.GetProcessById(app, id)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
if ps == nil {
RenderNotFound(rw, fmt.Sprintf("no such process: %s", id))
return
}
info, err := ps.Top()
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
RenderJson(rw, info)
}
func SettingsList(rw http.ResponseWriter, r *http.Request) {
github, err := models.SettingGet("github")
if err != nil {
helpers.Error(nil, err)
RenderError(rw, err)
return
}
heroku, err := models.SettingGet("heroku")
if err != nil {
helpers.Error(nil, err)
RenderError(rw, err)
return
}
params := map[string]interface{}{
"Github": github,
"Heroku": heroku,
}
RenderTemplate(rw, "settings", params)
}
func AppResources(rw http.ResponseWriter, r *http.Request) {
log := appsLogger("resources").Start()
app := mux.Vars(r)["app"]
resources, err := models.ListResources(app)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
RenderPartial(rw, "app", "resources", resources)
}
func AppDeployments(rw http.ResponseWriter, r *http.Request) {
log := appsLogger("deployments").Start()
app := mux.Vars(r)["app"]
deployments, err := models.ListDeployments(app)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
RenderPartial(rw, "app", "deployments", deployments)
}
func AppDebug(rw http.ResponseWriter, r *http.Request) {
log := appsLogger("environment").Start()
app := mux.Vars(r)["app"]
a, err := models.GetApp(app)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
RenderPartial(rw, "app", "debug", a)
}
func ServiceUnlink(rw http.ResponseWriter, r *http.Request) {
log := servicesLogger("unlink").Start()
vars := mux.Vars(r)
app := vars["app"]
name := vars["name"]
err := models.UnlinkService(app, name)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
}
RenderText(rw, "ok")
}
func ReleaseShow(rw http.ResponseWriter, r *http.Request) {
log := releasesLogger("show").Start()
vars := mux.Vars(r)
app := vars["app"]
release := vars["release"]
rr, err := models.GetRelease(app, release)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
RenderJson(rw, rr)
}
func ServiceShow(rw http.ResponseWriter, r *http.Request) {
log := servicesLogger("show").Start()
name := mux.Vars(r)["service"]
service, err := models.GetServiceFromName(name)
if err != nil {
helpers.Error(log, err)
RenderError(rw, err)
return
}
// sort.Sort(services)
RenderTemplate(rw, "service", service)
}