Esempio n. 1
0
// Test of gowebmsgpack.MsgpackFormatter.Format().
func TestFormatterFormat(t *testing.T) {

	// Create and regist formatter
	formatter := new(MsgpackFormatter)
	goweb.AddFormatter(formatter)

	// Create context
	r, _ := http.NewRequest("GET", "http://localhsot:8080", nil)
	w := httptest.NewRecorder()
	pathPrams := goweb.ParameterValueMap(make(map[string]string))
	cx := &goweb.Context{r, w, pathPrams, MSGPACK_FORMAT}

	data := []int{1, 2, 3}
	result := struct {
		C string
		S int
		D interface{}
		E []string
	}{
		"",
		http.StatusOK,
		data,
		nil,
	}
	expect, _ := msgpack.Marshal(result)
	cx.RespondWithData(data)
	actual := w.Body.Bytes()
	if !bytes.Equal(expect, actual) {
		t.Errorf("expect %v but actual %v.", expect, actual)
	}
}
Esempio n. 2
0
// Test of MsgpackRequestDecoder.Decode().
func TestDecoderDecode(t *testing.T) {

	expect := []int{1, 2, 3}
	body, _ := msgpack.Marshal(expect)

	// Create context
	r, _ := http.NewRequest("GET", "http://localhsot:8080", bytes.NewBuffer(body))
	w := httptest.NewRecorder()
	pathPrams := goweb.ParameterValueMap(make(map[string]string))
	cx := &goweb.Context{r, w, pathPrams, MSGPACK_FORMAT}

	// Create Decoder
	decoder := new(MsgpackRequestDecoder)

	var actual []int
	if err := decoder.Unmarshal(cx, &actual); err != nil {
		t.Error(err)
	}

	if len(expect) != len(actual) {
		t.Errorf("expect length of array is %d but actual is %d.", len(expect), len(actual))
	}

	for i := range expect {
		if expect[i] != actual[i] {
			t.Errorf("expect %dth element is %d but actual is %d", expect[i], actual[i])
			break
		}
	}
}
Esempio n. 3
0
func Publish(input chan []*FileEvent, server_list []string,
	server_timeout time.Duration) {
	var buffer bytes.Buffer
	//key := "abcdefghijklmnop"
	//cipher, err := aes.NewCipher([]byte(key))

	socket := FFS{
		Endpoints:   server_list,
		SocketType:  zmq.REQ,
		RecvTimeout: server_timeout,
		SendTimeout: server_timeout,
	}
	//defer socket.Close()

	for events := range input {
		// got a bunch of events, ship them out.
		log.Printf("Spooler gave me %d events\n", len(events))

		// Serialize with msgpack
		data, err := msgpack.Marshal(events)
		// TODO(sissel): chefk error
		_ = err
		//log.Printf("msgpack serialized %d bytes\n", len(data))

		// Compress it
		// A new compressor is used for every payload of events so
		// that any individual payload can be decompressed alone.
		// TODO(sissel): Make compression level tunable
		compressor, _ := zlib.NewWriterLevel(&buffer, 3)
		buffer.Truncate(0)
		_, err = compressor.Write(data)
		err = compressor.Flush()
		compressor.Close()
		//log.Printf("compressed %d bytes\n", buffer.Len())
		// TODO(sissel): check err

		// TODO(sissel): implement security/encryption/etc

		// Send full payload over zeromq REQ/REP
		// TODO(sissel): check error
		//buffer.Write(data)

		// Loop forever trying to send.
		// This will cause reconnects/etc on failures automatically
		for {
			err = socket.Send(buffer.Bytes(), 0)
			data, err = socket.Recv(0)
			if err == nil {
				// success!
				break
			}
		}
		// TODO(sissel): Check data value of reply?

		// TODO(sissel): retry on failure or timeout
		// TODO(sissel): notify registrar of success
	} /* for each event payload */
} // Publish
Esempio n. 4
0
// Readies response and converts input data into Msgpack.
func (f *MsgpackFormatter) Format(cx *goweb.Context, input interface{}) ([]uint8, error) {
	// marshal msgpack
	output, err := msgpack.Marshal(input)
	if err != nil {
		return nil, err
	}

	cx.ResponseWriter.Header().Set(CONTENT_TYPE, MSGPACK_CONTENT_TYPE)

	return output, nil
}
Esempio n. 5
0
func (t *MsgpackTest) BenchmarkStructMsgpack2(c *C) {
	in := t.structForBenchmark()
	out := &benchmarkStruct{}
	for i := 0; i < c.N; i++ {
		b, err := msgpack2.Marshal(in)
		if err != nil {
			panic(err)
		}
		err = msgpack2.Unmarshal(b, out, nil)
		if err != nil {
			panic(err)
		}
	}
}
Esempio n. 6
0
func BenchmarkStructUgorjiGoMsgpack(b *testing.B) {
	in := structForBenchmark()
	out := &benchmarkStruct{}
	for i := 0; i < b.N; i++ {
		buf, err := gomsgpack.Marshal(in)
		if err != nil {
			b.Fatal(err)
		}

		err = gomsgpack.Unmarshal(buf, out, nil)
		if err != nil {
			b.Fatal(err)
		}
	}
}
Esempio n. 7
0
// marshal into messagepack.
// This function is used for websocket.Codec.
func msgpackMarshal(v interface{}) (msg []byte, payloadType byte, err error) {
	msg, err = msgpack.Marshal(v)
	return msg, websocket.BinaryFrame, err
}