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()))
}