Example #1
0
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
}
Example #2
0
func TestNewID(t *testing.T) {
	guid := NewGuid()

	test = make(map[uint64]int)
	for i := 0; i < 1; i++ {
		go func() {
			//			id := guid.NewID(uint16(random.RandomInt31n(4095)))
			id := guid.NewID(1)
			//			fmt.Println(id)
			addID(id)
		}()
	}

	//	fmt.Println(int8(byte(128)))
	//	fmt.Println(uint8(byte(128)))

	//	var a []byte = make([]byte, 8)
	//	a[0] = 128
	//	a[1] = 128
	//	a[2] = 128
	//	a[3] = 128
	//	a[4] = 128
	//	a[5] = 128
	//	a[6] = 128
	//	a[7] = 128

	//	fmt.Println(binary.BigEndian.Uint64(a))

	//	b_buf := bytes.NewBuffer(a)
	//	var x int64
	//	binary.Read(b_buf, binary.BigEndian, &x)
	//	fmt.Println(x)

	fmt.Println(proto.EncodeVarint(322590098456576))
}
Example #3
0
func varint_encoder(L *lua.LState) int {
	l_value := L.CheckNumber(2)
	value := uint64(l_value)

	b := proto.EncodeVarint(value)

	L.SetTop(1)
	L.Push(lua.LString(string(b)))
	L.Call(1, 0)
	return 0
}
Example #4
0
func writeDelimitedBytes(conn *connection, data []byte) error {
	if _, err := conn.con.Write(proto.EncodeVarint(uint64(len(data)))); err != nil {
		log.Fatal("conn.con.Write(proto.EncodeVarint(uint64(len(data))))", err)
		return err
	}
	if _, err := conn.con.Write(data); err != nil {
		log.Fatal("conn.con.Write(data)", err)
		return err
	}

	return nil
}
Example #5
0
func signed_varint_encoder(L *lua.LState) int {
	l_value := L.CheckNumber(2)
	value := int64(l_value)

	var b []byte
	b = proto.EncodeVarint(uint64(value))

	L.SetTop(1)
	L.Push(lua.LString(string(b)))
	L.Call(1, 0)
	return 0
}
Example #6
0
// Writes a message to the underlying connection.
func (b *BaseConn) writeMsg(msg *baseproto.Message) error {
	msgBuffer, err := proto.Marshal(msg)
	if err != nil {
		log.Print("shared/connect: error marshalling msg ", err)
		return err
	}

	prefix := proto.EncodeVarint(uint64(len(msgBuffer)))
	_, err = b.conn.Write(prefix)
	if err != nil {
		return err
	}

	_, err = b.conn.Write(msgBuffer)
	return err
}
Example #7
0
// Sends the specified message and waits for a response
// This function blocks till it gets a response
// Each message gets a unique id and messages are prefixed with it's length
// encoded using protobuf'd varint format
func getResponse(conn net.Conn, message *Message) (*Message, error) {
	responseChan := make(chan *Message)
	messageId := getUniqueId()
	message.MessageId = &messageId
	pendingRequests[*message.MessageId] = responseChan

	data, err := proto.Marshal(message)
	if err != nil {
		delete(pendingRequests, *message.MessageId)
		return nil, err
	}
	data = append(proto.EncodeVarint(uint64(len(data))), data...)

	_, err = conn.Write(data)
	if err != nil {
		delete(pendingRequests, *message.MessageId)
		return nil, err
	}

	select {
	case response := <-responseChan:
		return response, nil
	}
}