Exemplo n.º 1
0
Arquivo: tools.go Projeto: bac/juju
func (h *toolsDownloadHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	st, err := h.ctxt.stateForRequestUnauthenticated(r)
	if err != nil {
		if err := sendError(w, err); err != nil {
			logger.Errorf("%v", err)
		}
		return
	}

	switch r.Method {
	case "GET":
		tarball, err := h.processGet(r, st)
		if err != nil {
			logger.Errorf("GET(%s) failed: %v", r.URL, err)
			if err := sendError(w, errors.NewBadRequest(err, "")); err != nil {
				logger.Errorf("%v", err)
			}
			return
		}
		if err := h.sendTools(w, http.StatusOK, tarball); err != nil {
			logger.Errorf("%v", err)
		}
	default:
		if err := sendError(w, errors.MethodNotAllowedf("unsupported method: %q", r.Method)); err != nil {
			logger.Errorf("%v", err)
		}
	}
}
Exemplo n.º 2
0
Arquivo: tools.go Projeto: bac/juju
func (h *toolsUploadHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// Validate before authenticate because the authentication is dependent
	// on the state connection that is determined during the validation.
	st, _, err := h.ctxt.stateForRequestAuthenticatedUser(r)
	if err != nil {
		if err := sendError(w, err); err != nil {
			logger.Errorf("%v", err)
		}
		return
	}

	switch r.Method {
	case "POST":
		// Add tools to storage.
		agentTools, err := h.processPost(r, st)
		if err != nil {
			if err := sendError(w, err); err != nil {
				logger.Errorf("%v", err)
			}
			return
		}
		if err := sendStatusAndJSON(w, http.StatusOK, &params.ToolsResult{
			ToolsList: tools.List{agentTools},
		}); err != nil {
			logger.Errorf("%v", err)
		}
	default:
		if err := sendError(w, errors.MethodNotAllowedf("unsupported method: %q", r.Method)); err != nil {
			logger.Errorf("%v", err)
		}
	}
}
Exemplo n.º 3
0
// ServeHTTP implements http.Handler.
func (h *LegacyHTTPHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
	st, tag, err := h.Connect(req)
	if err != nil {
		api.SendHTTPError(resp, err)
		return
	}

	var username string
	switch tag := tag.(type) {
	case *names.UserTag:
		username = tag.Name()
	default:
		// TODO(ericsnow) Fail?
		username = tag.Id()
	}

	// We do this *after* authorization, etc. (in h.Connect) in order
	// to prioritize errors that may originate there.
	switch req.Method {
	case "PUT":
		logger.Infof("handling resource upload request")
		response, err := h.HandleUpload(username, st, req)
		if err != nil {
			api.SendHTTPError(resp, err)
			return
		}
		api.SendHTTPStatusAndJSON(resp, http.StatusOK, &response)
		logger.Infof("resource upload request successful")
	default:
		api.SendHTTPError(resp, errors.MethodNotAllowedf("unsupported method: %q", req.Method))
	}
}
Exemplo n.º 4
0
func (h *testServiceHandler) _http_TestService_List(ctx golang_org_x_net_context.Context, rw net_http.ResponseWriter, req *net_http.Request) error {
	if req.Method != "GET" {
		return github_com_juju_errors.MethodNotAllowedf("expected GET request")
	}

	var (
		input ListOptions
	)

	ctx = github_com_limbo_services_core_runtime_limbo.AnnotateContext(ctx, req)

	// populate after=after
	{
		var msg0 = &input
		val := req.URL.Query().Get("after")
		intVal, _ := strconv.ParseInt(val, 10, 64)
		msg0.After = int64(intVal)
	}

	{ // call
		ss, err := github_com_limbo_services_core_runtime_limbo.NewPagedServerStream(ctx, rw, 0)
		if err != nil {
			return github_com_juju_errors.Trace(err)
		}
		defer ss.Close()
		stream := &testServiceListServer{ss}
		err = h.ss.List(&input, stream)
	}

	return nil
}
Exemplo n.º 5
0
Arquivo: backup.go Projeto: bac/juju
func (h *backupHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
	// Validate before authenticate because the authentication is dependent
	// on the state connection that is determined during the validation.
	st, _, err := h.ctxt.stateForRequestAuthenticatedUser(req)
	if err != nil {
		h.sendError(resp, err)
		return
	}

	backups, closer := newBackups(st)
	defer closer.Close()

	switch req.Method {
	case "GET":
		logger.Infof("handling backups download request")
		id, err := h.download(backups, resp, req)
		if err != nil {
			h.sendError(resp, err)
			return
		}
		logger.Infof("backups download request successful for %q", id)
	case "PUT":
		logger.Infof("handling backups upload request")
		id, err := h.upload(backups, resp, req)
		if err != nil {
			h.sendError(resp, err)
			return
		}
		logger.Infof("backups upload request successful for %q", id)
	default:
		h.sendError(resp, errors.MethodNotAllowedf("unsupported method: %q", req.Method))
	}
}
Exemplo n.º 6
0
func (h *testServiceHandler) _http_TestService_FetchPerson(ctx golang_org_x_net_context.Context, rw net_http.ResponseWriter, req *net_http.Request) error {
	if req.Method != "GET" {
		return github_com_juju_errors.MethodNotAllowedf("expected GET request")
	}

	var (
		input  FetchOptions
		params = github_com_limbo_services_core_runtime_router.P(ctx)
	)

	ctx = github_com_limbo_services_core_runtime_limbo.AnnotateContext(ctx, req)

	// populate id
	{
		var msg0 = &input
		val := params.Get("id")
		intVal, _ := strconv.ParseInt(val, 10, 64)
		msg0.Id = int64(intVal)
	}

	{ // call
		output, err := h.ss.FetchPerson(ctx, &input)
		if err != nil {
			return github_com_juju_errors.Trace(err)
		}
		github_com_limbo_services_core_runtime_limbo.RenderMessageJSON(rw, 200, output)
		return nil
	}

	return nil
}
Exemplo n.º 7
0
func (h *testServiceHandler) _http_TestService_Greet(ctx golang_org_x_net_context.Context, rw net_http.ResponseWriter, req *net_http.Request) error {
	if req.Method != "POST" {
		return github_com_juju_errors.MethodNotAllowedf("expected POST request")
	}

	var (
		input Person
	)

	ctx = github_com_limbo_services_core_runtime_limbo.AnnotateContext(ctx, req)

	{ // from body
		err := encoding_json.NewDecoder(req.Body).Decode(&input)
		if err != nil {
			return github_com_juju_errors.Trace(err)
		}
	}

	{ // call
		output, err := h.ss.Greet(ctx, &input)
		if err != nil {
			return github_com_juju_errors.Trace(err)
		}
		github_com_limbo_services_core_runtime_limbo.RenderMessageJSON(rw, 200, output)
		return nil
	}

	return nil
}
Exemplo n.º 8
0
// ServeHTTP implements the http.Handler interface.
func (h *registerUserHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	if req.Method != "POST" {
		sendError(w, errors.MethodNotAllowedf("unsupported method: %q", req.Method))
		return
	}
	st, err := h.ctxt.stateForRequestUnauthenticated(req)
	if err != nil {
		sendError(w, err)
		return
	}
	userTag, response, err := h.processPost(req, st)
	if err != nil {
		sendError(w, err)
		return
	}

	// Set a short-lived macaroon as a cookie on the response,
	// which the client can use to obtain a discharge macaroon.
	m, err := h.ctxt.srv.authCtxt.CreateLocalLoginMacaroon(userTag)
	if err != nil {
		sendError(w, err)
		return
	}
	cookie, err := httpbakery.NewCookie(macaroon.Slice{m})
	if err != nil {
		sendError(w, err)
		return
	}
	http.SetCookie(w, cookie)

	sendStatusAndJSON(w, http.StatusOK, response)
}
Exemplo n.º 9
0
Arquivo: gui.go Projeto: kat-co/juju
// ServeHTTP implements http.Handler.
func (h *guiVersionHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	if req.Method != "PUT" {
		sendError(w, errors.MethodNotAllowedf("unsupported method: %q", req.Method))
		return
	}
	if err := h.handlePut(w, req); err != nil {
		sendError(w, errors.Trace(err))
	}
}
Exemplo n.º 10
0
func (h *charmsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	var err error
	switch r.Method {
	case "POST":
		err = h.servePost(w, r)
	case "GET":
		err = h.serveGet(w, r)
	default:
		err = errors.MethodNotAllowedf("unsupported method: %q", r.Method)
	}
	if err != nil {
		h.sendError(w, r, err)
	}
}
Exemplo n.º 11
0
Arquivo: gui.go Projeto: kat-co/juju
// ServeHTTP implements http.Handler.
func (h *guiArchiveHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	var handler func(http.ResponseWriter, *http.Request) error
	switch req.Method {
	case "GET":
		handler = h.handleGet
	case "POST":
		handler = h.handlePost
	default:
		sendError(w, errors.MethodNotAllowedf("unsupported method: %q", req.Method))
		return
	}
	if err := handler(w, req); err != nil {
		sendError(w, errors.Trace(err))
	}
}
Exemplo n.º 12
0
// ServeHTTP implements the http.Handler interface.
func (h *registerUserHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	if req.Method != "POST" {
		sendError(w, errors.MethodNotAllowedf("unsupported method: %q", req.Method))
		return
	}
	st, err := h.ctxt.stateForRequestUnauthenticated(req)
	if err != nil {
		sendError(w, err)
		return
	}
	response, err := h.processPost(req, st)
	if err != nil {
		sendError(w, err)
		return
	}
	sendStatusAndJSON(w, http.StatusOK, response)
}
Exemplo n.º 13
0
func (h *imagesDownloadHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	st, err := h.ctxt.stateForRequestUnauthenticated(r)
	if err != nil {
		sendError(w, err)
		return
	}
	switch r.Method {
	case "GET":
		err := h.processGet(r, w, st)
		if err != nil {
			logger.Errorf("GET(%s) failed: %v", r.URL, err)
			sendError(w, err)
			return
		}
	default:
		sendError(w, errors.MethodNotAllowedf("unsupported method: %q", r.Method))
	}
}
Exemplo n.º 14
0
// ServeHTTP implements http.Handler.
func (h *LegacyHTTPHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
	opener, err := h.NewResourceOpener(req)
	if err != nil {
		h.SendHTTPError(resp, err)
		return
	}

	// We do this *after* authorization, etc. (in h.Extract...) in order
	// to prioritize errors that may originate there.
	switch req.Method {
	case "GET":
		logger.Infof("handling resource download request")

		opened, err := h.HandleDownload(opener, req)
		if err != nil {
			logger.Errorf("cannot fetch resource reader: %v", err)
			h.SendHTTPError(resp, err)
			return
		}
		defer opened.Close()

		h.UpdateDownloadResponse(resp, opened.Resource)

		resp.WriteHeader(http.StatusOK)
		if err := h.Copy(resp, opened); err != nil {
			// We cannot use api.SendHTTPError here, so we log the error
			// and move on.
			logger.Errorf("unable to complete stream for resource: %v", err)
			return
		}

		logger.Infof("resource download request successful")
	default:
		h.SendHTTPError(resp, errors.MethodNotAllowedf("unsupported method: %q", req.Method))
	}
}
Exemplo n.º 15
0
	err:        common.OperationBlockedError("test"),
	code:       params.CodeOperationBlocked,
	status:     http.StatusBadRequest,
	helperFunc: params.IsCodeOperationBlocked,
}, {
	err:        errors.NotSupportedf("needed feature"),
	code:       params.CodeNotSupported,
	status:     http.StatusInternalServerError,
	helperFunc: params.IsCodeNotSupported,
}, {
	err:        errors.BadRequestf("something"),
	code:       params.CodeBadRequest,
	status:     http.StatusBadRequest,
	helperFunc: params.IsBadRequest,
}, {
	err:        errors.MethodNotAllowedf("something"),
	code:       params.CodeMethodNotAllowed,
	status:     http.StatusMethodNotAllowed,
	helperFunc: params.IsMethodNotAllowed,
}, {
	err:    stderrors.New("an error"),
	status: http.StatusInternalServerError,
	code:   "",
}, {
	err: &common.DischargeRequiredError{
		Cause:    errors.New("something"),
		Macaroon: sampleMacaroon,
	},
	status: http.StatusUnauthorized,
	code:   params.CodeDischargeRequired,
	helperFunc: func(err error) bool {
Exemplo n.º 16
0
Arquivo: charms.go Projeto: bac/juju
func emitUnsupportedMethodErr(method string) error {
	return errors.MethodNotAllowedf("unsupported method: %q", method)
}