func Get(w http.ResponseWriter, r *http.Request) { w.SetHeader("Content-Type", "application/json") lock.Lock() e := json.NewEncoder(w) e.Encode(server) lock.Unlock() }
func (p *JSONMediaTypeHandler) OutputTo(req wm.Request, cxt wm.Context, writer io.Writer, resp wm.ResponseWriter) { buf := bytes.NewBufferString("") obj := jsonhelper.NewJSONObject() enc := json.NewEncoder(buf) obj.Set("status", "success") obj.Set("result", p.obj) err := enc.Encode(obj) if err != nil { //resp.Header().Set("Content-Type", wm.MIME_TYPE_JSON) if !p.writtenStatusHeader { resp.WriteHeader(500) p.writtenStatusHeader = true } m := jsonhelper.NewJSONObject() w := json.NewEncoder(writer) m.Set("status", "error") m.Set("message", err.String()) m.Set("result", nil) w.Encode(m) return } //resp.Header().Set("Content-Type", wm.MIME_TYPE_JSON) resp.Header().Set("Content-Length", strconv.Itoa(buf.Len())) if p.lastModified != nil { resp.Header().Set("Last-Modified", p.lastModified.Format(http.TimeFormat)) } if len(p.etag) > 0 { resp.Header().Set("ETag", strconv.Quote(p.etag)) } handler := wm.NewPassThroughMediaTypeHandler(wm.MIME_TYPE_JSON, ioutil.NopCloser(bytes.NewBuffer(buf.Bytes())), int64(buf.Len()), p.lastModified) handler.OutputTo(req, cxt, writer, resp) }
func (p *JsonDirectoryListing) OutputTo(req Request, cxt Context, writer io.Writer, resp ResponseWriter) { result := new(jsonDirectoryEntryResult) result.Path = p.urlPath var err os.Error defer func() { if p.file != nil { p.file.Close() p.file = nil } }() if p.file == nil { p.file, err = os.Open(p.fullPath) if err != nil { result.Status = "error" result.Message = err.String() result.Result = make([]jsonDirectoryEntry, 0) encoder := json.NewEncoder(writer) encoder.Encode(result) return } } fileInfos, err := p.file.Readdir(-1) if err != nil { result.Status = "error" result.Message = err.String() result.Result = make([]jsonDirectoryEntry, 0) encoder := json.NewEncoder(writer) encoder.Encode(result) return } entries := make([]jsonDirectoryEntry, len(fileInfos)) for i, fileInfo := range fileInfos { entries[i].Filename = fileInfo.Name entries[i].Path = path.Join(p.urlPath, fileInfo.Name) entries[i].Size = fileInfo.Size entries[i].IsDirectory = fileInfo.IsDirectory() if fileInfo.IsDirectory() { entries[i].IsDirectory = true entries[i].Size = 0 } else { entries[i].IsDirectory = false entries[i].Size = fileInfo.Size } entries[i].LastModified = time.SecondsToUTC(int64(fileInfo.Mtime_ns / 1e9)).Format(time.RFC3339) } result.Status = "success" result.Message = "" result.Result = entries encoder := json.NewEncoder(writer) encoder.Encode(result) }
func (p *InMemoryDataStore) Encode(w io.Writer) os.Error { v, err := jsonhelper.MarshalWithOptions(p, dm.UTC_DATETIME_FORMAT) if err != nil { return err } return json.NewEncoder(w).Encode(v) }
func output(_object interface{}, _configuration *configuration) os.Error { if _configuration.outputPretty { _json, _error := json.MarshalIndent(_object, "", " ") if _error != nil { return _error } _, _error = _configuration.output.Write(_json) if _error != nil { return _error } _, _error = _configuration.output.Write([]byte("\n")) if _error != nil { return _error } } else { _encoder := json.NewEncoder(_configuration.output) _error := _encoder.Encode(_object) if _error != nil { return _error } } return nil }
func postPosition(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) gid, _ := strconv.Atoi(r.FormValue("gid")) pid, _ := strconv.Atoi(r.FormValue("pid")) lat, _ := strconv.Atoi(r.FormValue("lat")) lng, _ := strconv.Atoi(r.FormValue("lng")) now := datastore.SecondsToTime(time.Seconds()) go savePlayer(c, &Player{pid, gid, lat, lng, now}) q := datastore.NewQuery("Player"). Filter("GameId =", gid) players := make([]Player, 0, 10) for t := q.Run(c); ; { var p Player _, err := t.Next(&p) if err == datastore.Done { break } if err != nil { serveError(c, w, err) return } if p.PlayerId != pid { players = append(players, p) } } m := map[string]interface{}{"players": players, "dead": false} enc := json.NewEncoder(w) enc.Encode(m) }
func main() { flag.Parse() ZellijTilings, reset = zellij.TileSkeleton(skeleton, tileSymmetry, false) Frame := zellij.SkeletonFrame(skeleton) symmetryCounts := make(map[string]int) for T := range ZellijTilings { symmetryGroup := zellij.DetectSymmetryGroup(T) filename := fmt.Sprintf("%v-%v-%d", skeleton, symmetryGroup, symmetryCounts[symmetryGroup]+1) symmetryCounts[symmetryGroup]++ save, err := os.Create(path.Join(dir, filename+".zellij")) if err != nil { panic("file error") } enc := json.NewEncoder(save) enc.Encode([]*quadratic.Map{Frame, T}) save.Close() image := cairo.NewSurface(path.Join(dir, "svg", filename+".svg"), 72*5, 72*5) image.SetSourceRGB(0., 0., 0.) image.SetLineWidth(.1) image.Translate(72*2.5, 72*2.5) image.Scale(4., 4.) T.ColourFaces(image, zellij.PlainBrush) image.Finish() } }
func ShortenURL(longUrl string) (shortenUrl string, err os.Error) { var encbuf bytes.Buffer enc := json.NewEncoder(&encbuf) err = enc.Encode(map[string]string{"longUrl": longUrl}) if err != nil { return } res, err := http.Post("https://www.googleapis.com/urlshortener/v1/url", "application/json", strings.NewReader(encbuf.String())) if err != nil { return } if res.StatusCode != 200 { err = os.NewError("failed to post") return } b, err := ioutil.ReadAll(res.Body) if err != nil { return } var decbuf bytes.Buffer decbuf.Write(b) dec := json.NewDecoder(&decbuf) var out map[string]interface{} err = dec.Decode(&out) if err != nil { return } shortenUrl = out["id"].(string) return }
func main() { var ( err os.Error clientId string clientSecret string ) if clientId, clientSecret, err = getClientInfo(); err != nil { panic(err) } transport := google.MakeOauthTransport(clientId, clientSecret, "") var accessCode string if accessCode, err = getAccessCode(transport.Config); err != nil { panic(err) } if _, err = transport.Exchange(accessCode); err != nil { panic(err) } fmt.Printf("\nYour Google Storage auth object:\n\n") enc := json.NewEncoder(os.Stdout) authObj := map[string]string{ "client_id": transport.ClientId, "client_secret": transport.ClientSecret, "refresh_token": transport.RefreshToken, } enc.Encode(authObj) fmt.Print("\n") }
/* Check the uniqueness of a Uid. * * FIXME: RESTify this! */ func CheckUidHandler(w http.ResponseWriter, r *http.Request) { log.Println("CheckUidHandler got request with method: " + r.Method) if r.Method == "POST" { context := appengine.NewContext(r) isUnique := controller.IsUidUnique(context, r.FormValue("uid")) encoder := json.NewEncoder(w) type UidResponse struct { Uid string Available string } response := new(UidResponse) response.Uid = r.FormValue("uid") log.Println("Result from IsUidUnique is: " + strconv.Btoa(isUnique) + " : " + reflect.TypeOf(isUnique).String()) if isUnique { log.Println("Username " + response.Uid + " is available") response.Available = "available" } else { log.Println("Username " + response.Uid + " is not available") response.Available = "not available" } log_, _ := json.Marshal(&response) log.Println("Sending to JQuery: " + string(log_)) if err := encoder.Encode(&response); err != nil { log.Println("Cannot send JSON to AJAX code: " + err.String()) } } return }
func (p *JSONMediaTypeInputHandler) OutputTo(req wm.Request, cxt wm.Context, writer io.Writer) (int, http.Header, os.Error) { defer func() { if p.reader != nil { if closer, ok := p.reader.(io.Closer); ok { closer.Close() } } }() //log.Printf("[JSONMTIH]: Calling OutputTo with reader %v\n", p.reader) if p.reader == nil { return p.handler.HandleJSONObjectInputHandler(req, cxt, writer, nil) } obj := jsonhelper.NewJSONObject() dec := json.NewDecoder(p.reader) err := dec.Decode(&obj) if err != nil { headers := make(http.Header) //headers.Set("Content-Type", wm.MIME_TYPE_JSON) m := jsonhelper.NewJSONObject() w := json.NewEncoder(writer) m.Set("status", "error") m.Set("message", err.String()) m.Set("result", nil) w.Encode(m) return 500, headers, err } return p.handler.HandleJSONObjectInputHandler(req, cxt, writer, obj) }
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { s.mu.Lock() defer s.mu.Unlock() w.SetHeader("Content-Type", "application/json") e := json.NewEncoder(w) e.Encode(s.series) }
// NewClientCodec returns a new rpc.ClientCodec using JSON-RPC on conn. func NewClientCodec(conn io.ReadWriteCloser) rpc.ClientCodec { return &clientCodec{ dec: json.NewDecoder(conn), enc: json.NewEncoder(conn), c: conn, pending: make(map[uint64]string), } }
// NewServerCodec returns a new rpc.ServerCodec using JSON-RPC on conn. func NewServerCodec(conn io.ReadWriteCloser) rpc.ServerCodec { return &serverCodec{ dec: json.NewDecoder(conn), enc: json.NewEncoder(conn), c: conn, pending: make(map[uint64]*json.RawMessage), } }
// serialize encodes a value using json. func serialize(src interface{}) ([]byte, error) { buf := new(bytes.Buffer) enc := json.NewEncoder(buf) if err := enc.Encode(src); err != nil { return nil, err } return buf.Bytes(), nil }
// Open a capture session, attempt to parse any requests to port 80 and // serialise to stdout as JSON. func main() { out = bufio.NewWriter(os.Stdout) errout = bufio.NewWriter(os.Stderr) c := OpenCaptureOrDie() enc := json.NewEncoder(os.Stdout) for pkt := c.Next(); pkt != nil; pkt = c.Next() { pkt.Decode() SerialisePacket(pkt, enc) } }
func EncodeToFile(filename string, object interface{}) (e os.Error) { file, e := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE, 0755) if e != nil { fmt.Printf("Failed to open %s, %s.\n", filename, e) return } enc := json.NewEncoder(file) e = enc.Encode(object) if e != nil { fmt.Printf("Failed to encode JSON object: %s. (Object represented as %#v).\n", e, object) return } return }
func (wrap MarshalStyle) JSONReader(v interface{}) (io.Reader, os.Error) { buf := new(bytes.Buffer) if wrap { buf.Write([]byte(`{"data": `)) } err := json.NewEncoder(buf).Encode(v) if err != nil { return nil, err } if wrap { buf.Write([]byte(`}`)) } return buf, nil }
// GET /<domain> func (this RestJsonMongo) Index(rw http.ResponseWriter, values url.Values, header http.Header) { logger.Debug("Index():%v,%v", values, header) items, err := this.Store.Find(values) if err != nil { http.Error(rw, err.String(), http.StatusBadRequest) return } handle := ItemsHandle{Items: items, NumberOfItems: len(items)} if err := json.NewEncoder(rw).Encode(handle); err != nil { logger.Warn(err) http.Error(rw, err.String(), http.StatusBadRequest) } }
func Shorten(w http.ResponseWriter, r *http.Request) { var key string for key = genKey(); store.Check(&key) == false; { } long_url := r.FormValue("url") store.Put(&key, &long_url) v := make(map[string]string) v["url"] = "http://" + *hostName + "/" + key enc := json.NewEncoder(w) enc.Encode(&v) }
// Signs the Content func signHandler(w http.ResponseWriter, r *http.Request) { dec := json.NewDecoder(r.Body) var data Signature dec.Decode(&data) keyBytes := []byte(data.Key) content := data.Content mac := hmac.NewSHA1(keyBytes) mac.Write([]byte(content)) out := make([]byte, base64.StdEncoding.EncodedLen(len(mac.Sum()))) base64.StdEncoding.Encode(out, mac.Sum()) w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(&Signature{string(out), content, data.Key}) }
func OutputErrorMessage(writer io.Writer, message string, result interface{}, statusCode int, headers http.Header) (int, http.Header, os.Error) { if statusCode == 0 { statusCode = 500 } if headers == nil { headers = make(http.Header) } //headers.Set("Content-Type", wm.MIME_TYPE_JSON) m := jsonhelper.NewJSONObject() w := json.NewEncoder(writer) m.Set("status", "error") m.Set("message", message) m.Set("result", result) w.Encode(m) return statusCode, headers, nil }
func Compile(w http.ResponseWriter, req *http.Request) { resp := new(Response) out, err := compile(req) if err != nil { if out != nil { resp.Errors = string(out) } else { resp.Errors = err.String() } } else { resp.Output = string(out) } if err := json.NewEncoder(w).Encode(resp); err != nil { log.Println(err) } }
// GET /<domain>/id func (this RestJsonMongo) Find(rw http.ResponseWriter, id string) { logger.Debug("Find(%v)", id) storedItem, err := this.Store.Get(id) if storedItem == nil { http.Error(rw, fmt.Sprintf("item %v not found", id), http.StatusNotFound) return } if err != nil { http.Error(rw, err.String(), http.StatusBadRequest) return } if err := json.NewEncoder(rw).Encode(storedItem); err != nil { http.Error(rw, err.String(), http.StatusBadRequest) } }
func New(_store Store, _hasher hasher.Hasher) (_tree *Tree) { _tree = new(Tree) _tree.store = _store _tree.hasher = _hasher _tree.gobBuffer = bytes.NewBuffer(make([]byte, 0, 1024*1024)) _tree.gobEncoder = gob.NewEncoder(_tree.gobBuffer) _tree.gobCache = gobCache{_tree.gobBuffer, _tree.gobEncoder, nil} _tree.jsonBuffer = bytes.NewBuffer(make([]byte, 0, 1024*1024)) _tree.jsonEncoder = json.NewEncoder(_tree.jsonBuffer) _tree.jsonCache = jsonCache{_tree.jsonBuffer, _tree.jsonEncoder, nil} _root := &_tree.root _root.tree = _tree _root.path = make([]string, 0) _root.gobCache = gobCache{_tree.gobBuffer, _tree.gobEncoder, nil} _root.jsonCache = jsonCache{_tree.jsonBuffer, _tree.jsonEncoder, nil} _root.setDirty() return _tree }
func getContext() *Context { mutex.Lock() ctx := free if ctx == nil { mutex.Unlock() ctx = &Context{} ctx.buf = &bytes.Buffer{} ctx.enc = json.NewEncoder(ctx.buf) ctx.req = &request{} } else { free = ctx.next mutex.Unlock() ctx.buf.Reset() *ctx.req = request{} } *ctx.req = request{} return ctx }
func main() { flag.Parse() q, err := GetQueue() if err != nil { log.Fatalf("Couldn't create queue: %v\n", err) } id, err := GetAWSIdentity() if err != nil { log.Fatalf("Couldn't get identity: %v\n", err) } msgs, err := q.FetchMessages(id, *max, *timeout) if err != nil { log.Fatalf("Couldn't pop from queue: %v\n", err) } log.Printf("#[%d messages received]", len(msgs)) _form := *outform for mi := range msgs { err = q.DeleteMessage(id, msgs[mi]) if err != nil { log.Printf("Couldn't delete message, not displaying (%v)", err) continue } switch _form { case "text": fmt.Printf("MessageID\t%s\n", msgs[mi].MessageId.String()) fmt.Printf("ReceiptHandle\t%s\n", msgs[mi].ReceiptHandle) fmt.Printf("MessageBody\t%s\n", string(msgs[mi].Body)) case "shell": // TODO: Escape these properly. fmt.Printf("export SQSMessage%dId=\"%s\";\n", mi, msgs[mi].MessageId.String()) fmt.Printf("export SQSMessage%dReceipt=\"%s\";\n", mi, msgs[mi].ReceiptHandle) fmt.Printf("export SQSMessage%dBody=\"%s\";\n", mi, http.URLEscape(string(msgs[mi].Body))) case "raw": os.Stdout.Write(msgs[mi].Body) } } if _form == "json" { enc := json.NewEncoder(os.Stdout) err := enc.Encode(msgs) if err != nil { log.Fatalf("Error decoding messages: %v", err) } } }
func main() { dec := json.NewDecoder(os.Stdin) enc := json.NewEncoder(os.Stdout) for { var v map[string]interface{} if err := dec.Decode(&v); err != nil { log.Println(err) return } for k := range v { if k != "Name" { v[k] = nil, false } } if err := enc.Encode(&v); err != nil { log.Println(err) } } }
// escapeForJSON will turn a []byte into properly escaped JSON substring. func escapeForJSON(args ...interface{}) (string, os.Error) { // Ensure there is only one argument given if len(args) != 1 { return "", fmt.Errorf("escapeForJSON: Wrong number of arguments") } // Converts the given []byte into a JSON encoded string (that's contained in e) buf := bytes.NewBuffer(nil) e := json.NewEncoder(buf) e.Encode(args) // Cast to string, and removing preceeding opening "[" s := strings.TrimLeft(string(buf.Bytes()), "[") // Trim down 2 (???) characters to remove trailing closing "] s = s[:len(s)-2] // Return the string, with no errors return s, nil }
func serveDirectory(fn string, w http.ResponseWriter, r *http.Request) { defer func() { if err, ok := recover().(os.Error); ok { http.Error(w, err.String(), http.StatusInternalServerError) } }() d, err := os.Open(fn) if err != nil { panic(err) } files, err := d.Readdir(-1) if err != nil { panic(err) } j := json.NewEncoder(w) if err := j.Encode(files); err != nil { panic(err) } }