Golang PipelinePack.Message方法代碼示例

// Run runs the FileReadFilter filter, which inspects each message, and appends
// the content of the file named as the executed template to the existing payload.
// The resulting message will be injected back, and have newType type.
func (fr FileReadFilter) Run(r pipeline.FilterRunner, h pipeline.PluginHelper) (err error) {
	if fr.tmpl == nil {
		return errors.New("FileReadFilter: empty template")
	}
	var (
		fh           *os.File
		inp          io.Reader
		npack, opack *pipeline.PipelinePack
	)
	out := bytes.NewBuffer(make([]byte, 0, 4096))
	log.Printf("FileReadFilter: Starting with template %s", fr.tmpl)
	for opack = range r.InChan() {
		//log.Printf("opack=%v", opack)
		//if opack.Decoded {
		out.Reset()
		if err = fr.tmpl.Execute(out, extendedMessage{opack.Message}); err != nil {
			opack.Recycle()
			return fmt.Errorf("FileReadFilter: error executing template %v with message %v: %v",
				fr.tmpl, opack.Message, err)
		}
		//log.Printf("out=%q", out)
		if fh, err = os.Open(out.String()); err != nil {
			log.Printf("FileReadFilter: cannot read %q: %v", out, err)
			opack.Recycle()
			continue
		}
		out.Reset()
		//if _, err = io.Copy(out, io.LimitedReader{R: fh, N: 65000}); err != nil && err != io.EOF {
		inp = fh
		if fr.decoder != nil {
			inp = transform.NewReader(fh, fr.decoder)
		}
		if _, err = io.Copy(out, inp); err != nil && err != io.EOF {
			log.Printf("FileReadFilter: error reading %q: %v", fh.Name(), err)
			opack.Recycle()
			fh.Close()
			continue
		}
		fh.Close()

		npack = h.PipelinePack(opack.MsgLoopCount)
		if npack == nil {
			opack.Recycle()
			return errors.New("FileReadFilter: no output pack - infinite loop?")
		}
		npack.Decoded = true
		npack.Message = message.CopyMessage(opack.Message)
		npack.Message.SetType(fr.newType)
		npack.Message.SetPayload(npack.Message.GetPayload() + "\n" + out.String())
		if !r.Inject(npack) {
			log.Printf("FileReadFilter: cannot inject new pack %v", npack)
		}
		//}
		opack.Recycle()
	}
	return nil
}

func (s *SandboxEncoder) Encode(pack *pipeline.PipelinePack) (output []byte, err error) {
	if s.sb == nil {
		err = errors.New("No sandbox.")
		return
	}
	atomic.AddInt64(&s.processMessageCount, 1)
	s.injected = false

	var startTime time.Time
	if s.sample {
		startTime = time.Now()
	}
	cowpack := new(pipeline.PipelinePack)
	cowpack.Message = pack.Message   // the actual copy will happen if write_message is called
	cowpack.MsgBytes = pack.MsgBytes // no copying is necessary since we don't change it
	retval := s.sb.ProcessMessage(cowpack)
	if retval == 0 && !s.injected {
		// `inject_message` was never called, protobuf encode the copy on write
		// message.
		if s.output, err = s.cEncoder.EncodeMessage(cowpack.Message); err != nil {
			return
		}
	}

	if s.sample {
		duration := time.Since(startTime).Nanoseconds()
		s.reportLock.Lock()
		s.processMessageDuration += duration
		s.processMessageSamples++
		s.reportLock.Unlock()
	}
	s.sample = 0 == rand.Intn(s.sampleDenominator)

	if retval > 0 {
		err = fmt.Errorf("FATAL: %s", s.sb.LastError())
		return
	}
	if retval == -2 {
		// Encoder has nothing to return.
		return nil, nil
	}
	if retval < 0 {
		atomic.AddInt64(&s.processMessageFailures, 1)
		err = fmt.Errorf("Failed serializing: %s", s.sb.LastError())
		return
	}
	return s.output, nil
}