// Creates a new log.
func newLog() *Log {
return &Log{
entries: make([]*LogEntry, 0),
pBuffer: proto.NewBuffer(nil),
pLogEntry: &protobuf.ProtoLogEntry{},
}
}
func struct_pack(L *lua.LState) int {
format := byte(L.CheckInt(2))
l_value := L.CheckNumber(3)
b := proto.NewBuffer(nil)
b.Reset()
L.SetTop(1)
switch format {
case 'i':
b.EncodeFixed32(uint64(int32(l_value)))
L.Push(lua.LString(string(b.Bytes())))
case 'q':
b.EncodeFixed64(uint64(int64(l_value)))
L.Push(lua.LString(string(b.Bytes())))
case 'f':
b.EncodeFixed32(uint64(float32(l_value)))
L.Push(lua.LString(string(b.Bytes())))
case 'd':
b.EncodeFixed64(uint64(float64(l_value)))
L.Push(lua.LString(string(b.Bytes())))
case 'I':
b.EncodeFixed32(uint64(uint32(l_value)))
L.Push(lua.LString(string(b.Bytes())))
case 'Q':
b.EncodeFixed64(uint64(l_value))
L.Push(lua.LString(string(b.Bytes())))
default:
L.RaiseError("Unknown, format")
}
L.Call(1, 0)
return 0
}
func receiveMsg(conn net.Conn) {
buf := make([]byte, 128)
n, err := conn.Read(buf)
if checkerr(err) {
return
}
fmt.Printf("\nread (%d) byte from %v :\n%v\n", n, conn.RemoteAddr(), buf[:n])
protobuf := proto.NewBuffer(buf[:n])
var msg OSMsg.OSMsg
pumerr := protobuf.Unmarshal(&msg)
if checkerr(pumerr) {
return
}
fmt.Printf("[Message]----->%v\n\n", msg.String())
//
// umerr := proto.Unmarshal(buf[:n], &msg)
// if checkerr(umerr) {
// return
// }
// fmt.Printf("[MyMessage] %v\n", msg)
// readStr := string(buf[:n])
// fmt.Printf("read string (%d):\n%s\n", n, readStr)
// umterr := proto.UnmarshalText(readStr, &msg)
// if checkerr(umterr) {
// return
// }
// fmt.Printf("[MyMessage] %v\n", msg)
}
func NewServerCodec(conn zmq.Socket) rpc.ServerCodec {
req := proto.NewBuffer(nil)
packetIds := make(idMap)
clientIds := make(map[uint64]uint64)
return &serverCodec{conn, req, packetIds, clientIds}
}
func (l *bufferList) Get() (*proto.Buffer, bool) {
if v, ok := l.l.Get(); ok {
return v.(*proto.Buffer), ok
}
return proto.NewBuffer(make([]byte, 0, 4096)), false
}
func BenchmarkUnmarshal(b *testing.B) {
b.StopTimer()
// BenchmarkUnmarshal is called multiple times.
once.Do(func() {
go http.ListenAndServe("localhost:9090", nil)
})
raw := prepareBuf(b).Bytes()
buf := proto.NewBuffer(make([]byte, 0, 4096))
for i := 0; i < b.N; i++ {
buf.SetBuf(raw)
b.StartTimer()
v := &SampleValueSeries{Value: make([]*SampleValueSeries_Value, 0, numSamples)}
if err := buf.Unmarshal(v); err != nil {
b.Fatal(err)
}
b.StopTimer()
if len(v.Value) != numSamples {
b.Fatal(len(v.Value))
}
}
}
func BuildJsonFromProto(cmdname string, cmddata []byte) string {
recvbuf := proto.NewBuffer(cmddata)
recv := &AccountTokenVerifyLoginUserPmd_CS{} //难点,这里这个结构是不确定的,只能动态描述
recvbuf.Unmarshal(recv)
recv_json, _ := json.Marshal(recv)
return string(recv_json)
}
func struct_unpack(L *lua.LState) int {
format := byte(L.CheckInt(1))
l_value := L.CheckString(2)
pos := L.CheckInt(3)
b_value := []byte(l_value)
b := proto.NewBuffer(b_value[pos:])
switch format {
case 'i':
value, _ := b.DecodeFixed32()
L.Push(lua.LNumber(int32(value)))
case 'q':
value, _ := b.DecodeFixed64()
L.Push(lua.LNumber(int64(value)))
case 'f':
value, _ := b.DecodeFixed32()
L.Push(lua.LNumber(float32(value)))
case 'd':
value, _ := b.DecodeFixed64()
L.Push(lua.LNumber(float64(value)))
case 'I':
value, _ := b.DecodeFixed32()
L.Push(lua.LNumber(uint32(value)))
case 'Q':
value, _ := b.DecodeFixed64()
L.Push(lua.LNumber(uint64(value)))
default:
L.RaiseError("Unknown, format")
}
return 1
}
func NewBuffer(rw io.ReadWriter) *Buffer {
return &Buffer{
rw: rw,
protoBuffer: proto.NewBuffer(nil),
index: 0,
}
}
func BuildProtoFromJson(typ reflect.Type, cmdjson string) []byte {
proto_cmd := reflect.New(typ).Interface().(proto.Message)
rawdata := []byte(cmdjson)
json.Unmarshal(rawdata, proto_cmd)
sendbuf := proto.NewBuffer(nil)
sendbuf.Marshal(proto_cmd)
return sendbuf.Bytes()
}
func (self *LevelDbShard) Write(database string, series []*protocol.Series) error {
wb := levigo.NewWriteBatch()
defer wb.Close()
for _, s := range series {
if len(s.Points) == 0 {
return errors.New("Unable to write no data. Series was nil or had no points.")
}
count := 0
for fieldIndex, field := range s.Fields {
temp := field
id, err := self.createIdForDbSeriesColumn(&database, s.Name, &temp)
if err != nil {
return err
}
keyBuffer := bytes.NewBuffer(make([]byte, 0, 24))
dataBuffer := proto.NewBuffer(nil)
for _, point := range s.Points {
keyBuffer.Reset()
dataBuffer.Reset()
keyBuffer.Write(id)
timestamp := self.convertTimestampToUint(point.GetTimestampInMicroseconds())
// pass the uint64 by reference so binary.Write() doesn't create a new buffer
// see the source code for intDataSize() in binary.go
binary.Write(keyBuffer, binary.BigEndian, ×tamp)
binary.Write(keyBuffer, binary.BigEndian, point.SequenceNumber)
pointKey := keyBuffer.Bytes()
if point.Values[fieldIndex].GetIsNull() {
wb.Delete(pointKey)
goto check
}
err = dataBuffer.Marshal(point.Values[fieldIndex])
if err != nil {
return err
}
wb.Put(pointKey, dataBuffer.Bytes())
check:
count++
if count >= self.writeBatchSize {
err = self.db.Write(self.writeOptions, wb)
if err != nil {
return err
}
count = 0
wb.Clear()
}
}
}
}
return self.db.Write(self.writeOptions, wb)
}
func (self *Shard) Write(database string, series []*protocol.Series) error {
wb := make([]storage.Write, 0)
for _, s := range series {
if len(s.Points) == 0 {
return errors.New("Unable to write no data. Series was nil or had no points.")
}
if len(s.FieldIds) == 0 {
return errors.New("Unable to write points without fields")
}
count := 0
for fieldIndex, id := range s.FieldIds {
for _, point := range s.Points {
// keyBuffer and dataBuffer have to be recreated since we are
// batching the writes, otherwise new writes will override the
// old writes that are still in memory
keyBuffer := bytes.NewBuffer(make([]byte, 0, 24))
dataBuffer := proto.NewBuffer(nil)
var err error
binary.Write(keyBuffer, binary.BigEndian, &id)
timestamp := self.convertTimestampToUint(point.GetTimestampInMicroseconds())
// pass the uint64 by reference so binary.Write() doesn't create a new buffer
// see the source code for intDataSize() in binary.go
binary.Write(keyBuffer, binary.BigEndian, ×tamp)
binary.Write(keyBuffer, binary.BigEndian, point.SequenceNumber)
pointKey := keyBuffer.Bytes()
if point.Values[fieldIndex].GetIsNull() {
wb = append(wb, storage.Write{Key: pointKey, Value: nil})
goto check
}
err = dataBuffer.Marshal(point.Values[fieldIndex])
if err != nil {
return err
}
wb = append(wb, storage.Write{Key: pointKey, Value: dataBuffer.Bytes()})
check:
count++
if count >= self.writeBatchSize {
err = self.db.BatchPut(wb)
if err != nil {
return err
}
count = 0
wb = make([]storage.Write, 0, self.writeBatchSize)
}
}
}
}
return self.db.BatchPut(wb)
}
func zig_zag_encode64(L *lua.LState) int {
b := proto.NewBuffer(nil)
b.Reset()
err := b.EncodeZigzag64(uint64(L.CheckNumber(1)))
if err == nil {
x, _ := binary.ReadUvarint(bytes.NewBuffer(b.Bytes()))
L.Push(lua.LNumber(x))
return 1
}
return 0
}
func (self *Shard) Write(database string, series []*protocol.Series) error {
self.closeLock.RLock()
defer self.closeLock.RUnlock()
if self.closed {
return fmt.Errorf("Shard is closed")
}
wb := make([]storage.Write, 0)
for _, s := range series {
if len(s.Points) == 0 {
return errors.New("Unable to write no data. Series was nil or had no points.")
}
if len(s.FieldIds) == 0 {
return errors.New("Unable to write points without fields")
}
count := 0
for fieldIndex, id := range s.FieldIds {
for _, point := range s.Points {
// keyBuffer and dataBuffer have to be recreated since we are
// batching the writes, otherwise new writes will override the
// old writes that are still in memory
dataBuffer := proto.NewBuffer(nil)
var err error
sk := newStorageKey(id, point.GetTimestamp(), point.GetSequenceNumber())
if point.Values[fieldIndex].GetIsNull() {
wb = append(wb, storage.Write{Key: sk.bytes(), Value: nil})
goto check
}
err = dataBuffer.Marshal(point.Values[fieldIndex])
if err != nil {
return err
}
wb = append(wb, storage.Write{Key: sk.bytes(), Value: dataBuffer.Bytes()})
check:
count++
if count >= self.writeBatchSize {
err = self.db.BatchPut(wb)
if err != nil {
return err
}
count = 0
wb = make([]storage.Write, 0, self.writeBatchSize)
}
}
}
}
return self.db.BatchPut(wb)
}
func zig_zag_decode64(L *lua.LState) int {
n := L.CheckNumber(1)
b_buf := bytes.NewBuffer([]byte{})
binary.Write(b_buf, binary.LittleEndian, n)
b := proto.NewBuffer(b_buf.Bytes())
value, err := b.DecodeZigzag64()
if err == nil {
L.Push(lua.LNumber(value))
return 1
}
return 0
}
func prepareBuf(b *testing.B) *proto.Buffer {
buf := proto.NewBuffer(make([]byte, 0, 4096))
v := &SampleValueSeries{Value: make([]*SampleValueSeries_Value, 0, numSamples)}
for i := 0; i < numSamples; i++ {
v.Value = append(v.Value, &SampleValueSeries_Value{
Timestamp: proto.Int64(rand.Int63()),
Value: proto.Float64(rand.NormFloat64()),
})
}
if err := buf.Marshal(v); err != nil {
b.Fatal(err)
}
return buf
}
func receiveMsg(conn net.Conn) {
buf := make([]byte, 128)
n, err := conn.Read(buf)
if checkerr(err) {
os.Exit(-1)
return
}
// fmt.Printf("\nread (%d) byte from %v :\n%v\n", n, conn.RemoteAddr(), buf[:n])
protobuf := proto.NewBuffer(buf[:n])
var _msg msg.OSMsg
pumerr := protobuf.Unmarshal(&_msg)
if checkerr(pumerr) {
return
}
fmt.Printf("[received <----- message]%v\n", _msg.String())
}
func CreateHekaStream(msgBytes []byte, outBytes *[]byte,
msc *message.MessageSigningConfig) error {
h := &message.Header{}
h.SetMessageLength(uint32(len(msgBytes)))
if msc != nil {
h.SetHmacSigner(msc.Name)
h.SetHmacKeyVersion(msc.Version)
var hm hash.Hash
switch msc.Hash {
case "sha1":
hm = hmac.New(sha1.New, []byte(msc.Key))
h.SetHmacHashFunction(message.Header_SHA1)
default:
hm = hmac.New(md5.New, []byte(msc.Key))
}
hm.Write(msgBytes)
h.SetHmac(hm.Sum(nil))
}
headerSize := proto.Size(h)
requiredSize := message.HEADER_FRAMING_SIZE + headerSize + len(msgBytes)
if requiredSize > message.MAX_RECORD_SIZE {
return fmt.Errorf("Message too big, requires %d (MAX_RECORD_SIZE = %d)",
requiredSize, message.MAX_RECORD_SIZE)
}
if cap(*outBytes) < requiredSize {
*outBytes = make([]byte, requiredSize)
} else {
*outBytes = (*outBytes)[:requiredSize]
}
(*outBytes)[0] = message.RECORD_SEPARATOR
(*outBytes)[1] = uint8(headerSize)
// This looks odd but is correct; it effectively "seeks" the initial write
// position for the protobuf output to be at the
// `(*outBytes)[message.HEADER_DELIMITER_SIZE]` position.
pbuf := proto.NewBuffer((*outBytes)[message.HEADER_DELIMITER_SIZE:message.HEADER_DELIMITER_SIZE])
if err := pbuf.Marshal(h); err != nil {
return err
}
(*outBytes)[headerSize+message.HEADER_DELIMITER_SIZE] = message.UNIT_SEPARATOR
copy((*outBytes)[message.HEADER_FRAMING_SIZE+headerSize:], msgBytes)
return nil
}
func createStream(msgBytes []byte, encoding message.Header_MessageEncoding,
outBytes *[]byte, msc *message.MessageSigningConfig) error {
h := &message.Header{}
h.SetMessageLength(uint32(len(msgBytes)))
if encoding != message.Default_Header_MessageEncoding {
h.SetMessageEncoding(encoding)
}
if msc != nil {
h.SetHmacSigner(msc.Name)
h.SetHmacKeyVersion(msc.Version)
var hm hash.Hash
switch msc.Hash {
case "sha1":
hm = hmac.New(sha1.New, []byte(msc.Key))
h.SetHmacHashFunction(message.Header_SHA1)
default:
hm = hmac.New(md5.New, []byte(msc.Key))
}
hm.Write(msgBytes)
h.SetHmac(hm.Sum(nil))
}
headerSize := uint8(proto.Size(h))
requiredSize := int(3 + headerSize)
if cap(*outBytes) < requiredSize {
*outBytes = make([]byte, requiredSize, requiredSize+len(msgBytes))
} else {
*outBytes = (*outBytes)[:requiredSize]
}
(*outBytes)[0] = message.RECORD_SEPARATOR
(*outBytes)[1] = uint8(headerSize)
pbuf := proto.NewBuffer((*outBytes)[2:2])
err := pbuf.Marshal(h)
if err != nil {
return err
}
(*outBytes)[headerSize+2] = message.UNIT_SEPARATOR
*outBytes = append(*outBytes, msgBytes...)
return nil
}
func NewBufferPair() *bufferPair {
return &bufferPair{proto.NewBuffer(nil), proto.NewBuffer(nil)}
}
func NewDecoder(r io.Reader) *Decoder {
return &Decoder{
r: r,
buffer: proto.NewBuffer(nil),
}
}
func NewEncoder(w io.Writer) *Encoder {
return &Encoder{
w: w,
buffer: proto.NewBuffer(nil),
}
}
func main() {
uj := &Pmd.UserJsMessageForwardUserPmd_CS{}
uj.Msgbytes = []byte(`{"whj":111}`)
fmt.Println("XXXXX", uj.String(), proto.MarshalTextString(uj))
rc := &Pmd.ReconnectErrorLoginUserPmd_S{}
rc.Desc = proto.String(`{"whj":111}`)
fmt.Println("xxxxx", rc.String(), proto.MarshalTextString(rc), *rc.Desc)
m := make(map[int]string)
m[1] = "wabghaijun"
a := 1
fmt.Println(protobuf.Encode(&a))
mset := make(map[int32]proto.Extension)
//mset[1] = proto.Extension{enc: []byte("sss")}
//umset, err := proto.MarshalMessageSet(mset)
var b []byte
fmt.Println(len(b))
nmd := &Pmd.ForwardNullUserPmd_CS{}
nmd1 := &Pmd.ForwardNullUserPmd_CS{}
nmd2 := &Pmd.ForwardNullUserPmd_CS{}
cmd3 := &Pmd.RequestCloseNullUserPmd_CS{}
cmd4 := &Pmd.RequestCloseNullUserPmd_CS{}
cmd3.Reason = proto.String("2222")
fmt.Println(proto.GetProperties(reflect.TypeOf(cmd3).Elem()))
cmd3byte, err1 := proto.Marshal(cmd3)
if err1 != nil {
fmt.Println("xxxxxxxxxxx", err1)
}
fmt.Println(proto.Unmarshal(cmd3byte, cmd3))
fmt.Println(mset)
cmd3test := proto.MarshalTextString(cmd3)
fmt.Println(cmd3test)
fmt.Println(proto.UnmarshalText(cmd3test, nmd))
//nmd.Prototype = proto.Uint64(2)
nmd.ByCmd = proto.Uint32(0)
//nmd.ByParam = proto.Uint32(0)
//nmd.ByCmd = append(nmd.ByCmd, 0)
//nmd.ByParam = append(nmd.ByParam, 0)
sendbuf := proto.NewBuffer(nil)
err := sendbuf.Marshal(nmd)
if err != nil {
fmt.Println("1", err)
}
nmd.Data = sendbuf.Bytes()
fmt.Println(nmd, proto.Size(nmd), len(sendbuf.Bytes()))
fmt.Println(len(sendbuf.Bytes()), sendbuf.Bytes())
//data := sendbuf.Bytes()
err = sendbuf.Marshal(cmd3)
if err != nil {
fmt.Println("2", err)
}
fmt.Println(len(sendbuf.Bytes()), sendbuf.Bytes())
data := sendbuf.Bytes()
fmt.Println(len(data), data)
//data = append(data, byte(1))
databuf := proto.NewBuffer(data)
err = databuf.Unmarshal(nmd1)
if err != nil {
fmt.Println("3", err)
}
//err = databuf.Unmarshal(nmd2)
err = proto.Unmarshal(data[:2], nmd2)
if err != nil {
fmt.Println("4", err)
}
err = proto.Unmarshal(data[2:], cmd4)
//err = databuf.Unmarshal(cmd4)
if err != nil {
fmt.Println("5", err)
}
fmt.Println(nmd, proto.Size(nmd))
fmt.Println(nmd1)
fmt.Println(nmd2)
fmt.Println(cmd4)
}
func NewServerCodec(conn io.ReadWriteCloser) rpc.ServerCodec {
req := &bufferPair{proto.NewBuffer(nil), proto.NewBuffer(nil)}
resp := &bufferPair{proto.NewBuffer(nil), proto.NewBuffer(nil)}
return &serverCodec{conn, req, resp}
}
// Advance the iterator to the next point
func (pi *PointIterator) Next() {
valueBuffer := proto.NewBuffer(nil)
pi.valid = false
pi.point = &protocol.Point{Values: make([]*protocol.FieldValue, len(pi.fields))}
err := pi.getIteratorNextValue()
if err != nil {
pi.setError(err)
return
}
var next *rawColumnValue
// choose the highest (or lowest in case of ascending queries) timestamp
// and sequence number. that will become the timestamp and sequence of
// the next point.
for i, value := range pi.rawColumnValues {
if value.value == nil {
continue
}
if next == nil {
next = &pi.rawColumnValues[i]
continue
}
if pi.asc {
if value.before(next) {
next = &pi.rawColumnValues[i]
}
continue
}
// the query is descending
if value.after(next) {
next = &pi.rawColumnValues[i]
}
}
for i, iterator := range pi.itrs {
rcv := &pi.rawColumnValues[i]
log4go.Debug("Column value: %s", rcv)
// if the value is nil or doesn't match the point's timestamp and sequence number
// then skip it
if rcv.value == nil || rcv.time != next.time || rcv.sequence != next.sequence {
log4go.Debug("rcv = %#v, next = %#v", rcv, next)
pi.point.Values[i] = &protocol.FieldValue{IsNull: &TRUE}
continue
}
// if we emitted at least one column, then we should keep
// trying to get more points
log4go.Debug("Setting is valid to true")
pi.valid = true
// advance the iterator to read a new value in the next iteration
if pi.asc {
iterator.Next()
} else {
iterator.Prev()
}
fv := &protocol.FieldValue{}
valueBuffer.SetBuf(rcv.value)
err := valueBuffer.Unmarshal(fv)
if err != nil {
log4go.Error("Error while running query: %s", err)
pi.setError(err)
return
}
pi.point.Values[i] = fv
rcv.value = nil
}
// this will only happen if there are no points for the given series
// and range and this is the first call to Next(). Otherwise we
// always call Next() on a valid PointIterator so we know we have
// more points
if next == nil {
return
}
pi.point.SetTimestampInMicroseconds(next.time)
pi.point.SequenceNumber = proto.Uint64(next.sequence)
}
func (self *Shard) executeQueryForSeries(querySpec *parser.QuerySpec, seriesName string, columns []string, processor cluster.QueryProcessor) error {
startTimeBytes := self.byteArrayForTime(querySpec.GetStartTime())
endTimeBytes := self.byteArrayForTime(querySpec.GetEndTime())
fields, err := self.getFieldsForSeries(querySpec.Database(), seriesName, columns)
if err != nil {
// because a db is distributed across the cluster, it's possible we don't have the series indexed here. ignore
switch err := err.(type) {
case FieldLookupError:
log.Debug("Cannot find fields %v", columns)
return nil
default:
log.Error("Error looking up fields for %s: %s", seriesName, err)
return fmt.Errorf("Error looking up fields for %s: %s", seriesName, err)
}
}
fieldCount := len(fields)
rawColumnValues := make([]rawColumnValue, fieldCount, fieldCount)
query := querySpec.SelectQuery()
aliases := query.GetTableAliases(seriesName)
if querySpec.IsSinglePointQuery() {
series, err := self.fetchSinglePoint(querySpec, seriesName, fields)
if err != nil {
log.Error("Error reading a single point: %s", err)
return err
}
if len(series.Points) > 0 {
processor.YieldPoint(series.Name, series.Fields, series.Points[0])
}
return nil
}
fieldNames, iterators := self.getIterators(fields, startTimeBytes, endTimeBytes, query.Ascending)
defer func() {
for _, it := range iterators {
it.Close()
}
}()
seriesOutgoing := &protocol.Series{Name: protocol.String(seriesName), Fields: fieldNames, Points: make([]*protocol.Point, 0, self.pointBatchSize)}
// TODO: clean up, this is super gnarly
// optimize for the case where we're pulling back only a single column or aggregate
buffer := bytes.NewBuffer(nil)
valueBuffer := proto.NewBuffer(nil)
for {
isValid := false
point := &protocol.Point{Values: make([]*protocol.FieldValue, fieldCount, fieldCount)}
for i, it := range iterators {
if rawColumnValues[i].value != nil || !it.Valid() {
if err := it.Error(); err != nil {
return err
}
continue
}
key := it.Key()
if len(key) < 16 {
continue
}
if !isPointInRange(fields[i].Id, startTimeBytes, endTimeBytes, key) {
continue
}
value := it.Value()
sequenceNumber := key[16:]
rawTime := key[8:16]
rawColumnValues[i] = rawColumnValue{time: rawTime, sequence: sequenceNumber, value: value}
}
var pointTimeRaw []byte
var pointSequenceRaw []byte
// choose the highest (or lowest in case of ascending queries) timestamp
// and sequence number. that will become the timestamp and sequence of
// the next point.
for _, value := range rawColumnValues {
if value.value == nil {
continue
}
pointTimeRaw, pointSequenceRaw = value.updatePointTimeAndSequence(pointTimeRaw,
pointSequenceRaw, query.Ascending)
}
for i, iterator := range iterators {
// if the value is nil or doesn't match the point's timestamp and sequence number
// then skip it
if rawColumnValues[i].value == nil ||
!bytes.Equal(rawColumnValues[i].time, pointTimeRaw) ||
!bytes.Equal(rawColumnValues[i].sequence, pointSequenceRaw) {
point.Values[i] = &protocol.FieldValue{IsNull: &TRUE}
continue
}
// if we emitted at lease one column, then we should keep
// trying to get more points
isValid = true
// advance the iterator to read a new value in the next iteration
if query.Ascending {
iterator.Next()
} else {
iterator.Prev()
}
fv := &protocol.FieldValue{}
valueBuffer.SetBuf(rawColumnValues[i].value)
err := valueBuffer.Unmarshal(fv)
if err != nil {
log.Error("Error while running query: %s", err)
return err
}
point.Values[i] = fv
rawColumnValues[i].value = nil
}
var sequence uint64
var t uint64
// set the point sequence number and timestamp
buffer.Reset()
buffer.Write(pointSequenceRaw)
binary.Read(buffer, binary.BigEndian, &sequence)
buffer.Reset()
buffer.Write(pointTimeRaw)
binary.Read(buffer, binary.BigEndian, &t)
time := self.convertUintTimestampToInt64(&t)
point.SetTimestampInMicroseconds(time)
point.SequenceNumber = &sequence
// stop the loop if we ran out of points
if !isValid {
break
}
shouldContinue := true
seriesOutgoing.Points = append(seriesOutgoing.Points, point)
if len(seriesOutgoing.Points) >= self.pointBatchSize {
for _, alias := range aliases {
series := &protocol.Series{
Name: proto.String(alias),
Fields: fieldNames,
Points: seriesOutgoing.Points,
}
if !processor.YieldSeries(series) {
log.Info("Stopping processing")
shouldContinue = false
}
}
seriesOutgoing = &protocol.Series{Name: protocol.String(seriesName), Fields: fieldNames, Points: make([]*protocol.Point, 0, self.pointBatchSize)}
}
if !shouldContinue {
break
}
}
//Yield remaining data
for _, alias := range aliases {
log.Debug("Final Flush %s", alias)
series := &protocol.Series{Name: protocol.String(alias), Fields: seriesOutgoing.Fields, Points: seriesOutgoing.Points}
if !processor.YieldSeries(series) {
log.Debug("Cancelled...")
}
}
log.Debug("Finished running query %s", query.GetQueryString())
return nil
}
func NewClientCodec(conn io.ReadWriteCloser) rpc.ClientCodec {
req := &bufferPair{proto.NewBuffer(nil), proto.NewBuffer(nil)}
resp := &bufferPair{proto.NewBuffer(nil), proto.NewBuffer(nil)}
return &clientCodec{conn, req, resp}
}
