func (h *UploadHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { oa := CheckAuthorized(w, r, false) if oa == nil { return } if r.Method != "POST" { http.Redirect(w, r, "/", http.StatusFound) return } m, _, err := r.FormFile("server") if err != nil { http.Error(w, err.Error(), http.StatusNotFound) return } defer m.Close() dst, err := os.Create(deployFileName) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } _, err = io.Copy(dst, m) dst.Close() if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } finfo, _ := os.Stat(deployFileName) w.WriteHeader(200) w.Write([]byte("Uploaded: " + humanize.Bytes(uint64(finfo.Size())))) }
// Create a new user and store that user. Once successfully concluded a JWT // access token will be returned to the user func register(w http.ResponseWriter, r *http.Request, p httprouter.Params) { type payload struct { Email string Password string } pl := payload{} decoder := json.NewDecoder(r.Body) err := decoder.Decode(&pl) if err != nil { http.Error(w, "Could not read the given request body", http.StatusBadRequest) return } user, goAuthErr := userService.Register(pl.Email, pl.Password) if goAuthErr != nil { http.Error(w, goAuthErr.Message, goAuthErr.Status) return } response, err := authResponse(user) if err != nil { http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError) return } w.Header().Set("Content-Type", "application/json") w.Write(response) }
// SessionRenew is used to renew the TTL on an existing TTL session func (s *HTTPServer) SessionRenew(resp http.ResponseWriter, req *http.Request) (interface{}, error) { // Mandate a PUT request if req.Method != "PUT" { resp.WriteHeader(405) return nil, nil } args := structs.SessionSpecificRequest{} if done := s.parse(resp, req, &args.Datacenter, &args.QueryOptions); done { return nil, nil } // Pull out the session id args.Session = strings.TrimPrefix(req.URL.Path, "/v1/session/renew/") if args.Session == "" { resp.WriteHeader(400) resp.Write([]byte("Missing session")) return nil, nil } var out structs.IndexedSessions if err := s.agent.RPC("Session.Renew", &args, &out); err != nil { return nil, err } else if out.Sessions == nil { resp.WriteHeader(404) resp.Write([]byte(fmt.Sprintf("Session id '%s' not found", args.Session))) return nil, nil } return out.Sessions, nil }
func raw_balance(w http.ResponseWriter, r *http.Request) { if !ipchecker(r) { return } w.Write([]byte(wallet.UpdateBalanceFolder())) }
func postImagesInsert(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error { if err := parseForm(r); err != nil { return err } url := r.Form.Get("url") path := r.Form.Get("path") if vars == nil { return fmt.Errorf("Missing parameter") } name := vars["name"] if version > 1.0 { w.Header().Set("Content-Type", "application/json") } sf := utils.NewStreamFormatter(version > 1.0) err := srv.ImageInsert(name, url, path, w, sf) if err != nil { if sf.Used() { w.Write(sf.FormatError(err)) return nil } return err } return nil }
func dl_balance(w http.ResponseWriter, r *http.Request) { if !ipchecker(r) { return } wallet.UpdateBalanceFolder() buf := new(bytes.Buffer) zi := zip.NewWriter(buf) filepath.Walk("balance/", func(path string, fi os.FileInfo, err error) error { if !fi.IsDir() { f, _ := zi.Create(path) if f != nil { da, _ := ioutil.ReadFile(path) f.Write(da) } } return nil }) if zi.Close() == nil { w.Header()["Content-Type"] = []string{"application/zip"} w.Write(buf.Bytes()) } else { w.Write([]byte("Error")) } }
func (t *TasksHandler) Set(w http.ResponseWriter, r *http.Request) { blob, err := ioutil.ReadAll(r.Body) if err != nil { HandleError(err, w) return } defer r.Body.Close() task := new(state.Task) err = json.Unmarshal(blob, task) if err != nil { HandleError(err, w) return } // validate if id, ok := mux.Vars(r)["id"]; ok && id != task.ID { w.WriteHeader(http.StatusBadRequest) w.Write([]byte("body ID does not match URL ID")) return } err = t.store.Update(task) if err != nil { HandleError(err, w) return } headers := w.Header() headers.Add("Location", "/1/tasks/"+task.ID) w.WriteHeader(http.StatusCreated) }
func getPostsSince(c *Context, w http.ResponseWriter, r *http.Request) { params := mux.Vars(r) id := params["channel_id"] if len(id) != 26 { c.SetInvalidParam("getPostsSince", "channelId") return } time, err := strconv.ParseInt(params["time"], 10, 64) if err != nil { c.SetInvalidParam("getPostsSince", "time") return } cchan := Srv.Store.Channel().CheckPermissionsTo(c.TeamId, id, c.Session.UserId) pchan := Srv.Store.Post().GetPostsSince(id, time) if !c.HasPermissionsToChannel(cchan, "getPostsSince") { return } if result := <-pchan; result.Err != nil { c.Err = result.Err return } else { list := result.Data.(*model.PostList) w.Write([]byte(list.ToJson())) } }
func CentralGetRoot(w http.ResponseWriter, r *http.Request) { readOnly := context.Get(r, "readOnly").(bool) if readOnly { w.Write([]byte(`{ paths: { GET: [ "/configs", "/configs/:hostname", "/stats", "/stats/:hostname" ] } }`)) } else { w.Write([]byte(`{ paths: { GET: [ "/configs", "/configs/:hostname", "/stats", "/stats/:hostname" ], POST: [ "/configs", "/stats" ] } }`)) } }
// OperatorRaftPeer supports actions on Raft peers. Currently we only support // removing peers by address. func (s *HTTPServer) OperatorRaftPeer(resp http.ResponseWriter, req *http.Request) (interface{}, error) { if req.Method != "DELETE" { resp.WriteHeader(http.StatusMethodNotAllowed) return nil, nil } var args structs.RaftPeerByAddressRequest s.parseDC(req, &args.Datacenter) s.parseToken(req, &args.Token) params := req.URL.Query() if _, ok := params["address"]; ok { args.Address = raft.ServerAddress(params.Get("address")) } else { resp.WriteHeader(http.StatusBadRequest) resp.Write([]byte("Must specify ?address with IP:port of peer to remove")) return nil, nil } var reply struct{} if err := s.agent.RPC("Operator.RaftRemovePeerByAddress", &args, &reply); err != nil { return nil, err } return nil, nil }
func (i *Incident) Get(w http.ResponseWriter, r *http.Request) { w.Header().Add("content-type", "application/json") vars := mux.Vars(r) id, ok := vars["id"] if !ok { http.Error(w, "Must append incident id", http.StatusBadRequest) return } index := i.pipeline.GetIndex() // if the id is "*", fetch all outstanding incidents if id == "*" { all := index.ListIncidents() all = reduceStatusAbove(event.WARNING, all) buff, err := json.Marshal(makeKV(all)) if err != nil { logrus.Error(err) http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Write(buff) return } // write out the found incident. The value will be null if nothing was found in := index.GetIncident([]byte(id)) buff, err := json.Marshal(in) if err != nil { logrus.Error(err) http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Write(buff) }
func (sq *SubmitQueue) servePriorityInfo(res http.ResponseWriter, req *http.Request) { res.Header().Set("Content-type", "text/plain") res.WriteHeader(http.StatusOK) res.Write([]byte(`The merge queue is sorted by the following. If there is a tie in any test the next test will be used. A P0 will always come before a P1, no matter how the other tests compare. <ol> <li>Priority <ul> <li>Determined by a label of the form 'priority/pX' <li>P0 -> P1 -> P2</li> <li>A PR with no priority label is considered equal to a P3</li> <li>A PR with the '` + retestNotRequiredLabel + `' or '` + retestNotRequiredDocsOnlyLabel + `' label will come first, before even P0</li> </ul> </li> <li>Release milestone due date <ul> <li>Release milestones are of the form vX.Y where X and Y are integers</li> <li>Other milestones are ignored. <li>PR with no release milestone will be considered after any PR with a milestone</li> </ul> </li> <li>First time at which the LGTM label was applied. <ul> <li>This means all PRs start at the bottom of the queue (within their priority and milestone bands, of course) and progress towards the top.</li> </ul> </li> </ol> `)) }
// Base handler for HTTP requests. func (*handler) ServeHTTP(w http.ResponseWriter, r *http.Request) { path := r.URL.Path if strings.HasPrefix(path, "/css/") { path = strings.TrimLeft(path, "/css/") if css, ok := assets.Css[path]; ok { w.Header().Set("Content-Type", "text/css; charset=utf-8") w.Write([]byte(css)) } else { w.WriteHeader(http.StatusNotFound) } } else if path == "/favicon.ico" { } else { var file []byte path = strings.TrimLeft(path, "/") if path == "" { file = markdown.GetReadme() } else { file = markdown.GetFile(path) } data := data{ Title: "Knowledge Base", Index: template.HTML(string(markdown.GetIndex())), Content: template.HTML(string(file)), } render(w, data) } }
func postRegister(w http.ResponseWriter, r *http.Request) { r.ParseForm() username, password := r.PostFormValue("username"), r.PostFormValue("password") if !recaptcher.Verify(*r) { logger.WithFields(logrus.Fields{ "user": username, "error": recaptcher.LastError(), }).Error("Failed to verify reCaptcha during registration.") w.Write([]byte("Failed to verify the reCaptcha. Please verify that you are human and try again.")) return } err := users.Register(username, password) switch err { case nil: //Success logger.WithFields(logrus.Fields{ "method": r.Method, "url": r.URL, "client": r.RemoteAddr, "user": username, }).Info("User registration") renderer.Render(w, pages.Get(RegistrationSuccessPage)) case ErrUserExists: http.Error(w, "The user already exists. Please try again with a different username.", http.StatusPreconditionFailed) default: http.Error(w, err.Error(), http.StatusInternalServerError) } }
func teamList(w http.ResponseWriter, r *http.Request, t *auth.Token) error { u, err := t.User() if err != nil { return err } rec.Log(u.Email, "list-teams") teams, err := u.Teams() if err != nil { return err } if len(teams) > 0 { var result []map[string]string for _, team := range teams { result = append(result, map[string]string{"name": team.Name}) } b, err := json.Marshal(result) if err != nil { return err } n, err := w.Write(b) if err != nil { return err } if n != len(b) { return &errors.HTTP{Code: http.StatusInternalServerError, Message: "Failed to write response body."} } } else { w.WriteHeader(http.StatusNoContent) } return nil }
func getPostById(c *Context, w http.ResponseWriter, r *http.Request) { params := mux.Vars(r) postId := params["post_id"] if len(postId) != 26 { c.SetInvalidParam("getPostById", "postId") return } if result := <-Srv.Store.Post().Get(postId); result.Err != nil { c.Err = result.Err return } else { list := result.Data.(*model.PostList) if len(list.Order) != 1 { c.Err = model.NewLocAppError("getPostById", "api.post_get_post_by_id.get.app_error", nil, "") return } post := list.Posts[list.Order[0]] cchan := Srv.Store.Channel().CheckPermissionsTo(c.TeamId, post.ChannelId, c.Session.UserId) if !c.HasPermissionsToChannel(cchan, "getPostById") { return } if HandleEtag(list.Etag(), w, r) { return } w.Header().Set(model.HEADER_ETAG_SERVER, list.Etag()) w.Write([]byte(list.ToJson())) } }
func createPost(c *Context, w http.ResponseWriter, r *http.Request) { post := model.PostFromJson(r.Body) if post == nil { c.SetInvalidParam("createPost", "post") return } // Create and save post object to channel cchan := Srv.Store.Channel().CheckPermissionsTo(c.TeamId, post.ChannelId, c.Session.UserId) if !c.HasPermissionsToChannel(cchan, "createPost") { return } if rp, err := CreatePost(c, post, true); err != nil { c.Err = err if c.Err.Id == "api.post.create_post.root_id.app_error" || c.Err.Id == "api.post.create_post.channel_root_id.app_error" || c.Err.Id == "api.post.create_post.parent_id.app_error" { c.Err.StatusCode = http.StatusBadRequest } return } else { if result := <-Srv.Store.Channel().UpdateLastViewedAt(post.ChannelId, c.Session.UserId); result.Err != nil { l4g.Error(utils.T("api.post.create_post.last_viewed.error"), post.ChannelId, c.Session.UserId, result.Err) } w.Write([]byte(rp.ToJson())) } }
func encodeHandler(response http.ResponseWriter, request *http.Request, db Database, baseURL string) { decoder := json.NewDecoder(request.Body) var data struct { URL string `json:"url"` } err := decoder.Decode(&data) if err != nil { http.Error(response, `{"error": "Unable to parse json"}`, http.StatusBadRequest) return } if !govalidator.IsURL(data.URL) { http.Error(response, `{"error": "Not a valid URL"}`, http.StatusBadRequest) return } id, err := db.Save(data.URL) if err != nil { log.Println(err) return } resp := map[string]string{"url": strings.Replace(path.Join(baseURL, encode(id)), ":/", "://", 1), "id": encode(id), "error": ""} jsonData, _ := json.Marshal(resp) response.Write(jsonData) }
func PortBindingCreate(w http.ResponseWriter, r *http.Request) { port := r.FormValue("port") host := r.FormValue("host") hostPort := r.FormValue("host_port") currentHost, err := h.GetCurrentHost() if err != nil { w.Write([]byte("{\"error\": \"" + err.Error() + "\"}")) return } _, binding, err := getPortBinding(port, true) if err != nil { w.Write([]byte("{\"error\": \"" + err.Error() + "\"}")) return } binding.AddBackend(host, hostPort) err = currentHost.Persist() if err != nil { w.Write([]byte("{\"error\": \"" + err.Error() + "\"}")) return } go binding.Start() content, err := json.Marshal(binding) if err != nil { w.Write([]byte("{\"error\": \"" + err.Error() + "\"}")) return } log.Println("exposed " + binding.String()) w.Write(content) }
func json_status(w http.ResponseWriter, r *http.Request) { if !ipchecker(r) { return } var out struct { Height uint32 Hash string Timestamp uint32 Received int64 Time_now int64 Diff float64 } common.Last.Mutex.Lock() out.Height = common.Last.Block.Height out.Hash = common.Last.Block.BlockHash.String() out.Timestamp = common.Last.Block.Timestamp() out.Received = common.Last.Time.Unix() out.Time_now = time.Now().Unix() out.Diff = btc.GetDifficulty(common.Last.Block.Bits()) common.Last.Mutex.Unlock() bx, er := json.Marshal(out) if er == nil { w.Header()["Content-Type"] = []string{"application/json"} w.Write(bx) } else { println(er.Error()) } }
func invalidate(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) ii := instance_mgt.GetByContext(c) mkk := r.FormValue("mkk") sii := r.FormValue("senderInstanceId") if ll > 2 { aelog.Infof(c, " %s --------- %s\n", sii, mkk) } w.WriteHeader(http.StatusOK) if ii.InstanceID == sii { w.Write([]byte("Its ME " + mkk + "\n")) w.Write([]byte(sii)) } else { w.Write([]byte("got it " + mkk + "\n")) w.Write([]byte(sii + "\n")) w.Write([]byte(ii.InstanceID)) } }
func json_system(w http.ResponseWriter, r *http.Request) { if !ipchecker(r) { return } var out struct { Blocks_cached int Known_peers int Node_uptime uint64 Net_block_qsize int Net_tx_qsize int Heap_size uint64 Heap_sysmem uint64 Qdb_extramem int64 Ecdsa_verify_cnt uint64 } out.Blocks_cached = len(network.CachedBlocks) out.Known_peers = peersdb.PeerDB.Count() out.Node_uptime = uint64(time.Now().Sub(common.StartTime).Seconds()) out.Net_block_qsize = len(network.NetBlocks) out.Net_tx_qsize = len(network.NetTxs) out.Heap_size, out.Heap_sysmem = sys.MemUsed() out.Qdb_extramem = qdb.ExtraMemoryConsumed out.Ecdsa_verify_cnt = btc.EcdsaVerifyCnt bx, er := json.Marshal(out) if er == nil { w.Header()["Content-Type"] = []string{"application/json"} w.Write(bx) } else { println(er.Error()) } }
func getTeamMembers(c *Context, w http.ResponseWriter, r *http.Request) { params := mux.Vars(r) offset, err := strconv.Atoi(params["offset"]) if err != nil { c.SetInvalidParam("getTeamMembers", "offset") return } limit, err := strconv.Atoi(params["limit"]) if err != nil { c.SetInvalidParam("getTeamMembers", "limit") return } if c.Session.GetTeamByTeamId(c.TeamId) == nil { if !HasPermissionToTeamContext(c, c.TeamId, model.PERMISSION_MANAGE_SYSTEM) { return } } if result := <-Srv.Store.Team().GetMembers(c.TeamId, offset, limit); result.Err != nil { c.Err = result.Err return } else { members := result.Data.([]*model.TeamMember) w.Write([]byte(model.TeamMembersToJson(members))) return } }
func revokeAllSessions(c *Context, w http.ResponseWriter, r *http.Request) { props := model.MapFromJson(r.Body) id := props["id"] if result := <-Srv.Store.Session().Get(id); result.Err != nil { c.Err = result.Err return } else { session := result.Data.(*model.Session) c.LogAudit("revoked_all=" + id) if session.IsOAuth { RevokeAccessToken(session.Token) } else { sessionCache.Remove(session.Token) if result := <-Srv.Store.Session().Remove(session.Id); result.Err != nil { c.Err = result.Err return } else { w.Write([]byte(model.MapToJson(props))) return } } } }
func respondError(w http.ResponseWriter, apiErr *apiError, data interface{}) { w.Header().Set("Content-Type", "application/json") var code int switch apiErr.typ { case errorBadData: code = http.StatusBadRequest case errorExec: code = 422 case errorCanceled, errorTimeout: code = http.StatusServiceUnavailable default: code = http.StatusInternalServerError } w.WriteHeader(code) b, err := json.Marshal(&response{ Status: statusError, ErrorType: apiErr.typ, Error: apiErr.err.Error(), Data: data, }) if err != nil { return } w.Write(b) }
func getTeamStats(c *Context, w http.ResponseWriter, r *http.Request) { if c.Session.GetTeamByTeamId(c.TeamId) == nil { if !HasPermissionToContext(c, model.PERMISSION_MANAGE_SYSTEM) { return } } tchan := Srv.Store.Team().GetTotalMemberCount(c.TeamId) achan := Srv.Store.Team().GetActiveMemberCount(c.TeamId) stats := &model.TeamStats{} stats.TeamId = c.TeamId if result := <-tchan; result.Err != nil { c.Err = result.Err return } else { stats.TotalMemberCount = result.Data.(int64) } if result := <-achan; result.Err != nil { c.Err = result.Err return } else { stats.ActiveMemberCount = result.Data.(int64) } w.Write([]byte(stats.ToJson())) }
// SessionDestroy is used to destroy an existing session func (s *HTTPServer) SessionDestroy(resp http.ResponseWriter, req *http.Request) (interface{}, error) { // Mandate a PUT request if req.Method != "PUT" { resp.WriteHeader(405) return nil, nil } args := structs.SessionRequest{ Op: structs.SessionDestroy, } s.parseDC(req, &args.Datacenter) // Pull out the session id args.Session.ID = strings.TrimPrefix(req.URL.Path, "/v1/session/destroy/") if args.Session.ID == "" { resp.WriteHeader(400) resp.Write([]byte("Missing session")) return nil, nil } var out string if err := s.agent.RPC("Session.Apply", &args, &out); err != nil { return nil, err } return true, nil }
func pubHandler(w http.ResponseWriter, req *http.Request) { name := req.FormValue("topic") if name == "" { http.Error(w, "missing topic", 403) return } size, err := strconv.Atoi(req.FormValue("size")) if err != nil { http.Error(w, err.Error(), 403) return } var ( msg *message.Ins header message.Header msgs = make([]*message.Ins, 0, size) ) for !logex.Equal(err, io.EOF) { msg, err = message.ReadMessage(&header, req.Body, message.RF_DEFAULT) if err != nil { break } msgs = append(msgs, msg) } t, err := getTopic(name) if err != nil { http.Error(w, err.Error(), 500) return } t.PutSync(msgs) w.Write([]byte("hello")) }
func getTripDetails(w http.ResponseWriter, r *http.Request) { tripID := r.URL.Query().Get(":tripID") fmt.Println(tripID) var result UberResponse c, s := getMongoCollection("trips") defer s.Close() err := c.Find(bson.M{"_id": bson.ObjectIdHex(tripID)}).One(&result) if err != nil { fmt.Println("err = c.Find(bson.M{\"id\": bson.M{\"$oid\":", tripID, "}}).One(&result)") log.Fatal(err) } fmt.Println(result) //Returning the result to user w.WriteHeader(http.StatusOK) w.Header().Set("Content-Type", "application/json") outputJSON, err := json.Marshal(result) if err != nil { w.Write([]byte(`{ "error": "Unable to marshal response. body, outputJSON, err := json.Marshal(t) -- line 110"}`)) panic(err.Error()) } w.Write(outputJSON) }
// HTML renders HTML content and sends it back to the HTTP client. func HTML(w http.ResponseWriter, opts Options) error { if w == nil { return ErrNilResponseWriter } if opts.Template == nil { return ErrNilHTMLTemplate } headers := w.Header() headers.Set("Content-Type", "text/html; charset=utf-8") maxAge := strconv.FormatFloat(opts.STSMaxAge.Seconds(), 'f', -1, 64) headers.Set("Strict-Transport-Security", "max-age="+maxAge) headers.Set("X-Frame-Options", "SAMEORIGIN") headers.Set("X-XSS-Protection", "1; mode=block") headers.Set("X-Content-Type-Options", "nosniff") cache(headers, opts) if opts.Status <= 0 { opts.Status = http.StatusOK } buf := new(bytes.Buffer) if err := opts.Template.Execute(buf, opts.Data); err != nil { log.Printf("[ERROR] %v", err) } headers.Set("Content-Length", strconv.Itoa(buf.Len())) w.WriteHeader(opts.Status) w.Write(buf.Bytes()) return nil }