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)
}
}
// 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)
}
}
// 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 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 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
}
// POST /images/load
func postImagesLoad(c *context, w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusCreated)
// call cluster to load image on every node
wf := NewWriteFlusher(w)
var errorMessage string
errorFound := false
callback := func(what, status string, err error) {
if err != nil {
errorFound = true
errorMessage = err.Error()
sendJSONMessage(wf, what, fmt.Sprintf("Loading Image... : %s", err.Error()))
return
}
if status == "" {
sendJSONMessage(wf, what, "Loading Image...")
} else {
sendJSONMessage(wf, what, fmt.Sprintf("Loading Image... : %s", status))
}
}
c.cluster.Load(r.Body, callback)
if errorFound {
sendErrorJSONMessage(wf, 1, errorMessage)
}
}
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)
}
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 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 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 fibHandler(w http.ResponseWriter, r *http.Request) {
fmt.Println("fib:")
if false {
w.Header().Set("ContentType", "text/html")
http.ServeFile(w, r, "demo.js")
}
}
// write renders a returned runtime.Object to the response as a stream or an encoded object. If the object
// returned by the response implements rest.ResourceStreamer that interface will be used to render the
// response. The Accept header and current API version will be passed in, and the output will be copied
// directly to the response body. If content type is returned it is used, otherwise the content type will
// be "application/octet-stream". All other objects are sent to standard JSON serialization.
func write(statusCode int, apiVersion string, codec runtime.Codec, object runtime.Object, w http.ResponseWriter, req *http.Request) {
if stream, ok := object.(rest.ResourceStreamer); ok {
out, flush, contentType, err := stream.InputStream(apiVersion, req.Header.Get("Accept"))
if err != nil {
errorJSONFatal(err, codec, w)
return
}
if out == nil {
// No output provided - return StatusNoContent
w.WriteHeader(http.StatusNoContent)
return
}
defer out.Close()
if len(contentType) == 0 {
contentType = "application/octet-stream"
}
w.Header().Set("Content-Type", contentType)
w.WriteHeader(statusCode)
writer := w.(io.Writer)
if flush {
writer = flushwriter.Wrap(w)
}
io.Copy(writer, out)
return
}
writeJSON(statusCode, codec, object, w, isPrettyPrint(req))
}
/**
* GET A LANGUAGE BY ITS ID
*/
func goGetLanguageById(w http.ResponseWriter, r *http.Request) {
//parse array of input from request message
vars := mux.Vars(r)
//get id input
var langId string
langId = vars["languageId"]
//execute get method
lang := getLanguageById(langId)
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
if lang.Id != "" {
w.WriteHeader(http.StatusOK)
if err := json.NewEncoder(w).Encode(lang); err != nil {
panic(err)
}
return
}
// If we didn't find it, 404
w.WriteHeader(http.StatusNotFound)
if err := json.NewEncoder(w).Encode(jsonErr{Code: http.StatusNotFound, Text: "Not Found"}); err != nil {
panic(err)
}
}
func readKey(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
// Simply write some test data for now
fmt.Println("reading values")
id := p.ByName("id")
i, _ := strconv.Atoi(id)
u := Data{}
if val, ok := Resp[i]; ok {
fmt.Println(i, val)
u.Key = i
u.Value = val
}
// Marshal provided interface into JSON structure
fmt.Println("before marshalling map :", u)
uj, _ := json.Marshal(u)
fmt.Println("after marshalling map :", u)
// Write content-type, statuscode, payload
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
fmt.Fprintf(w, "%s", uj)
}
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 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 AddStudent(w http.ResponseWriter, r *http.Request) {
var student Student
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
panic(err)
}
if err := r.Body.Close(); err != nil {
panic(err)
}
if err := json.Unmarshal(body, &student); err != nil {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(422) // unprocessable entity
if err := json.NewEncoder(w).Encode(err); err != nil {
panic(err)
}
}
// add to db
//t := RepoCreateTodo(student)
//w.Header().Set("Content-Type", "application/json; charset=UTF-8")
//w.WriteHeader(http.StatusCreated)
//if err := json.NewEncoder(w).Encode(t); err != nil {
// panic(err)
//}
}
// GET /events
func getEvents(c *context, w http.ResponseWriter, r *http.Request) {
if err := r.ParseForm(); err != nil {
httpError(w, err.Error(), 400)
return
}
var until int64 = -1
if r.Form.Get("until") != "" {
u, err := strconv.ParseInt(r.Form.Get("until"), 10, 64)
if err != nil {
httpError(w, err.Error(), 400)
return
}
until = u
}
c.eventsHandler.Add(r.RemoteAddr, w)
w.Header().Set("Content-Type", "application/json")
if f, ok := w.(http.Flusher); ok {
f.Flush()
}
c.eventsHandler.Wait(r.RemoteAddr, until)
}
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 TodoShow(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
var todoId int
var err error
if todoId, err = strconv.Atoi(vars["todoId"]); err != nil {
panic(err)
}
todo := RepoFindTodo(todoId)
if todo.Id > 0 {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusOK)
if err := json.NewEncoder(w).Encode(todo); err != nil {
panic(err)
}
return
}
// If we didn't find it, 404
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusNotFound)
if err := json.NewEncoder(w).Encode(jsonErr{Code: http.StatusNotFound, Text: "Not Found"}); err != nil {
panic(err)
}
}
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 (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 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 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 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
}
// 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 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 (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 (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
}
}
// GET /info
func getInfo(c *context, w http.ResponseWriter, r *http.Request) {
info := dockerclient.Info{
Containers: int64(len(c.cluster.Containers())),
Images: int64(len(c.cluster.Images().Filter(cluster.ImageFilterOptions{}))),
DriverStatus: c.statusHandler.Status(),
NEventsListener: int64(c.eventsHandler.Size()),
Debug: c.debug,
MemoryLimit: true,
SwapLimit: true,
IPv4Forwarding: true,
BridgeNfIptables: true,
BridgeNfIp6tables: true,
NCPU: c.cluster.TotalCpus(),
MemTotal: c.cluster.TotalMemory(),
HttpProxy: os.Getenv("http_proxy"),
HttpsProxy: os.Getenv("https_proxy"),
NoProxy: os.Getenv("no_proxy"),
SystemTime: time.Now().Format(time.RFC3339Nano),
}
if hostname, err := os.Hostname(); err == nil {
info.Name = hostname
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(info)
}