Beispiel #1
0
func TestRunBroadcastFive(t *testing.T) {
	c := make(chan Packet, 100)
	sentinel := Packet{Addr: "sentinel"}
	var r run
	r.seqn = 1
	r.out = c
	r.addr = []string{"v", "w", "x", "y", "z"}

	r.broadcast(newInvite(1))
	c <- sentinel

	exp := msg{
		Seqn: proto.Int64(1),
		Cmd:  invite,
		Crnd: proto.Int64(1),
	}

	addrs := make([]string, len(r.addr))
	for i := 0; i < len(r.addr); i++ {
		p := <-c
		addrs[i] = p.Addr
		var got msg
		err := proto.Unmarshal(p.Data, &got)
		assert.Equal(t, nil, err)
		assert.Equal(t, exp, got)
	}

	assert.Equal(t, sentinel, <-c)
	assert.Equal(t, r.addr, addrs)
}
Beispiel #2
0
func TestRunBroadcastThree(t *testing.T) {
	c := make(chan Packet, 100)
	sentinel := Packet{Addr: "sentinel"}
	var r run
	r.seqn = 1
	r.out = c
	r.addrs = map[string]bool{
		"x": true,
		"y": true,
		"z": true,
	}

	r.broadcast(newInvite(1))
	c <- sentinel

	exp := msg{
		Seqn: proto.Int64(1),
		Cmd:  invite,
		Crnd: proto.Int64(1),
	}

	addrs := map[string]bool{}
	for i := 0; i < len(r.addrs); i++ {
		p := <-c
		addrs[p.Addr] = true
		var got msg
		err := proto.Unmarshal(p.Data, &got)
		assert.Equal(t, nil, err)
		assert.Equal(t, exp, got)
	}

	assert.Equal(t, sentinel, <-c)
	assert.Equal(t, r.addrs, addrs)
}
Beispiel #3
0
func TestRunBroadcastFive(t *testing.T) {
	c := make(chan Packet, 100)
	var r run
	r.seqn = 1
	r.out = c
	r.addr = []*net.UDPAddr{
		&net.UDPAddr{net.IP{1, 2, 3, 4}, 5},
		&net.UDPAddr{net.IP{2, 3, 4, 5}, 6},
		&net.UDPAddr{net.IP{3, 4, 5, 6}, 7},
		&net.UDPAddr{net.IP{4, 5, 6, 7}, 8},
		&net.UDPAddr{net.IP{5, 6, 7, 8}, 9},
	}

	r.broadcast(newInvite(1))
	c <- Packet{}

	exp := msg{
		Seqn: proto.Int64(1),
		Cmd:  invite,
		Crnd: proto.Int64(1),
	}

	addr := make([]*net.UDPAddr, len(r.addr))
	for i := 0; i < len(r.addr); i++ {
		p := <-c
		addr[i] = p.Addr
		var got msg
		err := proto.Unmarshal(p.Data, &got)
		assert.Equal(t, nil, err)
		assert.Equal(t, exp, got)
	}

	assert.Equal(t, Packet{}, <-c)
	assert.Equal(t, r.addr, addr)
}
Beispiel #4
0
func TestRecvPacket(t *testing.T) {
	q := new(vector.Vector)

	recvPacket(q, Packet{"x", mustMarshal(&msg{Seqn: proto.Int64(1)})})
	recvPacket(q, Packet{"x", mustMarshal(&msg{Seqn: proto.Int64(2)})})
	recvPacket(q, Packet{"x", mustMarshal(&msg{Seqn: proto.Int64(3)})})

	assert.Equal(t, 3, q.Len())
}
Beispiel #5
0
func (*MyCalcService) Divide(req *CalcRequest, resp *CalcResponse) (err os.Error) {
	resp.Result = proto.Int64(0)
	defer func() {
		if x := recover(); x != nil {
			if ex, ok := x.(os.Error); ok {
				err = ex
			} else {
				err = os.ErrorString(fmt.Sprint(x))
			}
		}
	}()
	resp.Result = proto.Int64(proto.GetInt64(req.A) / proto.GetInt64(req.B))
	resp.Remainder = proto.Int64(proto.GetInt64(req.A) % proto.GetInt64(req.B))
	return
}
Beispiel #6
0
// chasing a moving target with exec here. currently it's kind of
// clumsy to pull out the return code. with luck the target will
// move again in a way i like.
func runPlugin(cmd, env []string, timeout int64) (result *CheckResult) {
	var output bytes.Buffer
	rc := 0
	log.Printf("running check %s", cmd)

	/* c := exec.Command(cmd[0], cmd...)*/
	c := exec.Command(cmd[0], cmd[1:]...)
	c.Stdout = &output
	starttime := time.Nanoseconds()
	err := c.Start()
	if err != nil {
		log.Fatal("Error running command ", cmd, ": ", err)
	}
	defer c.Process.Release()
	timer := time.AfterFunc(timeout, func() { c.Process.Kill() })
	err = c.Wait()
	timer.Stop()
	endtime := time.Nanoseconds()
	/* log.Print(msg)*/
	if err != nil {
		if msg, ok := err.(*os.Waitmsg); ok {
			rc = msg.ExitStatus()
		} else {
			log.Print("Error running command ", cmd, ": ", err)
		}
	}

	result = &CheckResult{
		StartTimestamp: proto.Int64(starttime),
		EndTimestamp:   proto.Int64(endtime),
		Status:         NewCheckStatus(CheckStatus(rc)),
		CheckPassive:   proto.Bool(*flagPassive),
	}
	switch rc {
	case 0, 1, 2, 3:
		// this is ok!
		log.Printf("%s: returned %s", cmd, CheckStatus_name[int32(rc)])
		result.Status = NewCheckStatus(CheckStatus(rc))
		result.CheckOutput = proto.String(string(bytes.TrimSpace(output.Bytes())))
		break
	default:
		// XXX check for timeout/sig9, presently assumed
		log.Printf("%s: return code %d", cmd, rc)
		result.Status = NewCheckStatus(CheckStatus_UNKNOWN)
		result.CheckOutput = proto.String(fmt.Sprintf("UNKNOWN: Command timed out after %d seconds\n", *flagCmdTimeout) + string(bytes.TrimSpace(output.Bytes())))
	}
	return result
}
Beispiel #7
0
func NewWavelet(url *WaveUrl) (result *Wavelet) {
	result = &Wavelet{Url: url}
	result.HashedVersion.HistoryHash = []byte(url.String())
	result.HashedVersion.Version = proto.Int64(0)
	result.Documents = make(map[string]*WaveletDocument)
	return result
}
Beispiel #8
0
func TestManagerTickQueue(t *testing.T) {
	ticker := make(chan int64)
	st := store.New()
	defer close(st.Ops)
	in := make(chan Packet)
	cfg := &Config{
		Alpha:  1,
		Store:  st,
		In:     in,
		Ticker: ticker,
		Out:    make(chan Packet, 100),
	}
	m := NewManager(cfg)
	st.Ops <- store.Op{
		Seqn: 1,
		Mut:  store.MustEncodeSet(node+"/a/addr", "x", 0),
	}
	for (<-m.Stats).Runs < 1 {
	}

	// get it to tick for seqn 2
	in <- Packet{Data: mustMarshal(&msg{Seqn: proto.Int64(2), Cmd: propose})}
	assert.Equal(t, 1, (<-m.Stats).WaitTicks)

	ticker <- time.Nanoseconds() + initialWaitBound*2
	assert.Equal(t, int64(1), (<-m.Stats).TotalTicks)
}
Beispiel #9
0
func TestManagerDeletesSuccessfulRun(t *testing.T) {
	st := store.New()
	defer close(st.Ops)
	in := make(chan Packet)
	out := make(chan Packet, 100)
	cfg := &Config{
		Alpha: 1,
		Store: st,
		In:    in,
		Out:   out,
		Ops:   st.Ops,
	}
	m := NewManager(cfg)

	st.Ops <- store.Op{
		Seqn: 1,
		Mut:  store.MustEncodeSet(node+"/a/addr", "x", 0),
	}
	for (<-m.Stats).TotalRuns < 1 {
	}

	in <- Packet{
		Data: mustMarshal(&msg{Seqn: proto.Int64(2), Cmd: learn, Value: []byte("foo")}),
		Addr: "127.0.0.1:9999",
	}
	for (<-m.Stats).TotalRuns < 2 {
	}
	assert.Equal(t, 1, (<-m.Stats).Runs)
}
Beispiel #10
0
// fetch fetches readBufferSize bytes starting at the given offset. On success,
// the data is saved as r.buf.
func (r *reader) fetch(off int64) error {
	req := &pb.FetchDataRequest{
		BlobKey:    proto.String(string(r.blobKey)),
		StartIndex: proto.Int64(off),
		EndIndex:   proto.Int64(off + readBufferSize - 1), // EndIndex is inclusive.
	}
	res := &pb.FetchDataResponse{}
	if err := r.c.Call("blobstore", "FetchData", req, res, nil); err != nil {
		return err
	}
	if len(res.Data) == 0 {
		return io.EOF
	}
	r.buf, r.r, r.off = res.Data, 0, off
	return nil
}
Beispiel #11
0
// UploadURL creates an upload URL for the form that the user will
// fill out, passing the application path to load when the POST of the
// form is completed. These URLs expire and should not be reused. The
// opts parameter may be nil.
func UploadURL(c appengine.Context, successPath string, opts *UploadURLOptions) (*url.URL, error) {
	req := &pb.CreateUploadURLRequest{
		SuccessPath: proto.String(successPath),
	}
	if opts != nil {
		if opts.MaxUploadBytes != 0 {
			req.MaxUploadSizeBytes = proto.Int64(opts.MaxUploadBytes)
		}
		if opts.MaxUploadBytesPerBlob != 0 {
			req.MaxUploadSizePerBlobBytes = proto.Int64(opts.MaxUploadBytesPerBlob)
		}
	}
	res := &pb.CreateUploadURLResponse{}
	if err := c.Call("blobstore", "CreateUploadURL", req, res, nil); err != nil {
		return nil, err
	}
	return url.Parse(*res.Url)
}
Beispiel #12
0
func TestManagerPacketQueue(t *testing.T) {
	in := make(chan Packet)

	st := store.New()
	out := make(chan Packet, 100)
	m := newManager("", 0, nil, in, nil, nil, nil, 0, st, out)

	in <- Packet{"x", mustMarshal(&msg{Seqn: proto.Int64(1)})}

	assert.Equal(t, 1, (<-m).WaitPackets)
}
Beispiel #13
0
func TestRunVoteDelivered(t *testing.T) {
	r := run{}
	r.out = make(chan Packet, 100)
	r.ops = make(chan store.Op, 100)
	r.l.init(1)

	p := packet{
		msg: msg{
			Seqn:  proto.Int64(1),
			Cmd:   vote,
			Vrnd:  proto.Int64(1),
			Value: []byte("foo"),
		},
		Addr: "X",
	}

	r.update(p, new(vector.Vector))

	assert.Equal(t, true, r.l.done)
	assert.Equal(t, "foo", r.l.v)
}
Beispiel #14
0
func TestRunSendsAcceptorPacket(t *testing.T) {
	c := make(chan Packet, 100)
	var r run
	r.out = c
	r.addr = []string{"x", "y"}

	var got msg
	exp := msg{
		Seqn: proto.Int64(0),
		Cmd:  rsvp,
		Crnd: proto.Int64(1),
		Vrnd: proto.Int64(0),
	}

	r.update(packet{msg: *newInviteSeqn1(1)}, new(vector.Vector))
	<-c
	err := proto.Unmarshal((<-c).Data, &got)
	assert.Equal(t, nil, err)
	assert.Equal(t, exp, got)
	assert.Equal(t, 0, len(c))
}
Beispiel #15
0
func TestRunSendsCoordPacket(t *testing.T) {
	c := make(chan Packet, 100)
	var r run
	r.c.crnd = 1
	r.out = c
	r.addr = []string{"x", "y"}

	var got msg
	exp := msg{
		Seqn: proto.Int64(0),
		Cmd:  invite,
		Crnd: proto.Int64(1),
	}

	r.update(packet{msg: *newPropose("foo")}, new(vector.Vector))
	<-c
	err := proto.Unmarshal((<-c).Data, &got)
	assert.Equal(t, nil, err)
	assert.Equal(t, exp, got)
	assert.Equal(t, 0, len(c))
}
Beispiel #16
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{
			&pb.OtherMessage{
				Key:   proto.Int64(0xdeadbeef),
				Value: []byte{1, 65, 7, 12},
			},
			&pb.OtherMessage{
				Weight: proto.Float32(6.022),
				Inner: &pb.InnerMessage{
					Host: proto.String("lesha.mtv"),
					Port: proto.Int32(8002),
				},
			},
		},
		Bikeshed: pb.NewMyMessage_Color(pb.MyMessage_BLUE),
		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)
	}

	// 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(104<<3|proto.WireBytes), b...)
	proto.SetRawExtension(msg, 104, b)

	// Extensions can be plain fields, too, so let's test that.
	b = append(proto.EncodeVarint(105<<3|proto.WireVarint), 19)
	proto.SetRawExtension(msg, 105, b)

	return msg
}
Beispiel #17
0
func TestRunVoteDelivered(t *testing.T) {
	r := run{}
	r.out = make(chan Packet, 100)
	r.ops = make(chan store.Op, 100)
	r.l.init(1, 1)

	p := packet{
		msg: msg{
			Seqn:  proto.Int64(1),
			Cmd:   vote,
			Vrnd:  proto.Int64(1),
			Value: []byte("foo"),
		},
		Addr: &net.UDPAddr{net.IP{1, 2, 3, 4}, 5},
	}

	r.update(&p, 0, new(triggers))

	assert.Equal(t, true, r.l.done)
	assert.Equal(t, "foo", r.l.v)
}
Beispiel #18
0
func (self *WaveletHistory) Range(startVersion int64, startHash []byte, endVersion int64, endHash []byte, limit int64) (result *ProtocolWaveletHistory, err os.Error) {
  // Error checking
  if startVersion < 0 || startVersion == int64(len(self.history)) {
	return nil, os.NewError("Invalid version number")
  }
  if endVersion < 1 || endVersion > int64(len(self.history)) {
	return nil, os.NewError("Invalid version number")
  }
  if endVersion <= startVersion {
	return nil, os.NewError("Invalid version number")
  }
	
  s := &ProtocolHashedVersion{Version:proto.Int64(startVersion), HistoryHash:startHash}
  e := &ProtocolHashedVersion{Version:proto.Int64(endVersion), HistoryHash:endHash}
  
  // Get the history
  mutations := self.history[startVersion:endVersion]
  if mutations[0] == nil || !mutations[0].HashedVersion.Equals(s) {
	return nil, os.NewError("Invalid hash or version")
  }
  if mutations[len(mutations)-1] == nil || mutations[len(mutations)-1].HistoryHash.Equals(e) {
	return nil, os.NewError("Invalid hash or version")
  }

  // Remove all items which are nil
  list := make([]*ProtocolWaveletDelta, 0, endVersion - startVersion)
  pos := 0
  for _, p := range mutations {
	if p == nil {
	  continue
	}
	list[pos] = p
	pos++
  }
  
  // TODO: Implement the limit
  result = &ProtocolWaveletHistory{}
  result.Deltas := list[:]
  return result, nil
}
// valueToProto converts a named value to a newly allocated Property.
// The returned error string is empty on success.
func valueToProto(defaultAppID, name string, v reflect.Value, multiple bool) (p *pb.Property, errStr string) {
	var (
		pv          pb.PropertyValue
		unsupported bool
	)
	switch v.Kind() {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		pv.Int64Value = proto.Int64(v.Int())
	case reflect.Bool:
		pv.BooleanValue = proto.Bool(v.Bool())
	case reflect.String:
		pv.StringValue = proto.String(v.String())
	case reflect.Float32, reflect.Float64:
		pv.DoubleValue = proto.Float64(v.Float())
	case reflect.Ptr:
		if k, ok := v.Interface().(*Key); ok {
			if k == nil {
				return nil, nilKeyErrStr
			}
			pv.Referencevalue = keyToReferenceValue(defaultAppID, k)
		} else {
			unsupported = true
		}
	case reflect.Slice:
		if b, ok := v.Interface().([]byte); ok {
			pv.StringValue = proto.String(string(b))
		} else {
			// nvToProto should already catch slice values.
			// If we get here, we have a slice of slice values.
			unsupported = true
		}
	default:
		unsupported = true
	}
	if unsupported {
		return nil, "unsupported datastore value type: " + v.Type().String()
	}
	p = &pb.Property{
		Name:     proto.String(name),
		Value:    &pv,
		Multiple: proto.Bool(multiple),
	}
	switch v.Interface().(type) {
	case []byte:
		p.Meaning = pb.NewProperty_Meaning(pb.Property_BLOB)
	case appengine.BlobKey:
		p.Meaning = pb.NewProperty_Meaning(pb.Property_BLOBKEY)
	case Time:
		p.Meaning = pb.NewProperty_Meaning(pb.Property_GD_WHEN)
	}
	return p, ""
}
Beispiel #20
0
func PrintLocationsAsProto(locations map[string]Location) []byte {
	locProto := &locationProto.LocationInfo{
		make([]*locationProto.Location, len(locations)), nil}
	loc := locProto.Location
	for name, location := range locations {
		loc[0] = &locationProto.Location{
			proto.String(name), proto.Float64(float64(location.lat)), proto.Float64(float64(location.lng)),
			nil, proto.Float64(float64(location.accuracy)), proto.Int64(location.timestamp), nil}
		loc = loc[1:]
	}
	data, _ := proto.Marshal(locProto)
	return data
}
Beispiel #21
0
func TestRunSendsAcceptorPacket(t *testing.T) {
	c := make(chan Packet, 100)
	x := &net.UDPAddr{net.IP{1, 2, 3, 4}, 5}
	y := &net.UDPAddr{net.IP{2, 3, 4, 5}, 6}
	var r run
	r.out = c
	r.addr = []*net.UDPAddr{x, y}

	var got msg
	exp := msg{
		Seqn: proto.Int64(0),
		Cmd:  rsvp,
		Crnd: proto.Int64(1),
		Vrnd: proto.Int64(0),
	}

	r.update(&packet{msg: *newInviteSeqn1(1)}, 0, new(vector.Vector))
	<-c
	err := proto.Unmarshal((<-c).Data, &got)
	assert.Equal(t, nil, err)
	assert.Equal(t, exp, got)
	assert.Equal(t, 0, len(c))
}
Beispiel #22
0
func TestRunReturnTrueIfLearned(t *testing.T) {
	r := run{}
	r.out = make(chan Packet, 100)
	r.ops = make(chan store.Op, 100)

	p := packet{msg: msg{
		Seqn:  proto.Int64(1),
		Cmd:   learn,
		Value: []byte("foo"),
	}}

	r.update(&p, 0, new(vector.Vector))
	assert.T(t, r.l.done)
}
Beispiel #23
0
// Add adds the task to a named queue.
// An empty queue name means that the default queue will be used.
// Add returns an equivalent Task with defaults filled in, including setting
// the task's Name field to the chosen name if the original was empty.
func Add(c appengine.Context, task *Task, queueName string) (*Task, error) {
	if queueName == "" {
		queueName = "default"
	}
	req := &taskqueue_proto.TaskQueueAddRequest{
		QueueName: []byte(queueName),
		TaskName:  []byte(task.Name),
		EtaUsec:   proto.Int64(time.Nanoseconds()/1e3 + task.Delay),
	}
	method := task.Method
	if method == "" {
		method = "POST"
	}
	if method == "PULL" {
		// Pull-based task
		req.Body = task.Payload
		req.Mode = taskqueue_proto.NewTaskQueueMode_Mode(taskqueue_proto.TaskQueueMode_PULL)
		// TODO: More fields will need to be set.
	} else {
		// HTTP-based task
		if v, ok := taskqueue_proto.TaskQueueAddRequest_RequestMethod_value[method]; ok {
			req.Method = taskqueue_proto.NewTaskQueueAddRequest_RequestMethod(
				taskqueue_proto.TaskQueueAddRequest_RequestMethod(v))
		} else {
			return nil, fmt.Errorf("taskqueue: bad method %q", method)
		}
		req.Url = []byte(task.Path)
		for k, vs := range task.Header {
			for _, v := range vs {
				req.Header = append(req.Header, &taskqueue_proto.TaskQueueAddRequest_Header{
					Key:   []byte(k),
					Value: []byte(v),
				})
			}
		}
		if method == "POST" || method == "PUT" {
			req.Body = task.Payload
		}
	}
	res := &taskqueue_proto.TaskQueueAddResponse{}
	if err := c.Call("taskqueue", "Add", req, res, nil); err != nil {
		return nil, err
	}
	resultTask := *task
	resultTask.Method = method
	if task.Name == "" {
		resultTask.Name = string(res.ChosenTaskName)
	}
	return &resultTask, nil
}
Beispiel #24
0
func TestManagerPumpDropsOldPackets(t *testing.T) {
	st := store.New()
	defer close(st.Ops)
	st.Ops <- store.Op{1, store.MustEncodeSet(node+"/a/addr", "x", 0)}
	st.Ops <- store.Op{2, store.MustEncodeSet("/ctl/cal/0", "a", 0)}

	var m Manager
	m.run = make(map[int64]*run)
	m.event(<-mustWait(st, 2))
	m.pump()
	recvPacket(&m.packet, Packet{"x", mustMarshal(&msg{Seqn: proto.Int64(1)})})
	m.pump()
	assert.Equal(t, 0, m.Stats.WaitPackets)
}
Beispiel #25
0
func TestRunSendsCoordPacket(t *testing.T) {
	c := make(chan Packet, 100)
	x := &net.UDPAddr{net.IP{1, 2, 3, 4}, 5}
	y := &net.UDPAddr{net.IP{2, 3, 4, 5}, 6}
	var r run
	r.c.crnd = 1
	r.out = c
	r.addr = []*net.UDPAddr{x, y}

	var got msg
	exp := msg{
		Seqn: proto.Int64(0),
		Cmd:  invite,
		Crnd: proto.Int64(1),
	}

	r.update(&packet{msg: *newPropose("foo")}, -1, new(triggers))
	<-c
	err := proto.Unmarshal((<-c).Data, &got)
	assert.Equal(t, nil, err)
	assert.Equal(t, exp, got)
	assert.Equal(t, 0, len(c))
}
Beispiel #26
0
func TestRunReturnFalseIfNotLearned(t *testing.T) {
	r := run{}
	r.out = make(chan Packet, 100)
	r.ops = make(chan store.Op, 100)

	p := packet{msg: msg{
		Seqn:  proto.Int64(1),
		Cmd:   invite,
		Value: []byte("foo"),
	}}

	r.update(&p, 0, new(triggers))
	assert.T(t, !r.l.done)
}
Beispiel #27
0
func TestApplyTriggers(t *testing.T) {
	packets := new(vector.Vector)
	triggers := new(vector.Vector)

	heap.Push(triggers, trigger{t: 1, n: 1})
	heap.Push(triggers, trigger{t: 2, n: 2})
	heap.Push(triggers, trigger{t: 3, n: 3})
	heap.Push(triggers, trigger{t: 4, n: 4})
	heap.Push(triggers, trigger{t: 5, n: 5})
	heap.Push(triggers, trigger{t: 6, n: 6})
	heap.Push(triggers, trigger{t: 7, n: 7})
	heap.Push(triggers, trigger{t: 8, n: 8})
	heap.Push(triggers, trigger{t: 9, n: 9})

	n := applyTriggers(packets, triggers, 5, &msg{Cmd: tick})
	assert.Equal(t, 5, n)

	expTriggers := new(vector.Vector)
	expPackets := new(vector.Vector)
	heap.Push(expPackets, &packet{msg: msg{Cmd: tick, Seqn: proto.Int64(1)}})
	heap.Push(expPackets, &packet{msg: msg{Cmd: tick, Seqn: proto.Int64(2)}})
	heap.Push(expPackets, &packet{msg: msg{Cmd: tick, Seqn: proto.Int64(3)}})
	heap.Push(expPackets, &packet{msg: msg{Cmd: tick, Seqn: proto.Int64(4)}})
	heap.Push(expPackets, &packet{msg: msg{Cmd: tick, Seqn: proto.Int64(5)}})
	heap.Push(expTriggers, trigger{t: 6, n: 6})
	heap.Push(expTriggers, trigger{t: 7, n: 7})
	heap.Push(expTriggers, trigger{t: 8, n: 8})
	heap.Push(expTriggers, trigger{t: 9, n: 9})

	sort.Sort(packets)
	sort.Sort(triggers)
	sort.Sort(expPackets)
	sort.Sort(expTriggers)

	assert.Equal(t, expTriggers, triggers)
	assert.Equal(t, expPackets, packets)
}
Beispiel #28
0
func TestManagerDropsOldPackets(t *testing.T) {
	runs := make(chan *run)
	defer close(runs)

	st := store.New()
	in := make(chan Packet)
	out := make(chan Packet, 100)
	m := newManager("", 0, nil, in, runs, nil, nil, 0, st, out)

	run := run{seqn: 2, ops: make(chan store.Op, 100)}
	runs <- &run

	in <- Packet{"x", mustMarshal(&msg{Seqn: proto.Int64(1)})}

	assert.Equal(t, 0, (<-m).WaitPackets)
}
Beispiel #29
0
func TestRunReturnFalseIfNotLearned(t *testing.T) {
	r := run{}
	r.out = make(chan Packet, 100)
	r.ops = make(chan store.Op, 100)

	p := packet{
		msg: msg{
			Seqn:  proto.Int64(1),
			Cmd:   invite,
			Value: []byte("foo"),
		},
		Addr: "X",
	}

	learned := r.update(p, new(vector.Vector))
	assert.T(t, !learned)
}
Beispiel #30
0
func createSubmit(version int64, hash []byte, doc string, docop *ProtocolDocumentOperation) []byte {
	submit := &ClientSubmitRequest{}
	delta := &ProtocolWaveletDelta{}
	delta.Author = proto.String("torben")
	delta.HashedVersion = &ProtocolHashedVersion{Version: proto.Int64(version), HistoryHash: hash}

	mut := &ProtocolWaveletOperation_MutateDocument{DocumentId: proto.String(doc), DocumentOperation: docop}
	op := &ProtocolWaveletOperation{MutateDocument: mut}

	delta.Operation = [...]*ProtocolWaveletOperation{op}[:]
	submit.Delta = delta

	var buffer bytes.Buffer
	Marshal(submit, &buffer)
	log.Println(buffer.String())
	return buffer.Bytes()
}