func TestIsDifferentUrlPrefixes(t *testing.T) { m := &pb.FileDescriptorProto{} a := &any.Any{TypeUrl: "foo/bar/" + proto.MessageName(m)} if !Is(a, m) { t.Errorf("message with type url %q didn't satisfy Is for type %q", a.TypeUrl, proto.MessageName(m)) } }
func (ipc *procIPCEventHandler) OnEvent(event *Event, conn io.ReadWriteCloser) { if event.GetType() == EventType_NOTIFY { switch event.GetMsgType() { case proto.MessageName((*HeartBeat)(nil)): var hbres HeartBeat hbres.Res = proto.Bool(true) notify(&hbres, 0, conn) case proto.MessageName((*AdminEvent)(nil)): event.decode() attach := getSessionAttach(event.GetHashCode()) if nil != attach { attach.(*writeBack).wr.Write([]byte(event.Msg.(*AdminEvent).GetContent())) } default: dispatch(event) } } else { if event.GetTo() != getProcessorName() { dispatch(event) return } event.decode() if event.GetType() == EventType_RESPONSE { triggerClientSessionRes(event.Msg, event.GetHashCode()) } else { //hanlder event } } }
func (c *Connection) handle() { var msg proto.Message for { select { case <-c.doneCh: return case msg = <-c.recv: } log.WithField("msg", msg).Debug("new msg") switch v := msg.(type) { case *protos.SubmitTask: if v.GetMulti() { generateTasks(v.GetOptions()) } else { t := &Task{} t.id = getNextTaskID() t.options = v.GetOptions() taskChan <- t } case *protos.TaskStatus: c.worker.taskStatusChan <- v case *protos.TaskResult: c.worker.taskResultChan <- v case *protos.SubmitCode: addJobType(v) default: log.WithFields(log.Fields{ "type": proto.MessageName(msg), "message": v, }).Error("connection.handle invalid type") } } }
func writeEvent(ev *Event, writer io.Writer) error { if len(ev.raw) > 0 { _, err := writer.Write(ev.raw) return err } var buf bytes.Buffer dataBuf, err := proto.Marshal(ev.Msg) if nil != err { return err } msgtype := proto.MessageName(ev.Msg) ev.MsgType = &msgtype headbuf, _ := proto.Marshal(ev) headerLen := uint32(len(headbuf)) // length = msglength(3byte) + headerlen(1byte) length := uint32(len(dataBuf)) length = (length << 8) + headerLen buf.Write(MAGIC_EVENT_HEADER) binary.Write(&buf, binary.LittleEndian, length) buf.Write(headbuf) buf.Write(dataBuf) _, err = buf.WriteTo(writer) return err }
// MarshalAny takes the protocol buffer and encodes it into google.protobuf.Any. func MarshalAny(pb proto.Message) (*any.Any, error) { value, err := proto.Marshal(pb) if err != nil { return nil, err } return &any.Any{TypeUrl: googleApis + proto.MessageName(pb), Value: value}, nil }
// Is returns true if any value contains a given message type. func Is(any *any.Any, pb proto.Message) bool { aname, err := AnyMessageName(any) if err != nil { return false } return aname == proto.MessageName(pb) }
func messageNameForPackage(pkg string, message golang.Message) (string, error) { switch pkg { case "golang": return golang.MessageName(message), nil //case "gogo": //return gogo.MessageName(message), nil default: return "", fmt.Errorf("lion: unknown package: %s", pkg) } }
func packMessage(message proto.Message, target *actor.PID) (*messages.MessageEnvelope, error) { typeName := proto.MessageName(message) bytes, err := proto.Marshal(message) if err != nil { return nil, err } envelope := &messages.MessageEnvelope{ TypeName: typeName, MessageData: bytes, Target: target, } return envelope, nil }
// UnmarshalAny parses the protocol buffer representation in a google.protobuf.Any // message and places the decoded result in pb. It returns an error if type of // contents of Any message does not match type of pb message. // // pb can be a proto.Message, or a *DynamicAny. func UnmarshalAny(any *any.Any, pb proto.Message) error { if d, ok := pb.(*DynamicAny); ok { if d.Message == nil { var err error d.Message, err = Empty(any) if err != nil { return err } } return UnmarshalAny(any, d.Message) } aname, err := AnyMessageName(any) if err != nil { return err } mname := proto.MessageName(pb) if aname != mname { return fmt.Errorf("mismatched message type: got %q want %q", aname, mname) } return proto.Unmarshal(any.Value, pb) }
func makeGolden() []golden { nested := &pb.Nested{Bunny: "Monty"} nb, err := proto.Marshal(nested) if err != nil { panic(err) } m1 := &pb.Message{ Name: "David", ResultCount: 47, Anything: &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(nested), Value: nb}, } m2 := &pb.Message{ Name: "David", ResultCount: 47, Anything: &anypb.Any{TypeUrl: "http://[::1]/type.googleapis.com/" + proto.MessageName(nested), Value: nb}, } m3 := &pb.Message{ Name: "David", ResultCount: 47, Anything: &anypb.Any{TypeUrl: `type.googleapis.com/"/` + proto.MessageName(nested), Value: nb}, } m4 := &pb.Message{ Name: "David", ResultCount: 47, Anything: &anypb.Any{TypeUrl: "type.googleapis.com/a/path/" + proto.MessageName(nested), Value: nb}, } m5 := &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(nested), Value: nb} any1 := &testpb.MyMessage{Count: proto.Int32(47), Name: proto.String("David")} proto.SetExtension(any1, testpb.E_Ext_More, &testpb.Ext{Data: proto.String("foo")}) proto.SetExtension(any1, testpb.E_Ext_Text, proto.String("bar")) any1b, err := proto.Marshal(any1) if err != nil { panic(err) } any2 := &testpb.MyMessage{Count: proto.Int32(42), Bikeshed: testpb.MyMessage_GREEN.Enum(), RepBytes: [][]byte{[]byte("roboto")}} proto.SetExtension(any2, testpb.E_Ext_More, &testpb.Ext{Data: proto.String("baz")}) any2b, err := proto.Marshal(any2) if err != nil { panic(err) } m6 := &pb.Message{ Name: "David", ResultCount: 47, Anything: &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any1), Value: any1b}, ManyThings: []*anypb.Any{ &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any2), Value: any2b}, &anypb.Any{TypeUrl: "type.googleapis.com/" + proto.MessageName(any1), Value: any1b}, }, } const ( m1Golden = ` name: "David" result_count: 47 anything: < [type.googleapis.com/proto3_proto.Nested]: < bunny: "Monty" > > ` m2Golden = ` name: "David" result_count: 47 anything: < ["http://[::1]/type.googleapis.com/proto3_proto.Nested"]: < bunny: "Monty" > > ` m3Golden = ` name: "David" result_count: 47 anything: < ["type.googleapis.com/\"/proto3_proto.Nested"]: < bunny: "Monty" > > ` m4Golden = ` name: "David" result_count: 47 anything: < [type.googleapis.com/a/path/proto3_proto.Nested]: < bunny: "Monty" > > ` m5Golden = ` [type.googleapis.com/proto3_proto.Nested]: < bunny: "Monty" > ` m6Golden = ` name: "David" result_count: 47 anything: < [type.googleapis.com/testdata.MyMessage]: < count: 47 name: "David" [testdata.Ext.more]: < data: "foo" > [testdata.Ext.text]: "bar" > > many_things: < [type.googleapis.com/testdata.MyMessage]: < count: 42 bikeshed: GREEN rep_bytes: "roboto" [testdata.Ext.more]: < data: "baz" > > > many_things: < [type.googleapis.com/testdata.MyMessage]: < count: 47 name: "David" [testdata.Ext.more]: < data: "foo" > [testdata.Ext.text]: "bar" > > ` ) return []golden{ {m1, strings.TrimSpace(m1Golden) + "\n", strings.TrimSpace(compact(m1Golden)) + " "}, {m2, strings.TrimSpace(m2Golden) + "\n", strings.TrimSpace(compact(m2Golden)) + " "}, {m3, strings.TrimSpace(m3Golden) + "\n", strings.TrimSpace(compact(m3Golden)) + " "}, {m4, strings.TrimSpace(m4Golden) + "\n", strings.TrimSpace(compact(m4Golden)) + " "}, {m5, strings.TrimSpace(m5Golden) + "\n", strings.TrimSpace(compact(m5Golden)) + " "}, {m6, strings.TrimSpace(m6Golden) + "\n", strings.TrimSpace(compact(m6Golden)) + " "}, } }
func GetMessageType(message proto.Message) string { return proto.MessageName(message) }
func (p *pusher) getLogrusEntry(entry *protolog.Entry) (*logrus.Entry, error) { logrusLevel, ok := levelToLogrusLevel[entry.Level] if !ok { return nil, fmt.Errorf("protolog: no logrus Level for %v", entry.Level) } logrusEntry := logrus.NewEntry(p.logger) logrusEntry.Time = prototime.TimestampToTime(entry.Timestamp) logrusEntry.Level = logrusLevel if p.options.EnableID { logrusEntry.Data["_id"] = entry.Id } if !p.options.DisableContexts { contexts, err := entry.UnmarshalledContexts() if err != nil { return nil, err } for _, context := range contexts { if context == nil { continue } name := proto.MessageName(context) switch name { case "protolog.Fields": protologFields, ok := context.(*protolog.Fields) if !ok { return nil, fmt.Errorf("protolog: expected *protolog.Fields, got %T", context) } for key, value := range protologFields.Value { if value != "" { logrusEntry.Data[key] = value } } default: if err := addProtoMessage(logrusEntry, context); err != nil { return nil, err } } } } event, err := entry.UnmarshalledEvent() if err != nil { return nil, err } if event != nil { name := proto.MessageName(event) switch name { case "protolog.Event": protologEvent, ok := event.(*protolog.Event) if !ok { return nil, fmt.Errorf("protolog: expected *protolog.Event, got %T", event) } logrusEntry.Message = trimRightSpace(protologEvent.Message) case "protolog.WriterOutput": writerOutput, ok := event.(*protolog.WriterOutput) if !ok { return nil, fmt.Errorf("protolog: expected *protolog.WriterOutput, got %T", event) } logrusEntry.Message = trimRightSpace(string(writerOutput.Value)) default: logrusEntry.Data["_event"] = name if err := addProtoMessage(logrusEntry, event); err != nil { return nil, err } } } return logrusEntry, nil }
func messageName(message proto.Message) string { if message == nil { return "" } return proto.MessageName(message) }