Ejemplo n.º 1
0
func main() {
	mh := codec.MsgpackHandle{}
	mh.MapType = reflect.TypeOf(map[string]interface{}(nil))
	buf := make([]byte, 10240)

	b := B{"hello", 3}
	msg_b := struct{ B B }{b}
	fmt.Printf("Send %#v\n", msg_b)

	enc := codec.NewEncoderBytes(&buf, &mh)
	err := enc.Encode(msg_b)
	if err != nil {
		log.Fatalf("Encode: %s", err)
	}

	var rcv interface{}
	dec := codec.NewDecoderBytes(buf, &mh)
	err = dec.Decode(&rcv)
	if err != nil {
		log.Fatalf("Decode: %s", err)
	}
	fmt.Printf("Raw Recv: %#v\n", rcv)

	var msg MSG
	dec = codec.NewDecoderBytes(buf, &mh)
	err = dec.Decode(&msg)
	if err != nil {
		log.Fatalf("Decode: %s", err)
	}
	fmt.Printf("Msg Recv: %#v\n", msg)
	fmt.Printf("Msg.A Recv: %#v\n", msg.A)
	fmt.Printf("Msg.B Recv: %#v\n", msg.B)
}
Ejemplo n.º 2
0
// Iterate over a key range, start inclusive, end exclusive. The value is always placed into
// the 'value' interface in order to allow typing. If fun returns an error the iteration is
// aborted.
func (db *DB) Iterate(from, to string, value interface{}, fun func(key string) error) error {
	slice := &dbutil.Range{[]byte(from), []byte(to)}
	if len(to) == 0 {
		slice.Limit = append(slice.Start, 0xFF)
	}

	glog.V(4).Infof("Iterating from %s to %s", string(slice.Start), string(slice.Limit))
	iter := db.ldb.NewIterator(slice, nil)
	defer iter.Release()

	for iter.Next() {
		glog.V(4).Infof("  Iter: %s=>%#v", string(iter.Key()), iter.Value())
		d := codec.NewDecoderBytes(iter.Value(), &mh)
		err := d.Decode(value)
		if err != nil {
			return err
		}
		err = fun(string(iter.Key()))
		if err != nil {
			return err
		}
	}
	glog.V(4).Infof("Done iterating from %s to %s", string(slice.Start), string(slice.Limit))
	return nil
}
Ejemplo n.º 3
0
// Get performs a key lookup in the store and returns the value. It handles decoding
// the value into the interface provided using msgPack.
func (db *DB) Get(key string, value interface{}) error {
	glog.V(3).Infoln("get", key)
	data, err := db.ldb.Get([]byte(key), nil)
	if err == leveldb.ErrNotFound {
		return ErrNotFound
	}
	if err != nil {
		return fmt.Errorf("database.Get key %s: %s", key, err.Error())
	}
	d := codec.NewDecoderBytes(data, &mh)
	err = d.Decode(value)
	if err != nil {
		return fmt.Errorf("database.Get decoding for key %s: %s", key, err.Error())
	}
	return nil
}
Ejemplo n.º 4
0
// Receive receives a message sent across the channel from
// a sender on the other side of the transport.
func (c *channel) Receive(message interface{}) error {
	if c.direction == outbound {
		return ErrWrongDirection
	}
	buf, readErr := c.stream.ReadData()
	if readErr != nil {
		if readErr == io.EOF {
			c.stream.Close()
		}
		return readErr
	}
	decoder := codec.NewDecoderBytes(buf, c.session.handler)
	decodeErr := decoder.Decode(message)
	if decodeErr != nil {
		return decodeErr
	}
	return nil
}