예제 #1
0
파일: insert.go 프로젝트: kennylixi/btree
// Insert can insert record into a btree
func (t *Btree) insert(record TreeLog) error {
	tnode, err := t.getTreeNode(t.GetRoot())
	if err != nil {
		if err.Error() != "no data" {
			return err
		}
		nnode := t.newTreeNode()
		nnode.NodeType = proto.Int32(isLeaf)
		_, err = nnode.insertRecord(record, t)
		if err == nil {
			t.Nodes[nnode.GetId()], err = proto.Marshal(nnode)
		}
		t.Root = proto.Int64(nnode.GetId())
		return err
	}
	clonednode, err := tnode.insertRecord(record, t)
	if err == nil && len(clonednode.GetKeys()) > int(t.GetNodeMax()) {
		nnode := t.newTreeNode()
		nnode.NodeType = proto.Int32(isNode)
		key, left, right := clonednode.split(t)
		nnode.insertOnce(key, left, right, t)
		t.Nodes[nnode.GetId()], err = proto.Marshal(nnode)
		t.Root = proto.Int64(nnode.GetId())
	} else {
		t.Root = proto.Int64(clonednode.GetId())
	}
	return err
}
func TestParseSectionIntro_Valid(t *testing.T) {
	lines := []string{
		"10",
		"BUILDID",
		"NODEID 123 321 789",
		"12 23 34",
	}
	trace := Trace{}
	err := parseSectionIntro(lines, &trace)
	if err != nil {
		t.Fatal("Unexpected error:", err)
	}
	expectedTrace := Trace{
		FileFormatVersion: proto.Int32(10),
		BuildId:           proto.String("BUILDID"),
		NodeId:            proto.String("NODEID"),
		ProcessStartTimeMicroseconds: proto.Int64(123),
		SequenceNumber:               proto.Int32(321),
		TraceCreationTimestamp:       proto.Int64(789),
		PcapReceived:                 proto.Uint32(12),
		PcapDropped:                  proto.Uint32(23),
		InterfaceDropped:             proto.Uint32(34),
	}
	checkProtosEqual(t, &expectedTrace, &trace)
}
예제 #3
0
파일: datum.go 프로젝트: tstranex/carpcomm
func NewTimestampDatum(key string, timestamp int64, t time.Time) (
	d pb.TelemetryDatum) {
	d.Key = proto.String(key)
	d.Timestamp = proto.Int64(timestamp)
	d.UnixTimestamp = proto.Int64(t.Unix())
	return d
}
예제 #4
0
func TestRunBroadcastFive(t *testing.T) {
	c := make(chan Packet, 100)
	var r run
	r.seqn = 1
	r.out = c
	r.addr = []*net.UDPAddr{
		MustResolveUDPAddr("udp", "1.2.3.4:5"),
		MustResolveUDPAddr("udp", "2.3.4.5:6"),
		MustResolveUDPAddr("udp", "3.4.5.6:7"),
		MustResolveUDPAddr("udp", "4.5.6.7:8"),
		MustResolveUDPAddr("udp", "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)
}
func TestParseSectionPacketSeries_Valid(t *testing.T) {
	lines := []string{
		"10 11",
		"0 10 23",
		"20 12 45",
		"10 10 20",
	}
	trace := Trace{}
	err := parseSectionPacketSeries(lines, &trace)
	if err != nil {
		t.Fatal("Unexpected error:", err)
	}
	expectedTrace := Trace{
		PacketSeriesDropped: proto.Uint32(11),
		PacketSeries: []*PacketSeriesEntry{
			&PacketSeriesEntry{
				TimestampMicroseconds: proto.Int64(10),
				Size:   proto.Int32(10),
				FlowId: proto.Int32(23),
			},
			&PacketSeriesEntry{
				TimestampMicroseconds: proto.Int64(30),
				Size:   proto.Int32(12),
				FlowId: proto.Int32(45),
			},
			&PacketSeriesEntry{
				TimestampMicroseconds: proto.Int64(40),
				Size:   proto.Int32(10),
				FlowId: proto.Int32(20),
			},
		},
	}
	checkProtosEqual(t, &expectedTrace, &trace)
}
예제 #6
0
// UpdateBatch implements HighWatermarker.
func (w *LevelDBHighWatermarker) UpdateBatch(m FingerprintHighWatermarkMapping) error {
	batch := leveldb.NewBatch()
	defer batch.Close()

	for fp, t := range m {
		existing, present, err := w.Get(&fp)
		if err != nil {
			return err
		}
		k := &dto.Fingerprint{}
		dumpFingerprint(k, &fp)
		v := &dto.MetricHighWatermark{}
		if !present {
			v.Timestamp = proto.Int64(t.Unix())
			batch.Put(k, v)

			continue
		}

		// BUG(matt): Replace this with watermark management.
		if t.After(existing) {
			v.Timestamp = proto.Int64(t.Unix())
			batch.Put(k, v)
		}
	}

	return w.LevelDBPersistence.Commit(batch)
}
예제 #7
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)
}
예제 #8
0
파일: actor.go 프로젝트: zhaijian/tok
func (p *Actor) OnReceive(uid interface{}, data []byte) {
	m, err := kodec.Unboxing(data)
	if err != nil {
		log.Println("decode err ", err)
		return
	}

	switch v := m.(type) {
	case *kodec.Msg:
		v.From = proto.Int64(int64(uid.(int)))
		v.Ct = proto.Int64(tick())

		if v.GetTp() != kodec.Msg_SYS {
			from := int(v.GetFrom())
			to := v.GetTo()
			if !p.checker.CheckUp(from, to) {
				log.Println(fmt.Errorf("warning: chat not allow, %d -> %v \n", from, to))
				return
			}
		}
		p.dispatchMsg(v)
	default:
		log.Println(fmt.Errorf("unknown data frame"))
	}
}
예제 #9
0
파일: scuttlebutt.go 프로젝트: hujh/gossip
func (g *Gossiper) scuttlebutt(id string, reqd []*Digest) ([]*Digest, []*Delta) {
	digests := make([]*Digest, 0)
	deltas := make([]*Delta, 0)

	for _, d := range reqd {
		p := g.peers[d.GetId()]

		if p == nil {
			digests = append(digests, &Digest{
				Id:      proto.String(d.GetId()),
				Gen:     proto.Int64(0),
				Version: proto.Int64(0),
			})
		} else {
			cr := p.compare(d.GetGen(), d.GetVersion())
			switch {
			case cr > 0:
				deltas = append(deltas, g.deltaAfterVersion(p, d.GetVersion()))
			case cr < 0:
				digests = append(digests, &Digest{
					Id:      proto.String(p.id),
					Gen:     proto.Int64(p.gen),
					Version: proto.Int64(p.version),
				})
			}
		}
	}

	return digests, deltas
}
func BenchmarkRegressionSplitter(b *testing.B) {
	flag.Parse()

	forestConfig := &pb.ForestConfig{
		NumWeakLearners: proto.Int64(int64(*numTrees)),
		SplittingConstraints: &pb.SplittingConstraints{
			MaximumLevels: proto.Int64(int64(*numLevels)),
		},
		LossFunctionConfig: &pb.LossFunctionConfig{
			LossFunction: pb.LossFunction_LOGIT.Enum(),
		},
		Algorithm: pb.Algorithm_BOOSTING.Enum(),
	}

	glog.Info(forestConfig.String())

	generator, err := NewForestGenerator(forestConfig)
	if err != nil {
		glog.Fatal(err)
	}
	examples := constructBenchmarkExamples(b.N, *numFeatures, 0)
	glog.Infof("Starting with %v examples", len(examples))

	b.ResetTimer()
	forest := generator.ConstructForest(examples)
	res, err := json.MarshalIndent(forest, "", "  ")
	if err != nil {
		glog.Fatalf("Error: %v", err)
	}
	glog.Info(res)
}
func ExampleBytesPerDevice_multipleSessions() {
	trace1 := Trace{
		PacketSeries: []*PacketSeriesEntry{
			&PacketSeriesEntry{
				TimestampMicroseconds: proto.Int64(0),
				Size:   proto.Int32(10),
				FlowId: proto.Int32(4),
			},
		},
		FlowTableEntry: []*FlowTableEntry{
			&FlowTableEntry{
				FlowId:   proto.Int32(4),
				SourceIp: proto.String("1.2.3.4"),
			},
		},
		AddressTableEntry: []*AddressTableEntry{
			&AddressTableEntry{
				IpAddress:  proto.String("1.2.3.4"),
				MacAddress: proto.String("AABBCCDDEEFF"),
			},
		},
	}
	trace2 := Trace{
		PacketSeries: []*PacketSeriesEntry{
			&PacketSeriesEntry{
				TimestampMicroseconds: proto.Int64(0),
				Size:   proto.Int32(13),
				FlowId: proto.Int32(4),
			},
		},
	}
	trace3 := Trace{
		PacketSeries: []*PacketSeriesEntry{
			&PacketSeriesEntry{
				TimestampMicroseconds: proto.Int64(0),
				Size:   proto.Int32(20),
				FlowId: proto.Int32(4),
			},
		},
	}
	consistentRanges := []*store.Record{
		&store.Record{
			Key:   lex.EncodeOrDie("node0", "anon0", int64(0), int32(0)),
			Value: lex.EncodeOrDie("node0", "anon0", int64(0), int32(2)),
		},
	}
	firstRecords := map[string]Trace{
		string(lex.EncodeOrDie("node0", "anon0", int64(0), int32(0))): trace1,
	}
	secondRecords := map[string]Trace{
		string(lex.EncodeOrDie("node0", "anon0", int64(0), int32(1))): trace2,
		string(lex.EncodeOrDie("node0", "anon0", int64(0), int32(2))): trace3,
	}
	runBytesPerDevicePipeline(consistentRanges, firstRecords, secondRecords)

	// Output:
	// node0,AABBCCDDEEFF,0: 43
}
func ExampleBytesPerDevice_macBoundAtStartOfFlow() {
	trace1 := Trace{
		PacketSeries: []*PacketSeriesEntry{
			&PacketSeriesEntry{
				TimestampMicroseconds: proto.Int64(0),
				Size:   proto.Int32(10),
				FlowId: proto.Int32(4),
			},
		},
		FlowTableEntry: []*FlowTableEntry{
			&FlowTableEntry{
				FlowId:        proto.Int32(4),
				SourceIp:      proto.String("1.2.3.4"),
				DestinationIp: proto.String("4.3.2.1"),
			},
		},
		AddressTableEntry: []*AddressTableEntry{
			&AddressTableEntry{
				IpAddress:  proto.String("1.2.3.4"),
				MacAddress: proto.String("AABBCCDDEEFF"),
			},
		},
	}
	trace2 := Trace{
		PacketSeries: []*PacketSeriesEntry{
			&PacketSeriesEntry{
				TimestampMicroseconds: proto.Int64(0),
				Size:   proto.Int32(12),
				FlowId: proto.Int32(4),
			},
		},
		AddressTableEntry: []*AddressTableEntry{
			&AddressTableEntry{
				IpAddress:  proto.String("1.2.3.4"),
				MacAddress: proto.String("FFEEDDCCBBAA"),
			},
		},
	}
	consistentRanges := []*store.Record{
		&store.Record{
			Key:   lex.EncodeOrDie("node0", "anon0", int64(0), int32(0)),
			Value: lex.EncodeOrDie("node0", "anon0", int64(0), int32(1)),
		},
	}
	records := map[string]Trace{
		string(lex.EncodeOrDie("node0", "anon0", int64(0), int32(0))): trace1,
		string(lex.EncodeOrDie("node0", "anon0", int64(0), int32(1))): trace2,
	}
	runBytesPerDevicePipeline(consistentRanges, records)

	// Output:
	// node0,AABBCCDDEEFF,0: 22
}
예제 #13
0
func (c curationState) Get() (key, value coding.Encoder) {
	key = coding.NewProtocolBuffer(&dto.CurationKey{
		Fingerprint:      model.NewFingerprintFromRowKey(c.fingerprint).ToDTO(),
		MinimumGroupSize: proto.Uint32(uint32(c.groupSize)),
		OlderThan:        proto.Int64(int64(c.recencyThreshold)),
	})

	value = coding.NewProtocolBuffer(&dto.CurationValue{
		LastCompletionTimestamp: proto.Int64(c.lastCurated.Unix()),
	})

	return
}
예제 #14
0
func createmessage() []byte {
	ProtoMessage := new(msgproto.Msg)
	ProtoMessage.Id = proto.Int32(12344)
	ProtoMessage.Lat = proto.Int64(12344)
	ProtoMessage.Long = proto.Int64(12344)
	ProtoMessage.Utime = proto.Int64(int64(time.Now().Unix()))
	data, err := proto.Marshal(ProtoMessage)
	if err != nil {
		fmt.Println(err)
	}
	return data

}
func runAvailabilityPipelineAugmented(startTimestamp int64, timestamps map[string]int64, moreTimestamps map[string]int64) {
	levelDbManager := store.NewSliceManager()

	tracesStore := levelDbManager.Writer("traces")
	tracesStore.BeginWriting()
	for encodedKey, timestamp := range timestamps {
		trace := Trace{
			TraceCreationTimestamp: proto.Int64(timestamp),
		}
		encodedTrace, err := proto.Marshal(&trace)
		if err != nil {
			panic(fmt.Errorf("Error encoding protocol buffer: %v", err))
		}
		tracesStore.WriteRecord(&store.Record{Key: []byte(encodedKey), Value: encodedTrace})
	}
	tracesStore.EndWriting()

	writer := bytes.NewBuffer([]byte{})
	transformer.RunPipeline(AvailabilityPipeline(levelDbManager, writer, startTimestamp))

	tracesStore.BeginWriting()
	for encodedKey, timestamp := range moreTimestamps {
		trace := Trace{
			TraceCreationTimestamp: proto.Int64(timestamp),
		}
		encodedTrace, err := proto.Marshal(&trace)
		if err != nil {
			panic(fmt.Errorf("Error encoding protocol buffer: %v", err))
		}
		tracesStore.WriteRecord(&store.Record{Key: []byte(encodedKey), Value: encodedTrace})
	}
	tracesStore.EndWriting()

	anotherTracesSlice := make([]*store.Record, 0)
	for encodedKey, timestamp := range moreTimestamps {
		trace := Trace{
			TraceCreationTimestamp: proto.Int64(timestamp),
		}
		encodedTrace, err := proto.Marshal(&trace)
		if err != nil {
			panic(fmt.Errorf("Error encoding protocol buffer: %v", err))
		}
		anotherTracesSlice = append(anotherTracesSlice, &store.Record{Key: []byte(encodedKey), Value: encodedTrace})
	}

	anotherWriter := bytes.NewBuffer([]byte{})
	transformer.RunPipeline(AvailabilityPipeline(levelDbManager, anotherWriter, startTimestamp))
	fmt.Printf("%s", anotherWriter.Bytes())
}
예제 #16
0
func (m *MyCalcService) Divide(req *CalcRequest, resp *CalcResponse) (err error) {
	resp.Result = proto.Int64(0)
	defer func() {
		if x := recover(); x != nil {
			if ex, ok := x.(error); ok {
				err = ex
			} else {
				err = errors.New(fmt.Sprint(x))
			}
		}
	}()
	resp.Result = proto.Int64((*req.A) / (*req.B))
	resp.Remainder = proto.Int64((*req.A) % (*req.B))
	return
}
예제 #17
0
파일: data.go 프로젝트: DrGo/samay
func (project *Project) CreateEntryWithDuration(
	content string,
	duration time.Duration,
	billable bool) *Entry {

	e := project.CreateEntry(content, billable)
	endTime := time.Now()
	startTime := endTime.Add(-duration)

	e.Started = proto.Int64(startTime.Unix())
	e.Ended = proto.Int64(endTime.Unix())
	e.Duration = proto.Int64(duration.Nanoseconds())

	return e
}
예제 #18
0
파일: raidman.go 프로젝트: nelhage/raidman
func eventToPbEvent(event *Event) (*proto.Event, error) {
	var e proto.Event

	if event.Host == "" {
		event.Host, _ = os.Hostname()
	}
	t := reflect.ValueOf(&e).Elem()
	s := reflect.ValueOf(event).Elem()
	typeOfEvent := s.Type()
	for i := 0; i < s.NumField(); i++ {
		f := s.Field(i)
		value := reflect.ValueOf(f.Interface())
		if reflect.Zero(f.Type()) != value && f.Interface() != nil {
			name := typeOfEvent.Field(i).Name
			switch name {
			case "State", "Service", "Host", "Description":
				tmp := reflect.ValueOf(pb.String(value.String()))
				t.FieldByName(name).Set(tmp)
			case "Ttl":
				tmp := reflect.ValueOf(pb.Float32(float32(value.Float())))
				t.FieldByName(name).Set(tmp)
			case "Time":
				tmp := reflect.ValueOf(pb.Int64(value.Int()))
				t.FieldByName(name).Set(tmp)
			case "Tags":
				tmp := reflect.ValueOf(value.Interface().([]string))
				t.FieldByName(name).Set(tmp)
			case "Metric":
				switch reflect.TypeOf(f.Interface()).Kind() {
				case reflect.Int:
					tmp := reflect.ValueOf(pb.Int64(int64(value.Int())))
					t.FieldByName("MetricSint64").Set(tmp)
				case reflect.Float32:
					tmp := reflect.ValueOf(pb.Float32(float32(value.Float())))
					t.FieldByName("MetricF").Set(tmp)
				case reflect.Float64:
					tmp := reflect.ValueOf(pb.Float64(value.Float()))
					t.FieldByName("MetricD").Set(tmp)
				default:
					return nil, fmt.Errorf("Metric of invalid type (type %v)",
						reflect.TypeOf(f.Interface()).Kind())
				}
			}
		}
	}

	return &e, nil
}
예제 #19
0
파일: key.go 프로젝트: yschu7/go_test
// AllocateIDs returns a range of n integer IDs with the given kind and parent
// combination. kind cannot be empty; parent may be nil. The IDs in the range
// returned will not be used by the datastore's automatic ID sequence generator
// and may be used with NewKey without conflict.
//
// The range is inclusive at the low end and exclusive at the high end. In
// other words, valid intIDs x satisfy low <= x && x < high.
//
// If no error is returned, low + n == high.
func AllocateIDs(c appengine.Context, kind string, parent *Key, n int) (low, high int64, err error) {
	if kind == "" {
		return 0, 0, errors.New("datastore: AllocateIDs given an empty kind")
	}
	if n < 0 {
		return 0, 0, fmt.Errorf("datastore: AllocateIDs given a negative count: %d", n)
	}
	if n == 0 {
		return 0, 0, nil
	}
	req := &pb.AllocateIdsRequest{
		ModelKey: keyToProto("", NewIncompleteKey(c, kind, parent)),
		Size:     proto.Int64(int64(n)),
	}
	res := &pb.AllocateIdsResponse{}
	if err := c.Call("datastore_v3", "AllocateIds", req, res, nil); err != nil {
		return 0, 0, err
	}
	// The protobuf is inclusive at both ends. Idiomatic Go (e.g. slices, for loops)
	// is inclusive at the low end and exclusive at the high end, so we add 1.
	low = res.GetStart()
	high = res.GetEnd() + 1
	if low+int64(n) != high {
		return 0, 0, fmt.Errorf("datastore: internal error: could not allocate %d IDs", n)
	}
	return low, high, nil
}
예제 #20
0
파일: taskqueue.go 프로젝트: LeXa4894/test
func lease(c appengine.Context, maxTasks int, queueName string, leaseTime int, groupByTag bool, tag []byte) ([]*Task, error) {
	req := &taskqueue_proto.TaskQueueQueryAndOwnTasksRequest{
		QueueName:    []byte(queueName),
		LeaseSeconds: proto.Float64(float64(leaseTime)),
		MaxTasks:     proto.Int64(int64(maxTasks)),
		GroupByTag:   proto.Bool(groupByTag),
		Tag:          tag,
	}
	res := &taskqueue_proto.TaskQueueQueryAndOwnTasksResponse{}
	callOpts := &appengine_internal.CallOptions{
		Timeout: 10 * time.Second,
	}
	if err := c.Call("taskqueue", "QueryAndOwnTasks", req, res, callOpts); err != nil {
		return nil, err
	}
	tasks := make([]*Task, len(res.Task))
	for i, t := range res.Task {
		tasks[i] = &Task{
			Payload:    t.Body,
			Name:       string(t.TaskName),
			Method:     "PULL",
			ETA:        time.Unix(0, *t.EtaUsec*1e3),
			RetryCount: *t.RetryCount,
			Tag:        string(t.Tag),
		}
	}
	return tasks, nil
}
예제 #21
0
// 客户端申请建立讨论组
func HandleClientBuildGroup(conn *net.TCPConn, recPacket *packet.Packet) {
	// read
	readMsg := &pb.PbClientBuildGroup{}
	packet.Unpack(recPacket, readMsg)
	uuid := ConnMapUuid.Get(conn).(string)
	group_name := readMsg.GetGroupName()

	// 建立讨论组
	ret, group_id := groupinfo.BuildGroup(group_name, uuid)
	tips_msg := "讨论组[" + group_name + "]建立成功"
	if ret {
		tips_msg = "讨论组[" + group_name + "]建立失败"
	}

	// write
	writeMsg := &pb.PbServerNotifyBuildGroup{
		Build:     proto.Bool(ret),
		GroupId:   proto.String(group_id),
		GroupName: proto.String(group_name),
		OwnerUuid: proto.String(uuid),
		TipsMsg:   proto.String(tips_msg),
		Timestamp: proto.Int64(time.Now().Unix()),
	}
	SendPbData(conn, packet.PK_ServerNotifyBuildGroup, writeMsg)
}
예제 #22
0
func TestManagerPacketProcessing(t *testing.T) {
	st := store.New()
	defer close(st.Ops)
	in := make(chan Packet)
	out := make(chan Packet, 100)
	var m Manager
	m.run = make(map[int64]*run)
	m.Alpha = 1
	m.Store = st
	m.In = in
	m.Out = out
	m.Ops = st.Ops

	st.Ops <- store.Op{1, store.MustEncodeSet(node+"/a/addr", "1.2.3.4:5", 0)}
	st.Ops <- store.Op{2, store.MustEncodeSet("/ctl/cal/0", "a", 0)}
	m.event(<-mustWait(st, 2))

	addr, _ := net.ResolveUDPAddr("udp", "127.0.0.1:9999")
	recvPacket(&m.packet, Packet{
		Data: mustMarshal(&msg{Seqn: proto.Int64(2), Cmd: learn, Value: []byte("foo")}),
		Addr: addr,
	})
	m.pump()
	assert.Equal(t, 0, m.packet.Len())
}
예제 #23
0
파일: btree.go 프로젝트: kennylixi/btree
func (t *Btree) run() {
	tick := time.Tick(time.Second * 2)
	for {
		select {
		case <-t.exitChan:
			break
		case op := <-t.opChan:
			switch op.GetAction() {
			case "insert":
				op.errChan <- t.insert(op.TreeLog)
			case "delete":
				op.errChan <- t.dodelete(op.Key)
			case "update":
				op.errChan <- t.update(op.TreeLog)
			case "search":
				rst, err := t.search(op.Key)
				op.valueChan <- rst
				op.errChan <- err
			}
			t.Index = proto.Int64(t.GetIndexCursor())
		case <-tick:
			t.gc()
		}
	}
	t.Marshal("treedump.tmp")
}
예제 #24
0
파일: btree.go 프로젝트: kennylixi/btree
// NewBtreeSize create new btree with custom leafsize/nodesize
func NewBtreeSize(leafsize int64, nodesize int64) *Btree {
	tree := &Btree{
		dupnodelist: make(map[int64]int),
		opChan:      make(chan *treeOperation),
		BtreeMetadata: BtreeMetadata{
			Root:        proto.Int64(0),
			Size:        proto.Int64(TreeSize),
			LeafMax:     proto.Int64(leafsize),
			NodeMax:     proto.Int64(nodesize),
			IndexCursor: proto.Int64(0),
			Nodes:       make([][]byte, TreeSize),
		},
	}
	go tree.run()
	return tree
}
예제 #25
0
// 客户端申请加入讨论组
func HandleClientJoinGroup(conn *net.TCPConn, recPacket *packet.Packet) {
	// read
	readMsg := &pb.PbClientJoinGroup{}
	packet.Unpack(recPacket, readMsg)

	from_uuid := readMsg.GetFromUuid()
	group_id := readMsg.GetGroupId()
	// note_msg := readMsg.GetNoteMsg()
	// timestamp := readMsg.GetTimestamp()

	// 加入讨论组
	if ret := groupinfo.JoinGroup(from_uuid, group_id); !ret {
		return
	}

	group_name, _ := groupinfo.GetGroupNameAndOwner(group_id)

	// write
	writeMsg := pb.PbServerNotifyJoinGroup{
		ApplicantUuid: proto.String(from_uuid),
		GroupId:       proto.String(group_id),
		GroupName:     proto.String(group_name),
		Timestamp:     proto.Int64(time.Now().Unix()),
	}

	// 通知所有组员,这个消息不离线存储
	group_members := groupinfo.GetAllUuid(group_id)
	for i := 1; i < len(group_members); i++ {
		SendPbData(UuidMapConn.Get(group_members[i]).(*net.TCPConn), packet.PK_ServerNotifyJoinGroup, writeMsg)
	}
}
예제 #26
0
파일: freeze.go 프로젝트: rok-kek/grumble
// Given a target channel and a ChannelState protocol message, create a freezer.Channel that
// only includes the values changed by the given ChannelState message.  When done, write that
// frozen.Channel to the datastore.
func (server *Server) UpdateFrozenChannel(channel *Channel, state *mumbleproto.ChannelState) {
	fc := &freezer.Channel{}
	fc.Id = proto.Uint32(uint32(channel.Id))
	if state.Name != nil {
		fc.Name = state.Name
	}
	if state.Parent != nil {
		fc.ParentId = state.Parent
	}
	if len(state.LinksAdd) > 0 || len(state.LinksRemove) > 0 {
		links := []uint32{}
		for cid, _ := range channel.Links {
			links = append(links, uint32(cid))
		}
		fc.Links = links
	}
	if state.Position != nil {
		fc.Position = proto.Int64(int64(*state.Position))
	}
	if len(state.DescriptionHash) > 0 {
		fc.DescriptionBlob = proto.String(channel.DescriptionBlob)
	}
	err := server.freezelog.Put(fc)
	if err != nil {
		server.Fatal(err)
	}
	server.numLogOps += 1
}
예제 #27
0
// 客户端请求获取讨论组信息
func HandleClientRequestGroupInfo(conn *net.TCPConn, recPacket *packet.Packet) {
	readMsg := &pb.PbClientRequestGroupInfo{}
	packet.Unpack(recPacket, readMsg)

	uuid := readMsg.GetFromUuid()
	// timestamp := readMsg.GetTimestamp()

	groupids := groupinfo.GetAllGroup(uuid)

	var allGroupInfo []*pb.PbGroupInfo

	for _, group_id := range groupids {
		s := groupinfo.GetAllUuid(group_id)
		group_name, owner_uuid, member_uuid := s[0], s[1], s[2:]

		gi := &pb.PbGroupInfo{
			GroupId:    proto.String(group_id),
			GroupName:  proto.String(group_name),
			OwnerUuid:  proto.String(owner_uuid),
			MemberUuid: member_uuid,
		}

		allGroupInfo = append(allGroupInfo, gi)
	}

	// write
	writeMsg := &pb.PbServerResponseGroupInfo{
		FromUuid:     proto.String(uuid),
		AllGroupInfo: allGroupInfo,
		Timestamp:    proto.Int64(time.Now().Unix()),
	}
	SendPbData(conn, packet.PK_ServerResponseGroupInfo, writeMsg)
}
예제 #28
0
파일: client.go 프로젝트: jwilkins/pond
// usageString returns a description of the amount of space taken up by a body
// with the given contents and a bool indicating overflow.
func (draft *Draft) usageString() (string, bool) {
	var replyToId *uint64
	if draft.inReplyTo != 0 {
		replyToId = proto.Uint64(1)
	}
	var dhPub [32]byte

	msg := &pond.Message{
		Id:               proto.Uint64(0),
		Time:             proto.Int64(1 << 62),
		Body:             []byte(draft.body),
		BodyEncoding:     pond.Message_RAW.Enum(),
		InReplyTo:        replyToId,
		MyNextDh:         dhPub[:],
		Files:            draft.attachments,
		DetachedFiles:    draft.detachments,
		SupportedVersion: proto.Int32(protoVersion),
	}

	serialized, err := proto.Marshal(msg)
	if err != nil {
		panic("error while serialising candidate Message: " + err.Error())
	}

	s := fmt.Sprintf("%d of %d bytes", len(serialized), pond.MaxSerializedMessage)
	return s, len(serialized) > pond.MaxSerializedMessage
}
예제 #29
0
// 客户端(群主)申请解散讨论组
func HandleClientDisbandGroup(conn *net.TCPConn, recPacket *packet.Packet) {
	// read
	readMsg := &pb.PbClientDisbandGroup{}
	packet.Unpack(recPacket, readMsg)
	from_id := readMsg.GetFromUuid()
	group_id := readMsg.GetGroupId()
	// timestamp := readMsg.GetTimestamp()

	// 验证from_id确实是该conn,并且是group_id的群主
	group_name, group_owner := groupinfo.GetGroupNameAndOwner(group_id)
	if from_id != ConnMapUuid.Get(conn).(string) || group_owner != from_id {
		CloseConn(conn)
		return
	}

	// 解散讨论组
	ret := groupinfo.DisbandGroup(from_id, group_id)
	tips_msg := "解散讨论组[" + group_name + "]成功"
	if ret {
		tips_msg = "解散讨论组[" + group_name + "]失败"
	}

	// write
	writeMsg := &pb.PbServerNotifyDisbandGroup{
		Disband:   proto.Bool(ret),
		GroupId:   proto.String(group_id),
		GroupName: proto.String(group_name),
		TipsMsg:   proto.String(tips_msg),
		Timestamp: proto.Int64(time.Now().Unix()),
	}
	SendPbData(conn, packet.PK_ServerNotifyDisbandGroup, writeMsg)
}
예제 #30
0
파일: handler.go 프로젝트: WaylandGod/gotcp
func HandleChatMsg(conn *net.TCPConn, recPacket *packet.Packet) {
	// read
	readmsg := &protomsgs.ChatMsg{}
	proto.Unmarshal(recPacket.Data, readmsg)

	fmt.Println(readmsg.GetSenderName())
	fmt.Println(readmsg.GetMsg())
	fmt.Println(utils.TimestampToTimestring(readmsg.GetTimestamp()))

	// write
	writemsg := &protomsgs.ChatMsg{
		SenderName: proto.String("服务器"),
		Msg:        proto.String("hello,生活真美好."),
		Timestamp:  proto.Int64(time.Now().Unix()),
	}
	data, err := proto.Marshal(writemsg)
	if err != nil {
		log.Printf("proto.Marshal(writemsg) error: %v", err)
		return
	}

	pac := &packet.Packet{
		Len:  uint32(len(data) + 6),
		Type: packet.TYPE_MESSAGE,
		Data: data,
	}

	SendByteStream(conn, pac.GetBytes(), 5*time.Second)
}