func eventToPbEvent(event *Event) (*proto.Event, error) { var e proto.Event if event.Host == "" { event.Host, _ = os.Hostname() } t := reflect.ValueOf(&e).Elem() s := reflect.ValueOf(event).Elem() typeOfEvent := s.Type() for i := 0; i < s.NumField(); i++ { f := s.Field(i) value := reflect.ValueOf(f.Interface()) if reflect.Zero(f.Type()) != value && f.Interface() != nil { name := typeOfEvent.Field(i).Name switch name { case "State", "Service", "Host", "Description": tmp := reflect.ValueOf(pb.String(value.String())) t.FieldByName(name).Set(tmp) case "Ttl": tmp := reflect.ValueOf(pb.Float32(float32(value.Float()))) t.FieldByName(name).Set(tmp) case "Time": tmp := reflect.ValueOf(pb.Int64(value.Int())) t.FieldByName(name).Set(tmp) case "Tags": tmp := reflect.ValueOf(value.Interface().([]string)) t.FieldByName(name).Set(tmp) case "Metric": switch reflect.TypeOf(f.Interface()).Kind() { case reflect.Int: tmp := reflect.ValueOf(pb.Int64(int64(value.Int()))) t.FieldByName("MetricSint64").Set(tmp) case reflect.Float32: tmp := reflect.ValueOf(pb.Float32(float32(value.Float()))) t.FieldByName("MetricF").Set(tmp) case reflect.Float64: tmp := reflect.ValueOf(pb.Float64(value.Float())) t.FieldByName("MetricD").Set(tmp) default: return nil, fmt.Errorf("Metric of invalid type (type %v)", reflect.TypeOf(f.Interface()).Kind()) } } } } return &e, nil }
func newTestMessage() *pb.MyMessage { msg := &pb.MyMessage{ Count: proto.Int32(42), Name: proto.String("Dave"), Quote: proto.String(`"I didn't want to go."`), Pet: []string{"bunny", "kitty", "horsey"}, Inner: &pb.InnerMessage{ Host: proto.String("footrest.syd"), Port: proto.Int32(7001), Connected: proto.Bool(true), }, Others: []*pb.OtherMessage{ { Key: proto.Int64(0xdeadbeef), Value: []byte{1, 65, 7, 12}, }, { Weight: proto.Float32(6.022), Inner: &pb.InnerMessage{ Host: proto.String("lesha.mtv"), Port: proto.Int32(8002), }, }, }, Bikeshed: pb.MyMessage_BLUE.Enum(), Somegroup: &pb.MyMessage_SomeGroup{ GroupField: proto.Int32(8), }, // One normally wouldn't do this. // This is an undeclared tag 13, as a varint (wire type 0) with value 4. XXX_unrecognized: []byte{13<<3 | 0, 4}, } ext := &pb.Ext{ Data: proto.String("Big gobs for big rats"), } if err := proto.SetExtension(msg, pb.E_Ext_More, ext); err != nil { panic(err) } greetings := []string{"adg", "easy", "cow"} if err := proto.SetExtension(msg, pb.E_Greeting, greetings); err != nil { panic(err) } // Add an unknown extension. We marshal a pb.Ext, and fake the ID. b, err := proto.Marshal(&pb.Ext{Data: proto.String("3G skiing")}) if err != nil { panic(err) } b = append(proto.EncodeVarint(201<<3|proto.WireBytes), b...) proto.SetRawExtension(msg, 201, b) // Extensions can be plain fields, too, so let's test that. b = append(proto.EncodeVarint(202<<3|proto.WireVarint), 19) proto.SetRawExtension(msg, 202, b) return msg }
func (l *LevelDBMetricPersistence) AppendSample(sample *model.Sample) (err error) { begin := time.Now() defer func() { duration := time.Now().Sub(begin) recordOutcome(storageOperations, storageLatency, duration, err, map[string]string{operation: appendSample, result: success}, map[string]string{operation: appendSample, result: failure}) }() metricDTO := model.SampleToMetricDTO(sample) indexHas, err := l.hasIndexMetric(metricDTO) if err != nil { return } if !indexHas { err = l.indexMetric(metricDTO) if err != nil { return } err = l.appendFingerprints(metricDTO) if err != nil { return } } fingerprintDTO, err := model.MessageToFingerprintDTO(metricDTO) if err != nil { return } sampleKeyDTO := &dto.SampleKey{ Fingerprint: fingerprintDTO, Timestamp: indexable.EncodeTime(sample.Timestamp), } sampleValueDTO := &dto.SampleValue{ Value: proto.Float32(float32(sample.Value)), } sampleKeyEncoded := coding.NewProtocolBufferEncoder(sampleKeyDTO) sampleValueEncoded := coding.NewProtocolBufferEncoder(sampleValueDTO) err = l.metricSamples.Put(sampleKeyEncoded, sampleValueEncoded) if err != nil { return } return }
func (s sampleGroup) Get() (key, value coding.Encoder) { key = coding.NewProtocolBuffer(&dto.SampleKey{ Fingerprint: model.NewFingerprintFromRowKey(s.fingerprint).ToDTO(), Timestamp: indexable.EncodeTime(s.values[0].time), LastTimestamp: proto.Int64(s.values[len(s.values)-1].time.Unix()), SampleCount: proto.Uint32(uint32(len(s.values))), }) series := &dto.SampleValueSeries{} for _, value := range s.values { series.Value = append(series.Value, &dto.SampleValueSeries_Value{ Timestamp: proto.Int64(value.time.Unix()), Value: proto.Float32(float32(value.value)), }) } value = coding.NewProtocolBuffer(series) return }
// Flush request and send data to Pinba server func (pinba *Pinba) Flush(request *request) error { if !pinba.connected { return fmt.Errorf("Could not connect to pinba server") } runtime.ReadMemStats(&memStats) req := ProtoMessage.Request{ Hostname: proto.String(pinba.hostname), ServerName: proto.String(pinba.serverName), ScriptName: proto.String(request.scriptName), RequestCount: proto.Uint32(1), DocumentSize: proto.Uint32(0), MemoryPeak: proto.Uint32(0), MemoryFootprint: proto.Uint32(uint32(memStats.TotalAlloc - request.memoryUsage)), RequestTime: proto.Float32(float32(time.Since(request.timeStart).Seconds())), RuUtime: proto.Float32(0), RuStime: proto.Float32(0), Schema: proto.String(request.schema), Dictionary: make([]string, 0, 20), TimerTagName: make([]uint32, 0, 20), TimerTagValue: make([]uint32, 0, 20), } for _, timer := range request.timers { req.TimerTagCount = append(req.TimerTagCount, uint32(len(*timer.tags))) req.TimerHitCount = append(req.TimerHitCount, 1) req.TimerValue = append(req.TimerValue, float32(timer.timeEnd.Sub(timer.timeStart).Seconds())) for tag, value := range *timer.tags { if pos, exists := inSlice(tag, req.Dictionary); exists { req.TimerTagName = append(req.TimerTagName, uint32(pos)) } else { req.Dictionary = append(req.Dictionary, tag) req.TimerTagName = append(req.TimerTagName, uint32(len(req.Dictionary)-1)) } if pos, exists := inSlice(value, req.Dictionary); exists { req.TimerTagValue = append(req.TimerTagValue, uint32(pos)) } else { req.Dictionary = append(req.Dictionary, value) req.TimerTagValue = append(req.TimerTagValue, uint32(len(req.Dictionary)-1)) } } } message, err := proto.Marshal(&req) if err != nil { return err } if _, err = pinba.connect.Write(message); err != nil { return err } return nil }
// User stats message. Shown in the Mumble client when a // user right clicks a user and selects 'User Information'. func (server *Server) handleUserStatsMessage(client *Client, msg *Message) { stats := &mumbleproto.UserStats{} err := proto.Unmarshal(msg.buf, stats) if err != nil { client.Panic(err) return } if stats.Session == nil { return } target, exists := server.clients[*stats.Session] if !exists { return } extended := false // If a client is requesting a UserStats from itself, serve it the whole deal. if client == target { extended = true } // Otherwise, only send extended UserStats for people with +register permissions // on the root channel. rootChan := server.RootChannel() if acl.HasPermission(&rootChan.ACL, client, acl.RegisterPermission) { extended = true } // If the client wasn't granted extended permissions, only allow it to query // users in channels it can enter. if !extended && !acl.HasPermission(&target.Channel.ACL, client, acl.EnterPermission) { client.sendPermissionDenied(client, target.Channel, acl.EnterPermission) return } details := extended local := extended || target.Channel == client.Channel if stats.StatsOnly != nil && *stats.StatsOnly == true { details = false } stats.Reset() stats.Session = proto.Uint32(target.Session()) if details { if tlsconn := target.conn.(*tls.Conn); tlsconn != nil { state := tlsconn.ConnectionState() for i := len(state.PeerCertificates) - 1; i >= 0; i-- { stats.Certificates = append(stats.Certificates, state.PeerCertificates[i].Raw) } stats.StrongCertificate = proto.Bool(target.IsVerified()) } } if local { fromClient := &mumbleproto.UserStats_Stats{} fromClient.Good = proto.Uint32(target.crypt.Good) fromClient.Late = proto.Uint32(target.crypt.Late) fromClient.Lost = proto.Uint32(target.crypt.Lost) fromClient.Resync = proto.Uint32(target.crypt.Resync) stats.FromClient = fromClient fromServer := &mumbleproto.UserStats_Stats{} fromServer.Good = proto.Uint32(target.crypt.RemoteGood) fromServer.Late = proto.Uint32(target.crypt.RemoteLate) fromServer.Lost = proto.Uint32(target.crypt.RemoteLost) fromServer.Resync = proto.Uint32(target.crypt.RemoteResync) stats.FromServer = fromServer } stats.UdpPackets = proto.Uint32(target.UdpPackets) stats.TcpPackets = proto.Uint32(target.TcpPackets) stats.UdpPingAvg = proto.Float32(target.UdpPingAvg) stats.UdpPingVar = proto.Float32(target.UdpPingVar) stats.TcpPingAvg = proto.Float32(target.TcpPingAvg) stats.TcpPingVar = proto.Float32(target.TcpPingVar) if details { version := &mumbleproto.Version{} version.Version = proto.Uint32(target.Version) if len(target.ClientName) > 0 { version.Release = proto.String(target.ClientName) } if len(target.OSName) > 0 { version.Os = proto.String(target.OSName) if len(target.OSVersion) > 0 { version.OsVersion = proto.String(target.OSVersion) } } stats.Version = version stats.CeltVersions = target.codecs stats.Opus = proto.Bool(target.opus) stats.Address = target.tcpaddr.IP } // fixme(mkrautz): we don't do bandwidth tracking yet if err := client.sendMessage(stats); err != nil { client.Panic(err) return } }
func eventToPbEvent(event *Event) (*proto.Event, error) { var e proto.Event if event.Host == "" { event.Host, _ = os.Hostname() } t := reflect.ValueOf(&e).Elem() s := reflect.ValueOf(event).Elem() typeOfEvent := s.Type() for i := 0; i < s.NumField(); i++ { f := s.Field(i) value := reflect.ValueOf(f.Interface()) if reflect.Zero(f.Type()) != value && f.Interface() != nil { name := typeOfEvent.Field(i).Name switch name { case "State", "Service", "Host", "Description": tmp := reflect.ValueOf(pb.String(value.String())) t.FieldByName(name).Set(tmp) case "Ttl": tmp := reflect.ValueOf(pb.Float32(float32(value.Float()))) t.FieldByName(name).Set(tmp) case "Time": tmp := reflect.ValueOf(pb.Int64(value.Int())) t.FieldByName(name).Set(tmp) case "Tags": tmp := reflect.ValueOf(value.Interface().([]string)) t.FieldByName(name).Set(tmp) case "Metric": switch reflect.TypeOf(f.Interface()).Kind() { case reflect.Int: tmp := reflect.ValueOf(pb.Int64(int64(value.Int()))) t.FieldByName("MetricSint64").Set(tmp) case reflect.Float32: tmp := reflect.ValueOf(pb.Float32(float32(value.Float()))) t.FieldByName("MetricF").Set(tmp) case reflect.Float64: tmp := reflect.ValueOf(pb.Float64(value.Float())) t.FieldByName("MetricD").Set(tmp) default: return nil, fmt.Errorf("Metric of invalid type (type %v)", reflect.TypeOf(f.Interface()).Kind()) } case "Attributes": var attrs []*proto.Attribute for k, v := range value.Interface().(map[string]string) { // Copy k,v so we can take // pointers to the new // temporaries k_, v_ := k, v attrs = append(attrs, &proto.Attribute{ Key: &k_, Value: &v_, }) } t.FieldByName(name).Set(reflect.ValueOf(attrs)) } } } return &e, nil }
// 模拟客户端(uuid) func testClient(uuid int) { defer func() { if e := recover(); e != nil { log.Printf("uuid: [%v] Panic: %v\r\n", getUuid(uuid), e) } }() // 连接服务器 tcpAddr, _ := net.ResolveTCPAddr("tcp4", config.Addr) conn, err := net.DialTCP("tcp", nil, tcpAddr) if err != nil { log.Printf("[%v] DialTCP失败: %v\r\n", getUuid(uuid), err) return } // 发送登陆请求 writeLoginMsg := &pb.PbClientLogin{ Uuid: proto.String(getUuid(uuid)), Version: proto.Float32(3.14), Timestamp: proto.Int64(time.Now().Unix()), } err = handlers.SendPbData(conn, packet.PK_ClientLogin, writeLoginMsg) if err != nil { log.Printf("[%v] 发送登陆包失败: %v\r\n", getUuid(uuid), err) return } // 下面这些处理和server.go中的一样 receivePackets := make(chan *packet.Packet, 20) // 接收到的包 chStop := make(chan bool) // 通知停止消息处理 request := make([]byte, 1024) rbuf := ringbuffer.NewRingBuffer(1024) defer func() { conn.Close() chStop <- true }() // 发送心跳包 go ping(conn) // 处理接受到的包 go handlePackets(uuid, conn, receivePackets, chStop) for { readSize, err := conn.Read(request) if err != nil { return } if readSize > 0 { rbuf.Write(request[:readSize]) // 包长(4) + 类型(4) + 包体(len([]byte)) for { if rbuf.Size() >= 8 { pacLen := convert.BytesToUint32(rbuf.Bytes(4)) if rbuf.Size() >= int(pacLen) { rbuf.Peek(4) receivePackets <- &packet.Packet{ Len: pacLen, Type: convert.BytesToUint32(rbuf.Read(4)), Data: rbuf.Read(int(pacLen) - 8), } } else { break } } else { break } } } } }
func (l *LevelDBMetricPersistence) AppendSamples(samples model.Samples) (err error) { begin := time.Now() defer func() { duration := time.Since(begin) recordOutcome(duration, err, map[string]string{operation: appendSamples, result: success}, map[string]string{operation: appendSamples, result: failure}) }() var ( fingerprintToSamples = groupByFingerprint(samples) indexErrChan = make(chan error) watermarkErrChan = make(chan error) ) go func(groups map[model.Fingerprint]model.Samples) { var ( metrics = map[model.Fingerprint]model.Metric{} ) for fingerprint, samples := range groups { metrics[fingerprint] = samples[0].Metric } indexErrChan <- l.indexMetrics(metrics) }(fingerprintToSamples) go func(groups map[model.Fingerprint]model.Samples) { watermarkErrChan <- l.refreshHighWatermarks(groups) }(fingerprintToSamples) samplesBatch := leveldb.NewBatch() defer samplesBatch.Close() for fingerprint, group := range fingerprintToSamples { for { lengthOfGroup := len(group) if lengthOfGroup == 0 { break } take := *leveldbChunkSize if lengthOfGroup < take { take = lengthOfGroup } chunk := group[0:take] group = group[take:lengthOfGroup] key := &dto.SampleKey{ Fingerprint: fingerprint.ToDTO(), Timestamp: indexable.EncodeTime(chunk[0].Timestamp), LastTimestamp: proto.Int64(chunk[take-1].Timestamp.Unix()), SampleCount: proto.Uint32(uint32(take)), } value := &dto.SampleValueSeries{} for _, sample := range chunk { value.Value = append(value.Value, &dto.SampleValueSeries_Value{ Timestamp: proto.Int64(sample.Timestamp.Unix()), Value: proto.Float32(float32(sample.Value)), }) } samplesBatch.Put(coding.NewProtocolBuffer(key), coding.NewProtocolBuffer(value)) } } err = l.metricSamples.Commit(samplesBatch) if err != nil { panic(err) } err = <-indexErrChan if err != nil { panic(err) } err = <-watermarkErrChan if err != nil { panic(err) } return }
func testBB(i_uuid string) { tcpAddr, _ := net.ResolveTCPAddr("tcp4", config.Addr) conn, err := net.DialTCP("tcp", nil, tcpAddr) if err != nil { log.Printf("%v DialTCP失败: %v\r\n", i_uuid, err) return } defer conn.Close() // 登陆 // write writeLoginMsg := &pb.PbClientLogin{ Uuid: proto.String(i_uuid), Version: proto.Float32(3.14), Timestamp: proto.Int64(time.Now().Unix()), } err = handlers.SendPbData(conn, packet.PK_ClientLogin, writeLoginMsg) if err != nil { log.Printf("%v 发送登陆包失败: %v\r\n", i_uuid, err) return } var ( bLen []byte = make([]byte, 4) bType []byte = make([]byte, 4) pacLen uint32 ) // read if n, err := io.ReadFull(conn, bLen); err != nil && n != 4 { log.Printf("Read pacLen failed: %v\r\n", err) return } if n, err := io.ReadFull(conn, bType); err != nil && n != 4 { log.Printf("Read pacType failed: %v\r\n", err) return } if pacLen = convert.BytesToUint32(bLen); pacLen > uint32(2048) { log.Printf("pacLen larger than maxPacLen\r\n") return } pacData := make([]byte, pacLen-8) if n, err := io.ReadFull(conn, pacData); err != nil && n != int(pacLen) { log.Printf("Read pacData failed: %v\r\n", err) return } pac := &packet.Packet{ Len: pacLen, Type: convert.BytesToUint32(bType), Data: pacData, } readAccepLoginMsg := &pb.PbServerAcceptLogin{} err = packet.Unpack(pac, readAccepLoginMsg) if err != nil { log.Printf("%v Unpack error: %v\r\n", i_uuid, err) return } fmt.Println(readAccepLoginMsg.GetLogin()) fmt.Println(readAccepLoginMsg.GetTipsMsg()) fmt.Println(convert.TimestampToTimeString(readAccepLoginMsg.GetTimestamp())) // 定时发送心跳包 go ping(conn) // 先向对方发送消息 // write go func() { writeC2CMsg := &pb.PbC2CTextChat{ FromUuid: proto.String(i_uuid), ToUuid: proto.String(u_uuid), TextMsg: proto.String("hi, 我的uuid是: " + i_uuid), Timestamp: proto.Int64(time.Now().Unix()), } err := handlers.SendPbData(conn, packet.PK_C2CTextChat, writeC2CMsg) if err != nil { log.Printf("%v 发送消息失败: %v\r\n", i_uuid, err) return } }() // 死循环,接收消息和发送消息 for { fmt.Println("坐等消息到来...") // read if n, err := io.ReadFull(conn, bLen); err != nil && n != 4 { log.Printf("Read pacLen failed: %v\r\n", err) return } if n, err := io.ReadFull(conn, bType); err != nil && n != 4 { log.Printf("Read pacType failed: %v\r\n", err) return } if pacLen = convert.BytesToUint32(bLen); pacLen > uint32(2048) { log.Printf("pacLen larger than maxPacLen\r\n") return } pacData := make([]byte, pacLen-8) if n, err := io.ReadFull(conn, pacData); err != nil && n != int(pacLen) { log.Printf("Read pacData failed: %v\r\n", err) return } pac := &packet.Packet{ Len: pacLen, Type: convert.BytesToUint32(bType), Data: pacData, } readC2CMsg := &pb.PbC2CTextChat{} err = packet.Unpack(pac, readC2CMsg) if err != nil { log.Printf("%v 读取到的消息Unpack error: %v\r\n", i_uuid, err) return } from_uuid := readC2CMsg.GetFromUuid() to_uuid := readC2CMsg.GetToUuid() txt_msg := readC2CMsg.GetTextMsg() timestamp := readC2CMsg.GetTimestamp() fmt.Println("from_uuid:", from_uuid) fmt.Println("to_uuid:", to_uuid) fmt.Println("txt_msg:", txt_msg) fmt.Println("timestamp:", convert.TimestampToTimeString(timestamp)) time.Sleep(5 * time.Second) // write writeC2CMsg := &pb.PbC2CTextChat{ FromUuid: proto.String(to_uuid), ToUuid: proto.String(from_uuid), TextMsg: proto.String(txt_msg + "我是 " + i_uuid), Timestamp: proto.Int64(timestamp), } err = handlers.SendPbData(conn, packet.PK_C2CTextChat, writeC2CMsg) if err != nil { log.Printf("%v 回复消息失败: %v\r\n", i_uuid, err) return } } }
func eventToPbEvent(event *Event) (*proto.Event, error) { var e proto.Event if event.Host == "" { event.Host, _ = os.Hostname() } t := reflect.ValueOf(&e).Elem() s := reflect.ValueOf(event).Elem() typeOfEvent := s.Type() for i := 0; i < s.NumField(); i++ { f := s.Field(i) value := reflect.ValueOf(f.Interface()) if reflect.Zero(f.Type()) != value && f.Interface() != nil { name := typeOfEvent.Field(i).Name switch name { case "State", "Service", "Host", "Description": tmp := reflect.ValueOf(pb.String(value.String())) t.FieldByName(name).Set(tmp) case "Ttl": tmp := reflect.ValueOf(pb.Float32(float32(value.Float()))) t.FieldByName(name).Set(tmp) case "Time": tmp := reflect.ValueOf(pb.Int64(value.Int())) t.FieldByName(name).Set(tmp) case "Tags": tmp := reflect.ValueOf(value.Interface().([]string)) t.FieldByName(name).Set(tmp) case "Metric": switch reflect.TypeOf(f.Interface()).Kind() { case reflect.Int: tmp := reflect.ValueOf(pb.Int64(int64(value.Int()))) t.FieldByName("MetricSint64").Set(tmp) case reflect.Int64: tmp := reflect.ValueOf(pb.Int64(value.Int())) t.FieldByName("MetricSint64").Set(tmp) case reflect.Float32: tmp := reflect.ValueOf(pb.Float32(float32(value.Float()))) t.FieldByName("MetricF").Set(tmp) case reflect.Float64: tmp := reflect.ValueOf(pb.Float64(value.Float())) t.FieldByName("MetricD").Set(tmp) default: return nil, fmt.Errorf("Metric of invalid type (type %v)", reflect.TypeOf(f.Interface()).Kind()) } case "Attributes": f := t.FieldByName(name) attrs := []*proto.Attribute{} for k, v := range value.Interface().(map[string]interface{}) { switch v.(type) { case string: attrs = append(attrs, &proto.Attribute{Key: pb.String(k), Value: pb.String(v.(string))}) case bool: attrs = append(attrs, &proto.Attribute{Key: pb.String(k)}) default: return nil, fmt.Errorf("Attribute value of invalid type (type %v)", reflect.TypeOf(v)) } } f.Set(reflect.ValueOf(attrs)) } } } return &e, nil }
// StateToProtocolBuffer converts a State type to a proto.State func StateToProtocolBuffer(state *State) (*proto.State, error) { if state.Host == "" { state.Host, _ = os.Hostname() } if state.Time == 0 { state.Time = time.Now().Unix() } var e proto.State t := reflect.ValueOf(&e).Elem() s := reflect.ValueOf(state).Elem() typeOfEvent := s.Type() for i := 0; i < s.NumField(); i++ { f := s.Field(i) value := reflect.ValueOf(f.Interface()) if reflect.Zero(f.Type()) != value && f.Interface() != nil { name := typeOfEvent.Field(i).Name switch name { case "State", "Service", "Host", "Description": tmp := reflect.ValueOf(pb.String(value.String())) t.FieldByName(name).Set(tmp) case "Once": tmp := reflect.ValueOf(pb.Bool(bool(value.Bool()))) t.FieldByName(name).Set(tmp) case "Ttl": tmp := reflect.ValueOf(pb.Float32(float32(value.Float()))) t.FieldByName(name).Set(tmp) case "Time": tmp := reflect.ValueOf(pb.Int64(value.Int())) t.FieldByName(name).Set(tmp) case "Tags": tmp := reflect.ValueOf(value.Interface().([]string)) t.FieldByName(name).Set(tmp) case "Metric": switch reflect.TypeOf(f.Interface()).Kind() { case reflect.Int: tmp := reflect.ValueOf(pb.Int64(int64(value.Int()))) t.FieldByName("MetricSint64").Set(tmp) case reflect.Float32: tmp := reflect.ValueOf(pb.Float32(float32(value.Float()))) t.FieldByName("MetricF").Set(tmp) case reflect.Float64: tmp := reflect.ValueOf(pb.Float64(value.Float())) t.FieldByName("MetricD").Set(tmp) default: return nil, fmt.Errorf("Metric of invalid type (type %v)", reflect.TypeOf(f.Interface()).Kind()) } case "Attributes": var attrs []*proto.Attribute for k, v := range value.Interface().(map[string]string) { k_, v_ := k, v attrs = append(attrs, &proto.Attribute{ Key: &k_, Value: &v_, }) } t.FieldByName(name).Set(reflect.ValueOf(attrs)) } } } return &e, nil }
// 模拟客户端(uuid) func testClient(uuid int) { defer func() { if e := recover(); e != nil { log.Printf("uuid: [%v] Panic: %v\r\n", getUuid(uuid), e) } }() // 连接服务器 tcpAddr, _ := net.ResolveTCPAddr("tcp4", config.Addr) conn, err := net.DialTCP("tcp", nil, tcpAddr) if err != nil { log.Printf("[%v] DialTCP失败: %v\r\n", getUuid(uuid), err) return } // 发送登陆请求 writeLoginMsg := &pb.PbClientLogin{ Uuid: proto.String(getUuid(uuid)), Version: proto.Float32(3.14), Timestamp: proto.Int64(time.Now().Unix()), } err = handlers.SendPbData(conn, packet.PK_ClientLogin, writeLoginMsg) if err != nil { log.Printf("[%v] 发送登陆包失败: %v\r\n", getUuid(uuid), err) return } // 下面这些处理和server.go中的一样 receivePackets := make(chan *packet.Packet, 100) // 接收到的包 chStop := make(chan bool) // 通知停止消息处理 defer func() { conn.Close() chStop <- true }() // 发送心跳包 go ping(conn) // 处理接受到的包 go handlePackets(uuid, conn, receivePackets, chStop) // 包长(4) + 类型(4) + 包体(len(pacData)) var ( bLen []byte = make([]byte, 4) bType []byte = make([]byte, 4) pacLen uint32 ) for { if n, err := io.ReadFull(conn, bLen); err != nil && n != 4 { log.Printf("Read pacLen failed: %v\r\n", err) return } if n, err := io.ReadFull(conn, bType); err != nil && n != 4 { log.Printf("Read pacType failed: %v\r\n", err) return } if pacLen = convert.BytesToUint32(bLen); pacLen > uint32(2048) { log.Printf("pacLen larger than maxPacLen\r\n") return } pacData := make([]byte, pacLen-8) if n, err := io.ReadFull(conn, pacData); err != nil && n != int(pacLen) { log.Printf("Read pacData failed: %v\r\n", err) return } receivePackets <- &packet.Packet{ Len: pacLen, Type: convert.BytesToUint32(bType), Data: pacData, } } }
func testBB(i_uuid string) { tcpAddr, _ := net.ResolveTCPAddr("tcp4", config.Addr) conn, err := net.DialTCP("tcp", nil, tcpAddr) if err != nil { log.Printf("%v DialTCP失败: %v\r\n", i_uuid, err) return } defer conn.Close() // 登陆 // write writeLoginMsg := &pb.PbClientLogin{ Uuid: proto.String(i_uuid), Version: proto.Float32(3.14), Timestamp: proto.Int64(time.Now().Unix()), } err = handlers.SendPbData(conn, packet.PK_ClientLogin, writeLoginMsg) if err != nil { log.Printf("%v 发送登陆包失败: %v\r\n", i_uuid, err) return } // read buf := make([]byte, 1024) n, err := conn.Read(buf) if err != nil { log.Printf("%v 登陆回应包读取失败: %v\r\n", i_uuid, err) return } pac := getPacFromBuf(buf, n) readAccepLoginMsg := &pb.PbServerAcceptLogin{} err = packet.Unpack(pac, readAccepLoginMsg) if err != nil { log.Printf("%v Unpack error: %v\r\n", i_uuid, err) return } fmt.Println(readAccepLoginMsg.GetLogin()) fmt.Println(readAccepLoginMsg.GetTipsMsg()) fmt.Println(convert.TimestampToTimeString(readAccepLoginMsg.GetTimestamp())) // 定时发送心跳包 go ping(conn) // 先向对方发送消息 // write go func() { writeC2CMsg := &pb.PbC2CTextChat{ FromUuid: proto.String(i_uuid), ToUuid: proto.String(u_uuid), TextMsg: proto.String("hi, 我的uuid是: " + i_uuid), Timestamp: proto.Int64(time.Now().Unix()), } err := handlers.SendPbData(conn, packet.PK_C2CTextChat, writeC2CMsg) if err != nil { log.Printf("%v 发送消息失败: %v\r\n", i_uuid, err) return } }() // 死循环,接收消息和发送消息 recBuf := make([]byte, 1024) for { fmt.Println("坐等消息到来...") // read n, err := conn.Read(recBuf) if err != nil { log.Printf("%v 读取消息失败: %v\r\n", i_uuid, err) return } fmt.Println("消息读取完毕") pac := getPacFromBuf(recBuf, n) readC2CMsg := &pb.PbC2CTextChat{} err = packet.Unpack(pac, readC2CMsg) if err != nil { log.Printf("%v 读取到的消息Unpack error: %v\r\n", i_uuid, err) return } from_uuid := readC2CMsg.GetFromUuid() to_uuid := readC2CMsg.GetToUuid() txt_msg := readC2CMsg.GetTextMsg() timestamp := readC2CMsg.GetTimestamp() fmt.Println("from_uuid:", from_uuid) fmt.Println("to_uuid:", to_uuid) fmt.Println("txt_msg:", txt_msg) fmt.Println("timestamp:", convert.TimestampToTimeString(timestamp)) time.Sleep(5 * time.Second) // write writeC2CMsg := &pb.PbC2CTextChat{ FromUuid: proto.String(to_uuid), ToUuid: proto.String(from_uuid), TextMsg: proto.String(txt_msg + "我是 " + i_uuid), Timestamp: proto.Int64(timestamp), } err = handlers.SendPbData(conn, packet.PK_C2CTextChat, writeC2CMsg) if err != nil { log.Printf("%v 回复消息失败: %v\r\n", i_uuid, err) return } } }