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
}
}
}