Example #1
0
func TestFakeSwitchCenter(t *testing.T) {
	printIndicate()

	groups := make(map[uint64]bool)
	groups[uint64(1)] = true
	groups[uint64(2)] = true
	groups[uint64(3)] = true

	fcenter := NewFakeSwitchCenter(groups)
	assert(nil != fcenter)

	for id, _ := range groups {
		fswitch := fcenter.Get(id)
		assert(nil != fswitch)
		assert(fswitch.id == id)
	}

	go fcenter.Run()
	defer fcenter.Stop()

	msg := pb.Message{From: 1, To: 2}
	fswitch := fcenter.Get(1)
	fswitch.GetSendChan() <- msg

	rmsg := <-fcenter.Get(2).GetRecvChan()
	assert(rmsg.From == 1)
	assert(rmsg.To == 2)

	msg.From = 3
	msg.To = 1
	fcenter.Get(3).GetSendChan() <- msg
	rmsg = <-fcenter.Get(1).GetRecvChan()
	assert(rmsg.From == 3)
	assert(rmsg.To == 1)
}
Example #2
0
func (sp *spaxos) doTryCatchUp(msg pb.Message) {
	assert(sp.id == msg.To)
	const catchUpStep = 10

	assert(sp.minIndex <= sp.maxIndex)
	for i := 0; i < catchUpStep; i++ {
		catchIndex := sp.minIndex + uint64(i+1)
		if catchIndex > sp.maxIndex {
			break
		}

		if _, ok := sp.insgroup[catchIndex]; ok {
			continue
		}

		// catchIndex don't have spaxos instance yet
		catchIns := sp.getSpaxosInstance(catchIndex)
		assert(nil != catchIns)
		// => create a new spaxos instance for catchIndex

		msg.Index = catchIndex
		catchIns.step(sp, msg)
	}
}
Example #3
0
func (sw *SSwitch) handleNetworkConnection(conn net.Conn) {

	defer conn.Close()

	reader := bufio.NewReader(conn)
	assert(nil != reader)
	for {
		//		err := conn.SetReadDeadline(time.Now().Add(2 * time.Millisecond))
		//		if nil != err {
		//			LogErr("%s conn.SetReadDeadline conn %s err %s",
		//				GetCurrentFuncName(), conn, err)
		//			return
		//		}

		var pkglen int
		var err error
		{
			var totalLen uint32
			err = binary.Read(reader, binary.BigEndian, &totalLen)
			if nil != err {
				LogErr("%s binary.Read err %s", GetCurrentFuncName(), err)
				return
			}
			pkglen = int(totalLen)
			assert(0 <= pkglen)
		}

		var pkg []byte
		for len(pkg) < pkglen {
			value := make([]byte, pkglen-len(pkg))
			readlen, err := reader.Read(value)
			if nil != err {
				LogErr("%s binary.Read pkglen %d err %s",
					GetCurrentFuncName(), pkglen, err)
				return
			}

			assert(0 < readlen)
			pkg = append(pkg, value...)
		}

		assert(pkglen == len(pkg))
		msg := pb.Message{}
		err = msg.Unmarshal(pkg)
		if nil != err {
			LogErr("%s pb.Message.Unmarshal err %s",
				GetCurrentFuncName(), err)
			return
		}

		if _, ok := sw.peers[msg.From]; !ok || sw.id != msg.To {
			LogDebug("%s ignore msg %v",
				GetCurrentFuncName(), msg)
			continue
		}

		LogDebug("net switch hostid %d recv msg (type %s) %v",
			sw.id, pb.MessageType_name[int32(msg.Type)], msg)
		// feed msg into node
		select {
		case sw.nrecvc <- msg:
		case <-sw.done:
			return
		}
	}
}