// Clone returns a copy of Region. func (r *Region) Clone() *Region { return &Region{ meta: proto.Clone(r.meta).(*metapb.Region), peer: proto.Clone(r.peer).(*metapb.Peer), addr: r.addr, curPeerIdx: r.curPeerIdx, } }
// GetRegionByKey returns the Region and its leader whose range contains the key. func (c *Cluster) GetRegionByKey(key []byte) (*metapb.Region, *metapb.Peer) { c.RLock() defer c.RUnlock() for _, r := range c.regions { if regionContains(r.meta.StartKey, r.meta.EndKey, key) { return proto.Clone(r.meta).(*metapb.Region), proto.Clone(r.leaderPeer()).(*metapb.Peer) } } return nil, nil }
// MaybeExtractQ extracts proto from HTTP request and returns it. // Nil indicates failure, and appropriate status / description is written // to response. func MaybeExtractQ(w http.ResponseWriter, r *http.Request, defaultQ proto.Message) *proto.Message { q := proto.Clone(defaultQ) if r.Method == "POST" { reqBody, err := ioutil.ReadAll(r.Body) if err != nil { fmt.Fprintf(w, "Failed to read POST body %v", err) return nil } err = proto.Unmarshal(reqBody, q) if err != nil { fmt.Fprintf(w, "Failed to parse POST body as binary proto: %v", err) return nil } } else { err := r.ParseForm() if err != nil { http.NotFound(w, r) fmt.Fprintf(w, "strange query %v", err) return nil } pb := r.Form.Get("pb") if pb == "" { http.NotFound(w, r) fmt.Fprintf(w, "Non-empty jsonpb-encoded pb param required for GET") return nil } err = jsonpb.UnmarshalString(pb, q) if err != nil { fmt.Fprintf(w, "Failed to parse pb param %v", err) return nil } } return &q }
func (s *server) updateConfig(user string, updater func(*pb.ServiceConfig) error) error { s.Lock() clonedCfg := proto.Clone(s.cfgs).(*pb.ServiceConfig) currentVersion := clonedCfg.Version s.Unlock() err := updater(clonedCfg) if err != nil { return err } config.ApplyDefaults(clonedCfg) clonedCfg.User = user clonedCfg.Date = time.Now().Unix() clonedCfg.Version = currentVersion + 1 r, e := config.Marshal(clonedCfg) if e != nil { return e } return s.persister.PersistAndNotify(r) }
func TestProto3SetDefaults(t *testing.T) { in := &pb.Message{ Terrain: map[string]*pb.Nested{ "meadow": new(pb.Nested), }, Proto2Field: new(tpb.SubDefaults), Proto2Value: map[string]*tpb.SubDefaults{ "badlands": new(tpb.SubDefaults), }, } got := proto.Clone(in).(*pb.Message) proto.SetDefaults(got) // There are no defaults in proto3. Everything should be the zero value, but // we need to remember to set defaults for nested proto2 messages. want := &pb.Message{ Terrain: map[string]*pb.Nested{ "meadow": new(pb.Nested), }, Proto2Field: &tpb.SubDefaults{N: proto.Int64(7)}, Proto2Value: map[string]*tpb.SubDefaults{ "badlands": {N: proto.Int64(7)}, }, } if !proto.Equal(got, want) { t.Errorf("with in = %v\nproto.SetDefaults(in) =>\ngot %v\nwant %v", in, got, want) } }
func PrivacyFilterSnapshot(snapshot pb.Snapshot) pb.Snapshot { result := proto.Clone(&snapshot).(*pb.Snapshot) for _, session := range result.Sessions { session.Pass = "******" } return *result }
func TestClone(t *testing.T) { m := proto.Clone(cloneTestMessage).(*pb.MyMessage) if !proto.Equal(m, cloneTestMessage) { t.Errorf("Clone(%v) = %v", cloneTestMessage, m) } // Verify it was a deep copy. *m.Inner.Port++ if proto.Equal(m, cloneTestMessage) { t.Error("Mutating clone changed the original") } // Byte fields and repeated fields should be copied. if &m.Pet[0] == &cloneTestMessage.Pet[0] { t.Error("Pet: repeated field not copied") } if &m.Others[0] == &cloneTestMessage.Others[0] { t.Error("Others: repeated field not copied") } if &m.Others[0].Value[0] == &cloneTestMessage.Others[0].Value[0] { t.Error("Others[0].Value: bytes field not copied") } if &m.RepBytes[0] == &cloneTestMessage.RepBytes[0] { t.Error("RepBytes: repeated field not copied") } if &m.RepBytes[0][0] == &cloneTestMessage.RepBytes[0][0] { t.Error("RepBytes[0]: bytes field not copied") } }
// addHealthResponse adds a mocked health response to the buffer channel. func (q *fakeQueryService) addHealthResponse(qps float64) { q.healthResponses <- &querypb.StreamHealthResponse{ Target: proto.Clone(&q.target).(*querypb.Target), Serving: true, RealtimeStats: &querypb.RealtimeStats{ Qps: qps, }, } }
// AddDefaultHealthResponse adds a faked health response to the buffer channel. // The response will have default values typical for a healthy tablet. func (q *StreamHealthQueryService) AddDefaultHealthResponse() { q.healthResponses <- &querypb.StreamHealthResponse{ Target: proto.Clone(&q.target).(*querypb.Target), Serving: true, RealtimeStats: &querypb.RealtimeStats{ SecondsBehindMaster: DefaultSecondsBehindMaster, }, } }
// GetStore returns a Store's meta. func (c *Cluster) GetStore(storeID uint64) *metapb.Store { c.mu.RLock() defer c.mu.RUnlock() if store := c.stores[storeID]; store != nil { return proto.Clone(store.meta).(*metapb.Store) } return nil }
func TestMerge(t *testing.T) { for _, m := range mergeTests { got := proto.Clone(m.dst) proto.Merge(got, m.src) if !proto.Equal(got, m.want) { t.Errorf("Merge(%v, %v)\n got %v\nwant %v\n", m.dst, m.src, got, m.want) } } }
// Compile all information exported through the hackerspace API and send it // back to the requestor. func (a *SpaceAPI) ServeHTTP(rw http.ResponseWriter, req *http.Request) { var msg = proto.Clone(a.conf.SpaceapiMd) var md *doorky.SpaceAPIMetadata var door *doorky.DoorSecret var out []byte var err error var ok bool md, ok = msg.(*doorky.SpaceAPIMetadata) if !ok { log.Print("Error: message is not of type SpaceAPIMetadata") http.Error(rw, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError) } for _, door = range a.conf.Secret { var lockInfo = new(doorky.SpaceAPIDoorLockSensor) var name = door.GetName() var ts time.Time var isOpen bool ts, isOpen, err = a.ts.LastValue(name) if err != nil { log.Print("Error fetching door status for ", name, ": ", err) continue } lockInfo.Value = proto.Bool(!isOpen) lockInfo.Location = proto.String(door.GetLocation()) lockInfo.Name = proto.String(name) lockInfo.Description = proto.String("Last update: " + ts.String()) if md.Sensors == nil { md.Sensors = new(doorky.SpaceAPISensors) } md.Sensors.DoorLocked = append(md.Sensors.DoorLocked, lockInfo) if a.conf.PrimaryDoor != nil && a.conf.GetPrimaryDoor() == name { md.State.Open = proto.Bool(isOpen) md.State.Lastchange = proto.Int64(ts.Unix()) } } out, err = json.MarshalIndent(md, " ", " ") if err != nil { log.Print("Error marshalling JSON: ", err) http.Error(rw, http.StatusText(http.StatusInternalServerError)+": "+ "Error marshalling response: "+err.Error(), http.StatusInternalServerError) } _, err = rw.Write(out) if err != nil { log.Print("Error writing response: ", err) } }
func TestReadDelimited(t *testing.T) { t.Parallel() for _, test := range []struct { buf []byte msg proto.Message n int err error }{ { buf: []byte{0}, msg: &Empty{}, n: 1, }, { n: 3, buf: []byte{2, 8, 1}, msg: &GoEnum{Foo: FOO_FOO1.Enum()}, }, { buf: []byte{141, 2, 10, 138, 2, 84, 104, 105, 115, 32, 105, 115, 32, 109, 121, 32, 103, 105, 103, 97, 110, 116, 105, 99, 44, 32, 117, 110, 104, 97, 112, 112, 121, 32, 115, 116, 114, 105, 110, 103, 46, 32, 32, 73, 116, 32, 101, 120, 99, 101, 101, 100, 115, 10, 116, 104, 101, 32, 101, 110, 99, 111, 100, 105, 110, 103, 32, 115, 105, 122, 101, 32, 111, 102, 32, 97, 32, 115, 105, 110, 103, 108, 101, 32, 98, 121, 116, 101, 32, 118, 97, 114, 105, 110, 116, 46, 32, 32, 87, 101, 32, 97, 114, 101, 32, 117, 115, 105, 110, 103, 32, 105, 116, 32, 116, 111, 32, 102, 117, 122, 122, 32, 116, 101, 115, 116, 32, 116, 104, 101, 10, 99, 111, 114, 114, 101, 99, 116, 110, 101, 115, 115, 32, 111, 102, 32, 116, 104, 101, 32, 104, 101, 97, 100, 101, 114, 32, 100, 101, 99, 111, 100, 105, 110, 103, 32, 109, 101, 99, 104, 97, 110, 105, 115, 109, 115, 44, 32, 119, 104, 105, 99, 104, 32, 109, 97, 121, 32, 112, 114, 111, 118, 101, 32, 112, 114, 111, 98, 108, 101, 109, 97, 116, 105, 99, 46, 10, 73, 32, 101, 120, 112, 101, 99, 116, 32, 105, 116, 32, 109, 97, 121, 46, 32, 32, 76, 101, 116, 39, 115, 32, 104, 111, 112, 101, 32, 121, 111, 117, 32, 101, 110, 106, 111, 121, 32, 116, 101, 115, 116, 105, 110, 103, 32, 97, 115, 32, 109, 117, 99, 104, 32, 97, 115, 32, 119, 101, 32, 100, 111, 46}, msg: &Strings{ StringField: proto.String(`This is my gigantic, unhappy string. It exceeds the encoding size of a single byte varint. We are using it to fuzz test the correctness of the header decoding mechanisms, which may prove problematic. I expect it may. Let's hope you enjoy testing as much as we do.`), }, n: 271, }, } { msg := proto.Clone(test.msg) msg.Reset() if n, err := ReadDelimited(bytes.NewBuffer(test.buf), msg); n != test.n || err != test.err { t.Fatalf("ReadDelimited(%v, msg) = %v, %v; want %v, %v", test.buf, n, err, test.n, test.err) } if !proto.Equal(msg, test.msg) { t.Fatalf("ReadDelimited(%v, msg); msg = %v; want %v", test.buf, msg, test.msg) } } }
// GetRegion returns a Region's meta and leader ID. func (c *Cluster) GetRegion(regionID uint64) (*metapb.Region, uint64) { c.mu.RLock() defer c.mu.RUnlock() r := c.regions[regionID] if r == nil { return nil, 0 } return proto.Clone(r.meta).(*metapb.Region), r.leader }
// VName returns a VName for obj relative to that of its package. func (pi *PackageInfo) VName(obj types.Object) *spb.VName { sig := pi.Signature(obj) base := pi.VNames[obj.Pkg()] if base == nil { return govname.ForBuiltin(sig) } vname := proto.Clone(base).(*spb.VName) vname.Signature = sig return vname }
// subtractSystemBatteryLevel sets start level to the current level of the first proto. func subtractSystemBatteryLevel(p1, p2 *bspb.BatteryStats_System_BatteryLevel) *bspb.BatteryStats_System_BatteryLevel { if p1 == nil && p2 == nil { return nil } if p2 == nil { return proto.Clone(p1).(*bspb.BatteryStats_System_BatteryLevel) } if p1 == nil { return proto.Clone(p2).(*bspb.BatteryStats_System_BatteryLevel) } d := &bspb.BatteryStats_System_BatteryLevel{} // CurrentLevel is set as the diff between the current level of the 2 protos. d.CurrentLevel = proto.Float32(p1.GetCurrentLevel() - p2.GetCurrentLevel()) // Startlevel is set to the level of the first proto which is our main proto against which we want to diff the other one d.StartLevel = proto.Float32(p1.GetCurrentLevel()) return d }
// subtractRepeatedMessage subtracts protos in list2 from the corresponding protos in list1. // The input lists should only contain protos, and the protos should have their identifiers // be their first field. func subtractRepeatedMessage(list1, list2 interface{}) reflect.Value { if list1 == nil && list2 == nil { return reflect.ValueOf([]proto.Message{}) } l1 := genericListOrDie(list1) if list2 == nil { return l1 } l2 := genericListOrDie(list2) if list1 == nil { // Need to make negatives of the elements in list2, so can't just return here. l1 = reflect.MakeSlice(l2.Type(), 0, 0) } t1, t2 := l1.Type(), l2.Type() if t1 != t2 { log.Fatalf("Mismatched list types: %v vs %v", t1, t2) } // All entries may not occur in both files, so use maps to keep track of everything. m1, m2 := make(map[string]proto.Message), make(map[string]proto.Message) for i := 0; i < l1.Len(); i++ { item := l1.Index(i) m1[name(item)] = item.Interface().(proto.Message) } for i := 0; i < l2.Len(); i++ { item := l2.Index(i) m2[name(item)] = item.Interface().(proto.Message) } out := reflect.MakeSlice(t1, 0, l1.Len()+l2.Len()) for n, p1 := range m1 { p2, ok := m2[n] if !ok { // In list1 but not list2. out = reflect.Append(out, reflect.ValueOf(proto.Clone(p1))) continue } if diff := subtractMessage(p1, p2); diff != nil { out = reflect.Append(out, reflect.ValueOf(diff)) } } for n, p2 := range m2 { if _, ok := m1[n]; !ok { // In list2 but not list1. Subtract to get negative values. if diff := subtractMessage(nil, p2); diff != nil { out = reflect.Append(out, reflect.ValueOf(diff)) } } } if out.Len() == 0 { return reflect.Zero(l1.Type()) } return out }
// GetStoreByAddr returns a Store's meta by an addr. func (c *Cluster) GetStoreByAddr(addr string) *metapb.Store { c.mu.RLock() defer c.mu.RUnlock() for _, s := range c.stores { if s.meta.GetAddress() == addr { return proto.Clone(s.meta).(*metapb.Store) } } return nil }
// GetRegionByKey returns the Region whose range contains the key. func (c *Cluster) GetRegionByKey(key []byte) *metapb.Region { c.mu.RLock() defer c.mu.RUnlock() for _, r := range c.regions { if regionContains(r.meta.StartKey, r.meta.EndKey, key) { return proto.Clone(r.meta).(*metapb.Region) } } return nil }
// IsHealthy returns nil if the query service is healthy (able to // connect to the database and serving traffic) or an error explaining // the unhealthiness otherwise. func (tsv *TabletServer) IsHealthy() error { tsv.mu.Lock() target := proto.Clone(&tsv.target).(*querypb.Target) tsv.mu.Unlock() _, err := tsv.Execute( context.Background(), target, "select 1 from dual", nil, 0, ) return err }
func TestProtoCopy(t *testing.T) { person := InitData("ronaflx", 195936, "*****@*****.**") copyPerson := person if !proto.Equal(person, copyPerson) { t.Errorf("expect:\n%s\nactual:\n%s\n", proto.MarshalTextString(person), proto.MarshalTextString( copyPerson)) } msg := proto.Clone(person) if !proto.Equal(person, msg) { t.Errorf("expect:\n%s\nactual:\n%s\n", proto.MarshalTextString(person), proto.MarshalTextString( msg)) } }
// Write implements part of the graphstore.Service interface. func (s *GraphStore) Write(ctx context.Context, req *spb.WriteRequest) error { s.mu.Lock() defer s.mu.Unlock() for _, u := range req.Update { s.insert(proto.Clone(&spb.Entry{ Source: req.Source, EdgeKind: u.EdgeKind, Target: u.Target, FactName: u.FactName, FactValue: u.FactValue, }).(*spb.Entry)) } return nil }
func (c *Client) reader() { var err error var nr int var buf []byte defer c.Close() for { if nr, err = c.nc.Read(buf); err != nil { return } if nr > 0 { c.decBuf.WriteRawBytes(buf[0:nr]) // c.codec.OnMessage(c, c.decBuf, time.Now().UnixNano()) reader := c.decBuf pid, err := reader.ReadU16() if err != nil { return } var exists bool var callback func(proto.Message) if callback, exists = c.callbacks[pid]; !exists { return } prototype := c.prototypes[pid] if prototype != nil { raw, err := reader.ReadRawBytes() if err != nil { return } clone := proto.Clone(prototype) err = proto.Unmarshal(raw, clone) if err != nil { return } callback(clone) } else { callback(nil) } } } }
// Normalize app data func normalizeApp(a *bspb.BatteryStats_App, totalTimeHour float64) *bspb.BatteryStats_App { if a == nil { return nil } res := proto.Clone(a).(*bspb.BatteryStats_App) if norm := normalizeMessage(a.GetForeground(), totalTimeHour); norm != nil { res.Foreground = norm.(*bspb.BatteryStats_App_Foreground) } if norm := normalizeAppApk(a.GetApk(), totalTimeHour); norm != nil { res.Apk = norm } normalizeAppChildren(res.GetChild(), totalTimeHour) if norm := normalizeMessage(a.GetNetwork(), totalTimeHour); norm != nil { res.Network = norm.(*bspb.BatteryStats_App_Network) } if norm := normalizeMessage(a.GetPowerUseItem(), totalTimeHour); norm != nil { res.PowerUseItem = norm.(*bspb.BatteryStats_App_PowerUseItem) } if norm := normalizeRepeatedMessage(a.GetProcess(), totalTimeHour).Interface(); norm != nil { res.Process = norm.([]*bspb.BatteryStats_App_Process) } if norm := normalizeRepeatedMessage(a.GetSensor(), totalTimeHour).Interface(); norm != nil { res.Sensor = norm.([]*bspb.BatteryStats_App_Sensor) } if norm := normalizeMessage(a.GetStateTime(), totalTimeHour); norm != nil { res.StateTime = norm.(*bspb.BatteryStats_App_StateTime) } if norm := normalizeMessage(a.GetVibrator(), totalTimeHour); norm != nil { res.Vibrator = norm.(*bspb.BatteryStats_App_Vibrator) } if norm := normalizeRepeatedMessage(a.GetWakelock(), totalTimeHour).Interface(); norm != nil { res.Wakelock = norm.([]*bspb.BatteryStats_App_Wakelock) } if norm := normalizeRepeatedMessage(a.GetWakeupAlarm(), totalTimeHour).Interface(); norm != nil { res.WakeupAlarm = norm.([]*bspb.BatteryStats_App_WakeupAlarm) } if norm := normalizeMessage(a.GetWifi(), totalTimeHour); norm != nil { res.Wifi = norm.(*bspb.BatteryStats_App_Wifi) } if norm := normalizeRepeatedMessage(a.GetUserActivity(), totalTimeHour).Interface(); norm != nil { res.UserActivity = norm.([]*bspb.BatteryStats_App_UserActivity) } if norm := normalizeRepeatedMessage(a.GetScheduledJob(), totalTimeHour).Interface(); norm != nil { res.ScheduledJob = norm.([]*bspb.BatteryStats_App_ScheduledJob) } return res }
// agentRPCTestIsTimeoutErrorDialTimeout verifies that client.IsTimeoutError() // returns true for RPCs failed due to a connect timeout during .Dial(). func agentRPCTestIsTimeoutErrorDialTimeout(ctx context.Context, t *testing.T, client tmclient.TabletManagerClient, ti *topo.TabletInfo) { // Connect to a non-existing tablet. // For example, this provokes gRPC to return error grpc.ErrClientConnTimeout. invalidTi := topo.NewTabletInfo(ti.Tablet, ti.Version()) invalidTi.Tablet = proto.Clone(invalidTi.Tablet).(*topodatapb.Tablet) invalidTi.Tablet.Hostname = "Non-Existent.Server" shortCtx, cancel := context.WithTimeout(ctx, time.Millisecond) defer cancel() err := client.Ping(shortCtx, invalidTi) if err == nil { t.Fatal("agentRPCTestIsTimeoutErrorDialTimeout: connect to non-existant tablet did not fail") } if !client.IsTimeoutError(err) { t.Errorf("agentRPCTestIsTimeoutErrorDialTimeout: want: IsTimeoutError() = true. error: %v", err) } }
func TestUnmarshalGolden(t *testing.T) { for _, tt := range goldenMessages { want := tt.m got := proto.Clone(tt.m) got.Reset() if err := proto.UnmarshalText(tt.t, got); err != nil { t.Errorf("failed to unmarshal\n%s\nerror: %v", tt.t, err) } if !anyEqual(got, want) { t.Errorf("message:\n%s\ngot:\n%s\nwant:\n%s", tt.t, got, want) } got.Reset() if err := proto.UnmarshalText(tt.c, got); err != nil { t.Errorf("failed to unmarshal\n%s\nerror: %v", tt.c, err) } if !anyEqual(got, want) { t.Errorf("message:\n%s\ngot:\n%s\nwant:\n%s", tt.c, got, want) } } }
func TestUnmarshalling(t *testing.T) { for _, tt := range unmarshallingTests { // Make a new instance of the type of our expected object. p := proto.Clone(tt.pb) p.Reset() err := UnmarshalString(tt.json, p) if err != nil { t.Error(err) continue } // For easier diffs, compare text strings of the protos. exp := proto.MarshalTextString(tt.pb) act := proto.MarshalTextString(p) if string(exp) != string(act) { t.Errorf("%s: got [%s] want [%s]", tt.desc, act, exp) } } }
// UpdateStream is part of tabletconn.TabletConn. func (itc *internalTabletConn) UpdateStream(ctx context.Context, target *querypb.Target, position string, timestamp int64) (tabletconn.StreamEventReader, error) { result := make(chan *querypb.StreamEvent, 10) var finalErr error go func() { finalErr = itc.tablet.qsc.QueryService().UpdateStream(ctx, target, position, timestamp, func(reply *querypb.StreamEvent) error { // We need to deep-copy the reply before returning, // because the underlying buffers are reused. result <- proto.Clone(reply).(*querypb.StreamEvent) return nil }) finalErr = tabletconn.TabletErrorFromGRPC(vterrors.ToGRPCError(finalErr)) // the client will only access finalErr after the // channel is closed, and then it's already set. close(result) }() return &updateStreamAdapter{result, &finalErr}, nil }
func TestEndToEndValid(t *testing.T) { t.Parallel() for _, test := range [][]proto.Message{ {&Empty{}}, {&GoEnum{Foo: FOO_FOO1.Enum()}, &Empty{}, &GoEnum{Foo: FOO_FOO1.Enum()}}, {&GoEnum{Foo: FOO_FOO1.Enum()}}, {&Strings{ StringField: proto.String(`This is my gigantic, unhappy string. It exceeds the encoding size of a single byte varint. We are using it to fuzz test the correctness of the header decoding mechanisms, which may prove problematic. I expect it may. Let's hope you enjoy testing as much as we do.`), }}, } { var buf bytes.Buffer var written int for i, msg := range test { n, err := WriteDelimited(&buf, msg) if err != nil { // Assumption: TestReadDelimited and TestWriteDelimited are sufficient // and inputs for this test are explicitly exercised there. t.Fatalf("WriteDelimited(buf, %v[%d]) = ?, %v; wanted ?, nil", test, i, err) } written += n } var read int for i, msg := range test { out := proto.Clone(msg) out.Reset() n, _ := ReadDelimited(&buf, out) // Decide to do EOF checking? read += n if !proto.Equal(out, msg) { t.Fatalf("out = %v; want %v[%d] = %#v", out, test, i, msg) } } if read != written { t.Fatalf("%v read = %d; want %d", test, read, written) } } }
func (codec *GPBCodec) OnMessage(conn *Conn, buf *Buffer, receiveTime int64) { // header size, err := buf.ReadU16() if err != nil { return } // pid pid, err := buf.ReadU16() if err != nil { return } var exists bool var callback func(*Conn, proto.Message) if callback, exists = codec.callbacks[pid]; !exists { return } prototype := codec.prototypes[pid] if prototype != nil { raw, err := buf.ReadSizedBytes(int(size - 2)) if err != nil { return } clone := proto.Clone(prototype) err = proto.Unmarshal(raw, clone) if err != nil { return } callback(conn, clone) } else { callback(conn, nil) } }