func (*JSONPBResponseProcessor) Process(w http.ResponseWriter, model interface{}) error {
msg := model.(proto.Message)
w.Header().Set("Content-Type", "application/json")
marshaler := jsonpb.Marshaler{}
w.WriteHeader(http.StatusOK)
marshaler.Marshal(w, msg)
return nil
}
func handleCollection(collection string, getFunc func(*http.Request) (interface{}, error)) {
handleAPI(collection+"/", func(w http.ResponseWriter, r *http.Request) error {
// Get the requested object.
obj, err := getFunc(r)
if err != nil {
if err == topo.ErrNoNode {
http.NotFound(w, r)
return nil
}
return fmt.Errorf("can't get %v: %v", collection, err)
}
// JSON marshals a nil slice as "null", but we prefer "[]".
if val := reflect.ValueOf(obj); val.Kind() == reflect.Slice && val.IsNil() {
w.Header().Set("Content-Type", jsonContentType)
w.Write([]byte("[]"))
return nil
}
// JSON encode response.
var data []byte
switch obj := obj.(type) {
case proto.Message:
// We use jsonpb for protobuf messages because it is the only supported
// way to marshal protobuf messages to JSON.
// In addition to that, it's the only way to emit zero values in the JSON
// output.
// Unfortunately, it works only for protobuf messages. Therefore, we use
// the default marshaler for the remaining structs (which are possibly
// mixed protobuf and non-protobuf).
// TODO(mberlin): Switch "EnumAsInts" to "false" once the frontend is
// updated and mixed types will use jsonpb as well.
// Note: jsonpb may panic if the "proto.Message" is an embedded field
// of "obj" and "obj" has non-exported fields.
// Marshal the protobuf message.
var b bytes.Buffer
m := jsonpb.Marshaler{EnumsAsInts: true, EmitDefaults: true, Indent: " ", OrigName: true}
if err := m.Marshal(&b, obj); err != nil {
return fmt.Errorf("jsonpb error: %v", err)
}
data = b.Bytes()
default:
data, err = json.MarshalIndent(obj, "", " ")
if err != nil {
return fmt.Errorf("json error: %v", err)
}
}
w.Header().Set("Content-Type", jsonContentType)
w.Write(data)
return nil
})
}
func ProtoToMap(pb proto.Message, idFix bool) map[string]interface{} {
marshaler := proto_json.Marshaler{}
s, _ := marshaler.MarshalToString(pb)
out := make(map[string]interface{})
json.Unmarshal([]byte(s), &out)
if idFix {
if _, ok := out["id"]; ok {
out["_id"] = out["id"]
delete(out, "id")
}
}
return out
}
func testEchoBody(t *testing.T) {
sent := gw.SimpleMessage{Id: "example"}
var m jsonpb.Marshaler
payload, err := m.MarshalToString(&sent)
if err != nil {
t.Fatalf("m.MarshalToString(%#v) failed with %v; want success", payload, err)
}
url := "http://localhost:8080/v1/example/echo_body"
resp, err := http.Post(url, "", strings.NewReader(payload))
if err != nil {
t.Errorf("http.Post(%q) failed with %v; want success", url, err)
return
}
defer resp.Body.Close()
buf, err := ioutil.ReadAll(resp.Body)
if err != nil {
t.Errorf("iotuil.ReadAll(resp.Body) failed with %v; want success", err)
return
}
if got, want := resp.StatusCode, http.StatusOK; got != want {
t.Errorf("resp.StatusCode = %d; want %d", got, want)
t.Logf("%s", buf)
}
var received gw.SimpleMessage
if err := jsonpb.UnmarshalString(string(buf), &received); err != nil {
t.Errorf("jsonpb.UnmarshalString(%s, &msg) failed with %v; want success", buf, err)
return
}
if got, want := received, sent; !reflect.DeepEqual(got, want) {
t.Errorf("msg.Id = %q; want %q", got, want)
}
if got, want := resp.Header.Get("Grpc-Metadata-Foo"), "foo1"; got != want {
t.Errorf("Grpc-Header-Foo was %q, wanted %q", got, want)
}
if got, want := resp.Header.Get("Grpc-Metadata-Bar"), "bar1"; got != want {
t.Errorf("Grpc-Header-Bar was %q, wanted %q", got, want)
}
if got, want := resp.Trailer.Get("Grpc-Trailer-Foo"), "foo2"; got != want {
t.Errorf("Grpc-Trailer-Foo was %q, wanted %q", got, want)
}
if got, want := resp.Trailer.Get("Grpc-Trailer-Bar"), "bar2"; got != want {
t.Errorf("Grpc-Trailer-Bar was %q, wanted %q", got, want)
}
}
func discoveryGet(clictx *cli.Context) error {
var err error
var opts []grpc.DialOption
if insecureDiscovery {
opts = append(opts, grpc.WithInsecure())
} else {
auth := credentials.NewClientTLSFromCert(nil, getServerName(discoveryServiceURL))
opts = append(opts, grpc.WithTransportCredentials(auth))
}
logrus.Infof("discovery.go: connecting to discovery service at url %s", discoveryServiceURL)
dcon, err := grpc.Dial(discoveryServiceURL, opts...)
if err != nil {
logrus.Fatalf("discovery.go: error while connection to discovery service %v", err)
}
dc := pb.NewDiscoveryClient(dcon)
ctx, _ := context.WithTimeout(context.Background(), 5*time.Second)
req := pb.DiscoveryRequest{}
if filename := clictx.String("filename"); filename != "" {
d, err := os.Open(filename)
if err != nil {
return err
}
defer d.Close()
if err := jsonpb.Unmarshal(d, &req); err != nil {
return err
}
} else {
req.Environment = clictx.String("env")
req.SdkVersion = clictx.String("sdk")
req.OsName = clictx.String("os")
req.CountryCode = clictx.String("country-code")
req.AppBundleId = clictx.String("bundle-id")
req.AppBundleVersion = clictx.String("bundle-version")
}
res, err := dc.Get(ctx, &req)
if err != nil {
return err
}
m := jsonpb.Marshaler{EnumsAsInts: false, EmitDefaults: true, Indent: " "}
s, err := m.MarshalToString(res)
fmt.Println(s)
return nil
}
func SearchCredHandler(w http.ResponseWriter, r *http.Request) {
// TODO: Set timeout header for after search result comes back
broadcastSearch := r.URL.Query()["broadcast"] != nil
queryKeys := r.URL.Query()["key"]
if len(queryKeys) == 0 {
w.WriteHeader(http.StatusBadRequest)
return
}
searchRequest := &credence.SearchRequest{
Keys: queryKeys,
Timestamp: time.Now().Unix(),
}
if broadcastSearch {
BroadcastSearch(searchRequest)
}
searchResult := &credence.SearchResult{}
// TODO: Do DB query for all keys at once
for _, key := range searchRequest.Keys {
for _, keyBreakdown := range models.SearchCredsBreakdown(key) {
searchResult.Results = append(searchResult.Results, keyBreakdown)
}
}
helpers.DeduplicateKeys(searchResult)
// Output
marshaler := jsonpb.Marshaler{}
json, _ := marshaler.MarshalToString(searchResult)
w.Header().Set("Content-Type", "application/json")
w.Header().Set("Access-Control-Allow-Origin", "*")
w.WriteHeader(http.StatusOK)
io.WriteString(w, json)
}
// Returns a valid json collection in bytes and the related jobs
func GetTestJSONCollectionBody(userId uint32, numberOfPayloads int) (*TrackBodyCollection, []*EventAction) {
collection, wrongCollection, incompleteCollection := GetTestCollectionPairs(userId, numberOfPayloads)
var collectionBytestream bytes.Buffer
var disturbedCollectionBytestream bytes.Buffer
var incompleteCollectionByteStream bytes.Buffer
m := jsonpb.Marshaler{false, false, "", true}
m.Marshal(&collectionBytestream, collection)
m.Marshal(&disturbedCollectionBytestream, wrongCollection)
m.Marshal(&incompleteCollectionByteStream, incompleteCollection)
t := &TrackBodyCollection{
collectionBytestream.Bytes(),
disturbedCollectionBytestream.Bytes(),
incompleteCollectionByteStream.Bytes()}
return t, GetJobsFromCollection(collection)
}
func testABEBulkEcho(t *testing.T) {
reqr, reqw := io.Pipe()
var wg sync.WaitGroup
var want []*sub.StringMessage
wg.Add(1)
go func() {
defer wg.Done()
defer reqw.Close()
var m jsonpb.Marshaler
for i := 0; i < 1000; i++ {
msg := sub.StringMessage{Value: proto.String(fmt.Sprintf("message %d", i))}
buf, err := m.MarshalToString(&msg)
if err != nil {
t.Errorf("m.Marshal(%v) failed with %v; want success", &msg, err)
return
}
if _, err := fmt.Fprintln(reqw, buf); err != nil {
t.Errorf("fmt.Fprintln(reqw, %q) failed with %v; want success", buf, err)
return
}
want = append(want, &msg)
}
}()
url := "http://localhost:8080/v1/example/a_bit_of_everything/echo"
req, err := http.NewRequest("POST", url, reqr)
if err != nil {
t.Errorf("http.NewRequest(%q, %q, reqr) failed with %v; want success", "POST", url, err)
return
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Transfer-Encoding", "chunked")
resp, err := http.DefaultClient.Do(req)
if err != nil {
t.Errorf("http.Post(%q, %q, req) failed with %v; want success", url, "application/json", err)
return
}
defer resp.Body.Close()
if got, want := resp.StatusCode, http.StatusOK; got != want {
t.Errorf("resp.StatusCode = %d; want %d", got, want)
}
var got []*sub.StringMessage
wg.Add(1)
go func() {
defer wg.Done()
dec := json.NewDecoder(resp.Body)
for i := 0; ; i++ {
var item struct {
Result json.RawMessage `json:"result"`
Error map[string]interface{} `json:"error"`
}
err := dec.Decode(&item)
if err == io.EOF {
break
}
if err != nil {
t.Errorf("dec.Decode(&item) failed with %v; want success; i = %d", err, i)
}
if len(item.Error) != 0 {
t.Errorf("item.Error = %#v; want empty; i = %d", item.Error, i)
continue
}
var msg sub.StringMessage
if err := jsonpb.UnmarshalString(string(item.Result), &msg); err != nil {
t.Errorf("jsonpb.UnmarshalString(%q, &msg) failed with %v; want success", item.Result, err)
}
got = append(got, &msg)
}
}()
wg.Wait()
if !reflect.DeepEqual(got, want) {
t.Errorf("got = %v; want %v", got, want)
}
}
func testABEBulkCreate(t *testing.T) {
count := 0
r, w := io.Pipe()
go func(w io.WriteCloser) {
defer func() {
if cerr := w.Close(); cerr != nil {
t.Errorf("w.Close() failed with %v; want success", cerr)
}
}()
for _, val := range []string{
"foo", "bar", "baz", "qux", "quux",
} {
want := gw.ABitOfEverything{
FloatValue: 1.5,
DoubleValue: 2.5,
Int64Value: 4294967296,
Uint64Value: 9223372036854775807,
Int32Value: -2147483648,
Fixed64Value: 9223372036854775807,
Fixed32Value: 4294967295,
BoolValue: true,
StringValue: fmt.Sprintf("strprefix/%s", val),
Uint32Value: 4294967295,
Sfixed32Value: 2147483647,
Sfixed64Value: -4611686018427387904,
Sint32Value: 2147483647,
Sint64Value: 4611686018427387903,
NonConventionalNameValue: "camelCase",
Nested: []*gw.ABitOfEverything_Nested{
{
Name: "hoge",
Amount: 10,
},
{
Name: "fuga",
Amount: 20,
},
},
}
var m jsonpb.Marshaler
if err := m.Marshal(w, &want); err != nil {
t.Fatalf("m.Marshal(%#v, w) failed with %v; want success", want, err)
}
if _, err := io.WriteString(w, "\n"); err != nil {
t.Errorf("w.Write(%q) failed with %v; want success", "\n", err)
return
}
count++
}
}(w)
url := "http://localhost:8080/v1/example/a_bit_of_everything/bulk"
resp, err := http.Post(url, "application/json", r)
if err != nil {
t.Errorf("http.Post(%q) failed with %v; want success", url, err)
return
}
defer resp.Body.Close()
buf, err := ioutil.ReadAll(resp.Body)
if err != nil {
t.Errorf("iotuil.ReadAll(resp.Body) failed with %v; want success", err)
return
}
if got, want := resp.StatusCode, http.StatusOK; got != want {
t.Errorf("resp.StatusCode = %d; want %d", got, want)
t.Logf("%s", buf)
}
var msg empty.Empty
if err := jsonpb.UnmarshalString(string(buf), &msg); err != nil {
t.Errorf("jsonpb.UnmarshalString(%s, &msg) failed with %v; want success", buf, err)
return
}
if got, want := resp.Header.Get("Grpc-Metadata-Count"), fmt.Sprintf("%d", count); got != want {
t.Errorf("Grpc-Header-Count was %q, wanted %q", got, want)
}
if got, want := resp.Trailer.Get("Grpc-Trailer-Foo"), "foo2"; got != want {
t.Errorf("Grpc-Trailer-Foo was %q, wanted %q", got, want)
}
if got, want := resp.Trailer.Get("Grpc-Trailer-Bar"), "bar2"; got != want {
t.Errorf("Grpc-Trailer-Bar was %q, wanted %q", got, want)
}
}
func testABECreateBody(t *testing.T) {
want := gw.ABitOfEverything{
FloatValue: 1.5,
DoubleValue: 2.5,
Int64Value: 4294967296,
Uint64Value: 9223372036854775807,
Int32Value: -2147483648,
Fixed64Value: 9223372036854775807,
Fixed32Value: 4294967295,
BoolValue: true,
StringValue: "strprefix/foo",
Uint32Value: 4294967295,
Sfixed32Value: 2147483647,
Sfixed64Value: -4611686018427387904,
Sint32Value: 2147483647,
Sint64Value: 4611686018427387903,
NonConventionalNameValue: "camelCase",
Nested: []*gw.ABitOfEverything_Nested{
{
Name: "bar",
Amount: 10,
},
{
Name: "baz",
Amount: 20,
},
},
RepeatedStringValue: []string{"a", "b", "c"},
OneofValue: &gw.ABitOfEverything_OneofString{
OneofString: "x",
},
MapValue: map[string]gw.NumericEnum{
"a": gw.NumericEnum_ONE,
"b": gw.NumericEnum_ZERO,
},
MappedStringValue: map[string]string{
"a": "x",
"b": "y",
},
MappedNestedValue: map[string]*gw.ABitOfEverything_Nested{
"a": {Name: "x", Amount: 1},
"b": {Name: "y", Amount: 2},
},
}
url := "http://localhost:8080/v1/example/a_bit_of_everything"
var m jsonpb.Marshaler
payload, err := m.MarshalToString(&want)
if err != nil {
t.Fatalf("m.MarshalToString(%#v) failed with %v; want success", want, err)
}
resp, err := http.Post(url, "application/json", strings.NewReader(payload))
if err != nil {
t.Errorf("http.Post(%q) failed with %v; want success", url, err)
return
}
defer resp.Body.Close()
buf, err := ioutil.ReadAll(resp.Body)
if err != nil {
t.Errorf("iotuil.ReadAll(resp.Body) failed with %v; want success", err)
return
}
if got, want := resp.StatusCode, http.StatusOK; got != want {
t.Errorf("resp.StatusCode = %d; want %d", got, want)
t.Logf("%s", buf)
}
var msg gw.ABitOfEverything
if err := jsonpb.UnmarshalString(string(buf), &msg); err != nil {
t.Errorf("jsonpb.UnmarshalString(%s, &msg) failed with %v; want success", buf, err)
return
}
if msg.Uuid == "" {
t.Error("msg.Uuid is empty; want not empty")
}
msg.Uuid = ""
if got := msg; !reflect.DeepEqual(got, want) {
t.Errorf("msg= %v; want %v", &got, &want)
}
}
func (i *restAPIHandler) POSTListing(w http.ResponseWriter, r *http.Request) {
w.Header().Add("Content-Type", "application/json")
l := new(pb.Listing)
jsonpb.Unmarshal(r.Body, l)
listingPath := path.Join(i.node.RepoPath, "root", "listings", l.ListingName)
if err := os.MkdirAll(listingPath, os.ModePerm); err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, `{"success": false, "reason": "%s"}`, err)
return
}
contract, err := i.node.SignListing(l)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, `{"success": false, "reason": "%s"}`, err)
return
}
f, err := os.Create(path.Join(listingPath, "listing.json"))
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, `{"success": false, "reason": "%s"}`, err)
return
}
defer func() {
if err := f.Close(); err != nil {
panic(err)
}
}()
m := jsonpb.Marshaler{
EnumsAsInts: false,
EmitDefaults: false,
Indent: " ",
OrigName: false,
}
out, err := m.MarshalToString(contract)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(w, `{"success": false, "reason": "%s"}`, err)
return
}
if _, err := f.WriteString(out); err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, `{"success": false, "reason": "%s"}`, err)
return
}
err = i.node.UpdateListingIndex(contract)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, `{"success": false, "reason": "%s"}`, err)
return
}
if err := i.node.SeedNode(); err != nil {
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, `{"success": false, "reason": "%s"}`, err)
return
}
fmt.Fprintf(w, `{"success": true}`)
}