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())))) }
// 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 }
// ServeHTTP dispatches the handler registered in the matched route. // // When there is a match, the route variables can be retrieved calling // mux.Vars(request). func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) { // Clean path to canonical form and redirect. if p := cleanPath(req.URL.Path); p != req.URL.Path { // Added 3 lines (Philip Schlump) - It was dropping the query string and #whatever from query. // This matches with fix in go 1.2 r.c. 4 for same problem. Go Issue: // http://code.google.com/p/go/issues/detail?id=5252 url := *req.URL url.Path = p p = url.String() w.Header().Set("Location", p) w.WriteHeader(http.StatusMovedPermanently) return } var match RouteMatch var handler http.Handler if r.Match(req, &match) { handler = match.Handler setVars(req, match.Vars) setCurrentRoute(req, match.Route) } if handler == nil { handler = r.NotFoundHandler if handler == nil { handler = http.NotFoundHandler() } } if !r.KeepContext { defer context.Clear(req) } handler.ServeHTTP(w, req) }
func TodoIndex(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json; charset=UTF-8") w.WriteHeader(http.StatusOK) if err := json.NewEncoder(w).Encode(todos); err != nil { panic(err) } }
func raw_balance(w http.ResponseWriter, r *http.Request) { if !ipchecker(r) { return } w.Write([]byte(wallet.UpdateBalanceFolder())) }
// showBlockPage shows a block page for a page that was blocked by an ACL. func (c *config) showBlockPage(w http.ResponseWriter, r *http.Request, resp *http.Response, user string, tally map[rule]int, scores map[string]int, rule ACLActionRule) { w.WriteHeader(http.StatusForbidden) if c.BlockTemplate == nil { return } data := blockData{ URL: r.URL.String(), Conditions: rule.Conditions(), User: user, Tally: listTally(stringTally(tally)), Scores: listTally(scores), Request: r, Response: resp, } w.Header().Set("Content-Type", "text/html; charset=utf-8") // Convert rule conditions into category descriptions as much as possible. var categories []string for _, acl := range rule.Needed { categories = append(categories, c.aclDescription(acl)) } for _, acl := range rule.Disallowed { categories = append(categories, "not "+c.aclDescription(acl)) } data.Categories = strings.Join(categories, ", ") err := c.BlockTemplate.Execute(w, data) if err != nil { log.Println("Error filling in block page template:", err) } }
func postContainersKill(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error { if vars == nil { return fmt.Errorf("Missing parameter") } if err := parseForm(r); err != nil { return err } name := vars["name"] signal := 0 if r != nil { s := r.Form.Get("signal") if s != "" { if s, err := strconv.Atoi(s); err != nil { return err } else { signal = s } } } if err := srv.ContainerKill(name, signal); err != nil { return err } w.WriteHeader(http.StatusNoContent) return nil }
func WriteSuccess(w http.ResponseWriter, code int) error { fmt.Println(code) w.Header().Set("Content-Type", "application/json; charset=utf-8") w.WriteHeader(code) item := Item{Item: "success"} return json.NewEncoder(w).Encode(item) }
func scriptSmoothie(w http.ResponseWriter, r *http.Request) { fmt.Println("scriptSmoothie:") if true { w.Header().Set("ContentType", "text/javascript") http.ServeFile(w, r, "smoothie.js") } }
func writeJson(w http.ResponseWriter, r *http.Request, obj interface{}) (err error) { w.Header().Set("Content-Type", "application/javascript") var bytes []byte if r.FormValue("pretty") != "" { bytes, err = json.MarshalIndent(obj, "", " ") } else { bytes, err = json.Marshal(obj) } if err != nil { return } callback := r.FormValue("callback") if callback == "" { _, err = w.Write(bytes) } else { if _, err = w.Write([]uint8(callback)); err != nil { return } if _, err = w.Write([]uint8("(")); err != nil { return } fmt.Fprint(w, string(bytes)) if _, err = w.Write([]uint8(")")); err != nil { return } } return }
func (s *apiService) getJSMetadata(w http.ResponseWriter, r *http.Request) { meta, _ := json.Marshal(map[string]string{ "deviceID": s.id.String(), }) w.Header().Set("Content-Type", "application/javascript") fmt.Fprintf(w, "var metadata = %s;\n", meta) }
func Register(w http.ResponseWriter, r *http.Request) { user := models.User{} if r.FormValue("displayName") != "" { user.DisplayName = r.FormValue("displayName") } else { user.DisplayName = "NULL" } _email := r.FormValue("email") if _email != "" { user.Email.Scan(_email) } if r.FormValue("password") != "" { user.Password = r.FormValue("password") } else { user.Password = "******" } createUserToken(&user) if err := repository.CreateUser(&user).Error; err != nil { w.WriteHeader(http.StatusForbidden) json.NewEncoder(w).Encode(err) return } log.Println(user) json.NewEncoder(w).Encode(user) }
// ServeHTTP implements `http.Handler` interface. func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Request req := s.pool.request.Get().(*Request) reqHdr := s.pool.header.Get().(*Header) reqURL := s.pool.url.Get().(*URL) reqHdr.reset(r.Header) reqURL.reset(r.URL) req.reset(r, reqHdr, reqURL) // Response res := s.pool.response.Get().(*Response) resAdpt := s.pool.responseAdapter.Get().(*responseAdapter) resAdpt.reset(res) resHdr := s.pool.header.Get().(*Header) resHdr.reset(w.Header()) res.reset(w, resAdpt, resHdr) s.handler.ServeHTTP(req, res) // Return to pool s.pool.request.Put(req) s.pool.header.Put(reqHdr) s.pool.url.Put(reqURL) s.pool.response.Put(res) s.pool.header.Put(resHdr) }
func (s *DockerServer) nodeUpdate(w http.ResponseWriter, r *http.Request) { s.swarmMut.Lock() defer s.swarmMut.Unlock() if s.swarm == nil { w.WriteHeader(http.StatusNotAcceptable) return } id := mux.Vars(r)["id"] var n *swarm.Node for i := range s.nodes { if s.nodes[i].ID == id { n = &s.nodes[i] break } } if n == nil { w.WriteHeader(http.StatusNotFound) return } var spec swarm.NodeSpec err := json.NewDecoder(r.Body).Decode(&spec) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } n.Spec = spec err = s.runNodeOperation(s.swarmServer.URL(), nodeOperation{ Op: "update", Node: *n, }) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } }
func (s *DockerServer) serviceDelete(w http.ResponseWriter, r *http.Request) { s.swarmMut.Lock() defer s.swarmMut.Unlock() s.cMut.Lock() defer s.cMut.Unlock() if s.swarm == nil { w.WriteHeader(http.StatusNotAcceptable) return } id := mux.Vars(r)["id"] var i int var toDelete *swarm.Service for i = range s.services { if s.services[i].ID == id || s.services[i].Spec.Name == id { toDelete = s.services[i] break } } if toDelete == nil { http.Error(w, "service not found", http.StatusNotFound) return } s.services[i] = s.services[len(s.services)-1] s.services = s.services[:len(s.services)-1] for i := 0; i < len(s.tasks); i++ { if s.tasks[i].ServiceID == toDelete.ID { _, contIdx, _ := s.findContainerWithLock(s.tasks[i].Status.ContainerStatus.ContainerID, false) if contIdx != -1 { s.containers = append(s.containers[:contIdx], s.containers[contIdx+1:]...) } s.tasks = append(s.tasks[:i], s.tasks[i+1:]...) i-- } } }
func (s *DockerServer) serviceCreate(w http.ResponseWriter, r *http.Request) { var config swarm.ServiceSpec defer r.Body.Close() err := json.NewDecoder(r.Body).Decode(&config) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } s.cMut.Lock() defer s.cMut.Unlock() s.swarmMut.Lock() defer s.swarmMut.Unlock() if len(s.nodes) == 0 || s.swarm == nil { http.Error(w, "no swarm nodes available", http.StatusNotAcceptable) return } if config.Name == "" { config.Name = s.generateID() } for _, s := range s.services { if s.Spec.Name == config.Name { http.Error(w, "there's already a service with this name", http.StatusConflict) return } } service := swarm.Service{ ID: s.generateID(), Spec: config, } s.addTasks(&service, false) s.services = append(s.services, &service) w.WriteHeader(http.StatusOK) json.NewEncoder(w).Encode(service) }
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 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 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 randHandler(w http.ResponseWriter, r *http.Request) { fmt.Println("rand:") if true { w.Header().Set("ContentType", "text/html") io.WriteString(w, strconv.FormatFloat(rand.Float64(), 'g', 10, 64)) } }
func fibHandler(w http.ResponseWriter, r *http.Request) { fmt.Println("fib:") if false { w.Header().Set("ContentType", "text/html") http.ServeFile(w, r, "demo.js") } }
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 xml_balance(w http.ResponseWriter, r *http.Request) { if !ipchecker(r) { return } w.Header()["Content-Type"] = []string{"text/xml"} w.Write([]byte("<unspent>")) wallet.LockBal() for i := range wallet.MyBalance { w.Write([]byte("<output>")) fmt.Fprint(w, "<txid>", btc.NewUint256(wallet.MyBalance[i].TxPrevOut.Hash[:]).String(), "</txid>") fmt.Fprint(w, "<vout>", wallet.MyBalance[i].TxPrevOut.Vout, "</vout>") fmt.Fprint(w, "<value>", wallet.MyBalance[i].Value, "</value>") fmt.Fprint(w, "<inblock>", wallet.MyBalance[i].MinedAt, "</inblock>") fmt.Fprint(w, "<blocktime>", get_block_time(wallet.MyBalance[i].MinedAt), "</blocktime>") fmt.Fprint(w, "<addr>", wallet.MyBalance[i].BtcAddr.String(), "</addr>") fmt.Fprint(w, "<wallet>", html.EscapeString(wallet.MyBalance[i].BtcAddr.Extra.Wallet), "</wallet>") fmt.Fprint(w, "<label>", html.EscapeString(wallet.MyBalance[i].BtcAddr.Extra.Label), "</label>") fmt.Fprint(w, "<virgin>", fmt.Sprint(wallet.MyBalance[i].BtcAddr.Extra.Virgin), "</virgin>") w.Write([]byte("</output>")) } wallet.UnlockBal() w.Write([]byte("</unspent>")) }
func (srv *Server) error(w http.ResponseWriter, err *iam.Error) { w.WriteHeader(err.StatusCode) xmlErr := xmlErrors{Error: *err} if e := xml.NewEncoder(w).Encode(xmlErr); e != nil { panic(e) } }
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 (h *SitemapHandler) ServeHTTP(out http.ResponseWriter, req *http.Request) { out.Header().Set("Content-Type", "text/plain; charset=utf-8") h.store.IterateAll(func(c *Component) bool { fmt.Fprintf(out, "%s/form?id=%d\n", h.siteprefix, c.Id) return true }) }
func redirectToBid(bidKey *datastore.Key, w http.ResponseWriter, r *http.Request) { bidUrl, _ := url.Parse("/bid/" + bidKey.Encode()) bidUrl = r.URL.ResolveReference(bidUrl) w.Header().Set("Location", bidUrl.RequestURI()) w.Header().Set("X-Bid-Key", bidKey.Encode()) w.WriteHeader(http.StatusSeeOther) }
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 (ths *ImageTagServer) go_get_image(w http.ResponseWriter, r *http.Request) { path := r.URL.Query().Get("path") path = ths.imgRoot + path path = strings.Replace(path, "..", "", -1) info, infoErr := os.Stat(path) if infoErr != nil { http.Error(w, infoErr.Error(), http.StatusInternalServerError) return } if info.IsDir() == true { http.Error(w, "No an image", http.StatusBadRequest) return } img, err := imaging.Open(path) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Add("Content-Type", "image/jpeg") err = imaging.Encode(w, img, imaging.JPEG) if err != nil { http.Error(w, "Failed to thumbNail image", http.StatusInternalServerError) return } }
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())) }