Golang Reader.ReadSlice方法代码示例

// Symbol looks up the program counters listed in the request,
// responding with a table mapping program counters to function names.
// The package initialization registers it as /debug/pprof/symbol.
func Symbol(c *http.Conn, r *http.Request) {
	c.SetHeader("content-type", "text/plain; charset=utf-8")

	// We don't know how many symbols we have, but we
	// do have symbol information.  Pprof only cares whether
	// this number is 0 (no symbols available) or > 0.
	fmt.Fprintf(c, "num_symbols: 1\n")

	var b *bufio.Reader
	if r.Method == "POST" {
		b = bufio.NewReader(r.Body)
	} else {
		b = bufio.NewReader(strings.NewReader(r.URL.RawQuery))
	}

	for {
		w, err := b.ReadSlice('+')
		if err == nil {
			w = w[0 : len(w)-1] // trim +
		}
		pc, _ := strconv.Btoui64(string(w), 0)
		if pc != 0 {
			f := runtime.FuncForPC(uintptr(pc))
			if f != nil {
				fmt.Fprintf(c, "%#x %s\n", pc, f.Name())
			}
		}

		// Wait until here to check for err; the last
		// symbol will have an err because it doesn't end in +.
		if err != nil {
			break
		}
	}
}

func parseInput(r *bufio.Reader) (args []string, err error) {
	for {
		buf, err := r.ReadSlice('\n')

		end := false
		if err == io.EOF {
			end = true
		} else if err != nil {
			return args, errors.New(fmt.Sprintf("Error reading line '%s': %v\n", buf, err))
		}

		index := bytes.IndexByte(buf, '#')
		if index != -1 {
			buf = buf[:index]
		}

		buf = bytes.TrimSpace(buf)

		if len(buf) == 0 {
			if end {
				break
			}
			continue
		}

		args = append(args, string(buf))

		if end {
			break
		}
	}

	return
}

func (p *protocol) ReadParam(r *bufio.Reader) ([]byte, bool, error) {
	data, err := r.ReadSlice('\r')
	if err != nil {
		return nil, false, p.sanitizeErr(err)
	}
	err = p.assumeByte(r, '\n')
	if err != nil {
		return nil, false, err
	}

	next, err := r.ReadByte()
	if err != nil {
		return nil, false, p.sanitizeErr(err)
	}
	hasNext := true
	if next == '\r' {
		hasNext = false
		err = p.assumeByte(r, '\n')
		if err != nil {
			return nil, false, p.sanitizeErr(err)
		}
	} else {
		r.UnreadByte()
	}

	return data, hasNext, nil
}

// parseConfigResponse reads a CONFIG response from r and returns the version
// number and byte array of server descriptions.
func parseConfigResponse(r *bufio.Reader) (int, []byte, error) {
	line, err := r.ReadSlice('\n')
	if err != nil {
		return 0, nil, err
	}
	size, err := scanConfigDataLength(line)
	if err != nil {
		return 0, nil, err
	}
	value, err := ioutil.ReadAll(io.LimitReader(r, int64(size)+2))
	if err != nil {
		return 0, nil, err
	}
	if !bytes.HasSuffix(value, crlf) {
		return 0, nil, fmt.Errorf("elasticache: corrupt config result read")
	}
	// Reduce the value down to its total identified size
	value = value[:size]

	// Pull out version and server list, separated by LFs
	re := regexp.MustCompile("^(\\d+)\n(.*)\n$")
	configData := re.FindSubmatch(value)
	if configData == nil {
		return 0, nil, fmt.Errorf("elasticache: malformed config data: %s", value)
	}

	version, _ := strconv.Atoi(string(configData[1]))
	return version, configData[2], nil
}

func readLine(rd *bufio.Reader) ([]byte, error) {
	// line, isPrefix, err := rd.ReadLine()
	// if err != nil {
	// 	return line, err
	// }
	// if isPrefix {
	// 	return line, errReaderTooSmall
	// }
	// if len(line) < 2 || line[len(line)-2] != '\r' { // \r\n
	// 	fmt.Println(line)
	// 	return nil, errors.New(fmt.Sprintf("invalid redis packet %v, err:%v", line, err))
	// }
	// return line, nil

	line, err := rd.ReadSlice('\n')
	if err != nil {
		return nil, err
	}

	if len(line) < 2 || line[len(line)-2] != '\r' { // \r\n
		return nil, errors.New(fmt.Sprintf("invalid redis packet %v, err:%v", line, err))
	}

	return line[:len(line)-2], nil
}

func parseStatsResponse(r *bufio.Reader, stats *Statistics) error {
	for {
		line, err := r.ReadSlice('\n')
		if err != nil {
			return err
		}
		if bytes.Equal(line, resultEnd) {
			return nil
		}
		if hits, err := parseStatsLine(line, statsGetHits); err == nil {
			stats.Hits = hits
			continue
		}
		if misses, err := parseStatsLine(line, statsGetMisses); err == nil {
			stats.Misses = misses
			continue
		}
		if bytesWritten, err := parseStatsLine(line, statsBytesWritten); err == nil {
			stats.ByteHits = bytesWritten
			continue
		}
		if items, err := parseStatsLine(line, statsItems); err == nil {
			stats.Items = items
			continue
		}
		if bytes_total, err := parseStatsLine(line, statsBytes); err == nil {
			stats.Bytes = bytes_total
			continue
		}
	}
}

// parseGetResponse reads a GET response from r and calls cb for each
// read and allocated Item
func parseGetResponse(r *bufio.Reader, cb func(*Item)) error {
	for {
		line, err := r.ReadSlice('\n')
		if err != nil {
			return err
		}
		if bytes.Equal(line, resultEnd) {
			return nil
		}
		it := new(Item)
		size, err := scanGetResponseLine(line, it)
		if err != nil {
			return err
		}
		it.Value, err = ioutil.ReadAll(io.LimitReader(r, int64(size)+2))
		if err != nil {
			return err
		}
		if !bytes.HasSuffix(it.Value, crlf) {
			return fmt.Errorf("memcache: corrupt get result read")
		}
		it.Value = it.Value[:size]
		cb(it)
	}
	panic("unreached")
}

// parseGetResponse reads a GET response from r and calls cb for each
// read and allocated Item
func parseGetResponse(r *bufio.Reader, cb func(*Item)) error {
	for {
		line, err := r.ReadSlice('\n')
		if err != nil {
			return err
		}
		if bytes.Equal(line, resultEnd) {
			return nil
		}
		it := new(Item)
		var size int
		n, err := fmt.Sscanf(string(line), "VALUE %s %d %d %d\r\n",
			&it.Key, &it.Flags, &size, &it.casid)
		if err != nil {
			return err
		}
		if n != 4 {
			return fmt.Errorf("memcache: unexpected line in get response: %q", string(line))
		}
		it.Value, err = ioutil.ReadAll(io.LimitReader(r, int64(size)+2))
		if err != nil {
			return err
		}
		if !bytes.HasSuffix(it.Value, crlf) {
			return fmt.Errorf("memcache: corrupt get result read")
		}
		it.Value = it.Value[:size]
		cb(it)
	}
	panic("unreached")
}

func parseStatsSettingsResponse(r *bufio.Reader, stats *SettingsStats) error {
	pattern := "STAT %s %s\r\n"
	var (
		key   string
		value []byte
	)
	for {
		line, err := r.ReadSlice('\n')
		if err != nil {
			return err
		}
		if bytes.Equal(line, resultEnd) {
			return nil
		}

		n, err := fmt.Sscanf(string(line), pattern, &key, &value)
		if err != nil || n != 2 {
			return fmt.Errorf("memcache: unexpected line in stats response: %q", line)
		}
		err = stats.Set(key, value)
		if err != nil && err != ErrInvalidStatsKey {
			return err
		}
	}
	panic("unreached")
}

func readRequestLine(b *bufio.Reader) (method string, url string, version int, err os.Error) {

	p, err := b.ReadSlice('\n')
	if err != nil {
		if err == bufio.ErrBufferFull {
			err = web.ErrLineTooLong
		}
		return
	}

	m := requestLineRegexp.FindSubmatch(p)
	if m == nil {
		err = ErrBadRequestLine
		return
	}

	method = string(m[1])

	major, err := strconv.Atoi(string(m[3]))
	if err != nil {
		return
	}

	minor, err := strconv.Atoi(string(m[4]))
	if err != nil {
		return
	}

	version = web.ProtocolVersion(major, minor)

	url = string(m[2])

	return
}

func handleData(rd bufio.Reader, out io.Writer) string {
	// Stolen from go-smtpd:
	// http://code.google.com/p/go-smtpd/source/browse/smtpd/smtpd.go
	fmt.Fprint(out, "354 Go ahead\r\n")

	buf := new(bytes.Buffer)

	for {
		sl, err := rd.ReadSlice('\n')
		if err != nil {
			return ""
		}
		if bytes.Equal(sl, []byte(".\r\n")) {
			break
		}
		if sl[0] == '.' {
			sl = sl[1:]
		}
		_, err = buf.Write(sl)
		if err != nil {
			return ""
		}
	}

	fmt.Fprint(out, "250 2.0.0 Ok: queued\r\n")

	return buf.String()
}

func parseStatsItemsResponse(r *bufio.Reader, slabMap map[int]*ItemStats) error {
	pattern := "STAT items:%d:%s %s\r\n"
	var (
		slabIndex int
		key       string
		value     []byte
	)
	for {
		line, err := r.ReadSlice('\n')
		if err != nil {
			return err
		}
		if bytes.Equal(line, resultEnd) {
			return nil
		}

		n, err := fmt.Sscanf(string(line), pattern, &slabIndex, &key, &value)
		if err != nil || n != 3 {
			return fmt.Errorf("memcache: unexpected line in stats items response: %q", line)
		}

		_, ok := slabMap[slabIndex]
		if !ok {
			slabMap[slabIndex] = new(ItemStats)
		}
		err = slabMap[slabIndex].Set(key, value)
		if err != nil && err != ErrInvalidStatsKey {
			return err
		}
	}
	panic("unreached")
}

// readEvent reads a single binlog event. It can be a single comment line,
// or multiple lines terminated by the delimiter.
func (bls *BinlogStreamer) readEvent(bufReader *bufio.Reader) (event []byte, err error) {
	for {
		fragment, err := bufReader.ReadSlice('\n')
		event = append(event, fragment...)
		if err == bufio.ErrBufferFull {
			continue
		}
		if err != nil {
			if err == io.EOF {
				return event, err
			}
			return event, fmt.Errorf("read error: %v", err)
		}
		// Use a different var than event, because you have to keep
		// the trailing \n if we continue
		trimmed := bytes.TrimSpace(event)
		if bytes.HasPrefix(trimmed, HASH_COMMENT) ||
			bytes.HasPrefix(trimmed, SLASH_COMMENT) ||
			bytes.HasPrefix(trimmed, DELIM_STMT) {
			return trimmed, nil
		}
		if bytes.HasSuffix(trimmed, bls.delim) {
			return bytes.TrimSpace(trimmed[:len(trimmed)-len(bls.delim)]), nil
		}
	}
}

func (hub *MsgHub) msgProc(id int, reader *bufio.Reader) (err error) {
	var msgType byte
	var controlType byte

	msgType, err = reader.ReadByte()
	if err != nil {
		ERROR.Println("read from incoming error, detail:", err)
		return
	}
	switch msgType {
	case StringMsgType:
		//drop msg, should be ping
		var bs []byte
		bs, err = reader.ReadSlice('\n')
		if err != nil {
			return
		} else {
			INFO.Println(id, "said:", string(bs[:len(bs)-1]))
		}
	case ControlMsgType: //cronntrol msg
		if controlType, err = reader.ReadByte(); err != nil {
			return
		}
		switch controlType {
		case AddRouteControlType, RemoveRouteControlType:
			var msg RouteControlMsg
			var buf = make([]byte, msg.Len())
			buf[0] = ControlMsgType
			buf[1] = controlType
			reader.Read(buf[2:])
			if err = msg.Unmarshal(buf); err != nil {
				return
			}
			if msg.ControlType == AddRouteControlType {
				hub.AddRoute(msg.Id, msg.Type, id, nil)
			} else {
				hub.RemoveRoute(msg.Id, msg.Type)
			}
		case OfflineControlType:
			if err = hub.OfflineIncomingControlMsg(ControlMsgType, OfflineMsgType, reader); err != nil {
				return
			}
		}
	case RouteMsgType, TempRouteMsgType:
		var msg DeliverMsg
		if msg.To, msg.Carry, err = readRouteMsgBody(reader); err != nil {
			return
		}
		msg.MsgType = msgType
		hub.LocalDispatch(&msg)
	case OfflineMsgType:
		if err = hub.OfflineIncomingMsg(OfflineMsgType, reader); err != nil {
			return
		}
	default:
		err = UnknownMsg
	}
	return nil
}

func (s *debugLogSuite) getErrorResult(c *gc.C, reader *bufio.Reader) params.ErrorResult {
	line, err := reader.ReadSlice('\n')
	c.Assert(err, gc.IsNil)
	var errResult params.ErrorResult
	err = json.Unmarshal(line, &errResult)
	c.Assert(err, gc.IsNil)
	return errResult
}