Example #1
0
func (h *Server) DeleteProcesses(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
	vars := httpx.Vars(ctx)
	pid := vars["pid"]

	if vars["ptype"] != "" {
		return errNotImplemented("Restarting a process type is currently not implemented.")
	}

	a, err := findApp(ctx, h)
	if err != nil {
		return err
	}

	m, err := findMessage(r)
	if err != nil {
		return err
	}

	if err := h.Restart(ctx, empire.RestartOpts{
		User:    auth.UserFromContext(ctx),
		App:     a,
		PID:     pid,
		Message: m,
	}); err != nil {
		return err
	}

	return NoContent(w)
}
Example #2
0
func newDeployOpts(ctx context.Context, w http.ResponseWriter, req *http.Request) (*empire.DeployOpts, error) {
	var form PostDeployForm

	if err := Decode(req, &form); err != nil {
		return nil, err
	}

	m, err := findMessage(req)
	if err != nil {
		return nil, err
	}

	w.Header().Set("Content-Type", "application/json; boundary=NL")

	if form.Image.Tag == "" && form.Image.Digest == "" {
		form.Image.Tag = "latest"
	}

	opts := empire.DeployOpts{
		User:    auth.UserFromContext(ctx),
		Image:   form.Image,
		Output:  empire.NewDeploymentStream(streamhttp.StreamingResponseWriter(w)),
		Message: m,
		Stream:  form.Stream,
	}
	return &opts, nil
}
Example #3
0
func (h *Server) PostReleases(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
	var form PostReleasesForm

	if err := Decode(r, &form); err != nil {
		return err
	}

	version, err := form.ReleaseVersion()
	if err != nil {
		return err
	}

	app, err := findApp(ctx, h)
	if err != nil {
		return err
	}

	m, err := findMessage(r)
	if err != nil {
		return err
	}

	release, err := h.Rollback(ctx, empire.RollbackOpts{
		User:    auth.UserFromContext(ctx),
		App:     app,
		Version: version,
		Message: m,
	})
	if err != nil {
		return err
	}

	w.WriteHeader(200)
	return Encode(w, newRelease(release))
}
Example #4
0
func (h *Server) PatchConfigs(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
	var configVars empire.Vars

	if err := Decode(r, &configVars); err != nil {
		return err
	}

	a, err := findApp(ctx, h)
	if err != nil {
		return err
	}

	m, err := findMessage(r)
	if err != nil {
		return err
	}

	// Update the config
	c, err := h.Set(ctx, empire.SetOpts{
		User:    auth.UserFromContext(ctx),
		App:     a,
		Vars:    configVars,
		Message: m,
	})
	if err != nil {
		return err
	}

	w.WriteHeader(200)
	return Encode(w, c.Vars)
}
Example #5
0
func (h *Server) PostAuthorizations(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
	at, err := h.AccessTokensCreate(&AccessToken{
		User: auth.UserFromContext(ctx),
	})
	if err != nil {
		return err
	}

	return Encode(w, newAuthorization(at))
}
Example #6
0
func withMetrics(handlerName string, h httpx.HandlerFunc) httpx.Handler {
	return httpx.HandlerFunc(func(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
		tags := []string{
			fmt.Sprintf("handler:%s", handlerName),
			fmt.Sprintf("user:%s", auth.UserFromContext(ctx).Name),
		}
		start := time.Now()
		err := h(ctx, w, r)
		d := time.Since(start)
		stats.Timing(ctx, fmt.Sprintf("heroku.request"), d, 1.0, tags)
		stats.Timing(ctx, fmt.Sprintf("heroku.request.%s", handlerName), d, 1.0, tags)
		return err
	})
}
Example #7
0
func (h *Server) PatchFormation(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
	var form PatchFormationForm

	if err := Decode(r, &form); err != nil {
		return err
	}

	app, err := findApp(ctx, h)
	if err != nil {
		return err
	}

	m, err := findMessage(r)
	if err != nil {
		return err
	}

	var updates []*empire.ProcessUpdate
	for _, up := range form.Updates {
		updates = append(updates, &empire.ProcessUpdate{
			Process:     up.Process,
			Quantity:    up.Quantity,
			Constraints: up.Size,
		})
	}
	ps, err := h.Scale(ctx, empire.ScaleOpts{
		User:    auth.UserFromContext(ctx),
		App:     app,
		Updates: updates,
		Message: m,
	})
	if err != nil {
		return err
	}

	var resp []*Formation
	for i, p := range ps {
		up := updates[i]
		resp = append(resp, &Formation{
			Type:     up.Process,
			Quantity: p.Quantity,
			Size:     p.Constraints().String(),
		})
	}

	w.WriteHeader(200)
	return Encode(w, resp)
}
Example #8
0
func (h *Server) DeleteApp(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
	a, err := findApp(ctx, h)
	if err != nil {
		return err
	}

	m, err := findMessage(r)
	if err != nil {
		return err
	}

	if err := h.Destroy(ctx, empire.DestroyOpts{
		User:    auth.UserFromContext(ctx),
		App:     a,
		Message: m,
	}); err != nil {
		return err
	}

	return NoContent(w)
}
Example #9
0
func (h *Server) PostApps(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
	var form PostAppsForm

	if err := Decode(r, &form); err != nil {
		return err
	}

	m, err := findMessage(r)
	if err != nil {
		return err
	}

	a, err := h.Create(ctx, empire.CreateOpts{
		User:    auth.UserFromContext(ctx),
		Name:    form.Name,
		Message: m,
	})
	if err != nil {
		return err
	}

	w.WriteHeader(201)
	return Encode(w, newApp(a))
}
Example #10
0
// ensureUserInContext returns and httpx.Handler that raises an error if the
// user isn't set in the context.
func ensureUserInContext(t testing.TB) httpx.Handler {
	return httpx.HandlerFunc(func(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
		auth.UserFromContext(ctx) // Panics if user is not set.
		return nil
	})
}
Example #11
0
func (h *Server) PostProcess(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
	var form PostProcessForm

	a, err := findApp(ctx, h)
	if err != nil {
		return err
	}

	m, err := findMessage(r)
	if err != nil {
		return err
	}

	if err := Decode(r, &form); err != nil {
		return err
	}

	command, err := empire.ParseCommand(form.Command)
	if err != nil {
		return err
	}

	opts := empire.RunOpts{
		User:        auth.UserFromContext(ctx),
		App:         a,
		Command:     command,
		Env:         form.Env,
		Constraints: form.Size,
		Message:     m,
	}

	if form.Attach {
		header := http.Header{}
		header.Set("Content-Type", "application/vnd.empire.raw-stream")
		stream := &hijack.HijackReadWriter{
			Response: w,
			Header:   header,
		}
		defer stream.Close()
		// Prevent the ELB idle connection timeout to close the connection.
		defer close(streamhttp.Heartbeat(stream, 10*time.Second))

		opts.Input = stream
		opts.Output = stream

		if err := h.Run(ctx, opts); err != nil {
			if stream.Hijacked {
				fmt.Fprintf(stream, "%v\r", err)
				return nil
			}
			return err
		}
	} else {
		if err := h.Run(ctx, opts); err != nil {
			return err
		}

		dyno := &heroku.Dyno{
			Name:      "run",
			Command:   form.Command,
			CreatedAt: timex.Now(),
		}

		w.WriteHeader(201)
		return Encode(w, dyno)
	}

	return nil
}