Golang bytes.Reader类(方法)实例源码

// HandleLog is the default http log handler
func HandleLog(h HTTP, entries <-chan *log.Entry) {
	var e *log.Entry
	var b []byte
	var reader *bytes.Reader

	formatter := h.FormatFunc()(h)
	remoteHost := h.RemoteHost()
	httpClient := stdhttp.Client{}

	req, _ := stdhttp.NewRequest(h.Method(), remoteHost, nil)
	req.Header = h.Headers()

	for e = range entries {

		b = formatter(e)

		reader = bytes.NewReader(b)
		req.Body = ioutil.NopCloser(reader)
		req.ContentLength = int64(reader.Len())

		resp, err := httpClient.Do(req)
		if err != nil {
			log.Error("Could not post data to %s: %v\n", remoteHost, err)
			goto END
		}

		if resp.StatusCode < 200 || resp.StatusCode >= 299 {
			bt, _ := ioutil.ReadAll(resp.Body)
			log.Error("Received HTTP %d during POST request to %s body: %s\n", resp.StatusCode, remoteHost, string(bt))
		}

	END:
		e.Consumed()
	}
}

func _readLong3(file *bytes.Reader, offset int64) int64 {
	buf := make([]byte, 4)
	file.ReadAt(buf, offset)
	buf[3] = 0x00

	return int64(binary.LittleEndian.Uint32(buf))
}

func (k *KeenIoMetrics) AuthedRequest(method, path string, body *bytes.Reader) (resp *http.Response, err error) {
	path = fmt.Sprintf("https://api.keen.io/3.0/projects/%s%s", k.ProjectToken, path)
	req, err := http.NewRequest(method, path, body)
	if err != nil {
		return
	}

	req.Header.Add("Authorization", k.ApiKey)

	if body != nil {
		req.Header.Add("Content-Type", "application/json")
		req.ContentLength = int64(body.Len())
	}

	resp, err = k.HttpClient.Do(req)

	if err != nil {
		k.Error("Failed to send metric event to keen.io %v", err)
	} else {
		defer resp.Body.Close()
		if resp.StatusCode != 201 {
			bytes, _ := ioutil.ReadAll(resp.Body)
			k.Error("Got %v response from keen.io: %s", resp.StatusCode, bytes)
		}
	}

	return
}

func (this *HSPerfData) readEntryValueAsLong(reader *bytes.Reader, StartOfs int64, entry *PerfDataEntry) error {
	reader.Seek(StartOfs+int64(entry.DataOffset), os.SEEK_SET)
	reader.Read(this.globalbuf[:8])
	entry.LongValue = int64(this.byteOrder.Uint64(this.globalbuf[:8]))

	return nil
}

//Skip skip
func (t *TTFParser) Skip(fd *bytes.Reader, length int) error {
	_, err := fd.Seek(int64(length), 1)
	if err != nil {
		return err
	}
	return nil
}

func installZip(source *bytes.Reader, dest string) error {
	zr, err := zip.NewReader(source, int64(source.Len()))
	if err != nil {
		return err
	}

	for _, f := range zr.File {
		fileCopy, err := os.OpenFile(dest, installFlag, f.Mode())
		if err != nil {
			return err
		}
		defer fileCopy.Close()

		rc, err := f.Open()
		if err != nil {
			return err
		}
		defer rc.Close()

		_, err = io.Copy(fileCopy, rc)
		if err != nil {
			return err
		}
	}

	return nil
}

func readRune(r *bytes.Reader) rune {
	n, s, err := r.ReadRune()
	if n == _EOF_ || s == 0 || err != nil {
		return _EOF_
	}
	return n
}

func testZipArc(f *bytes.Reader) {
	za, err := New(&reader{f}, f.Size())
	if err != nil {
		panic(err)
	}

	compareFile(za, "a.txt", "This is a file.\n")
	compareFile(za, "k/l/m/a.txt", "k-l-m-a!\n")
	compareFile(za, "z.txt", "This is also a file.\n")

	d, err := za.Open("a")
	if err != nil {
		panic(err)
	}

	dfi, err := d.Readdir(0)
	if err != nil {
		panic(err)
	}

	h := sha256.New()
	for _, x := range dfi {
		s := fmt.Sprintf("%v\t%v\t%v\t%v\n", x.Name(), x.IsDir(), x.Mode(), x.Size())
		h.Write([]byte(s))
	}
	hs := hex.EncodeToString(h.Sum(nil))
	if hs != "93d5c5b0a7a5205b5ad687a8726dbec1a355a3937151ca96f7e704675ae1e536" {
		panic("hash mismatch: " + hs)
	}
}

//  degob converts a gob into a new copy of a subtree.
func degob(buf *bytes.Reader) Node {
	var tree Node
	buf.Seek(0, 0)
	dec := gob.NewDecoder(buf)
	CkErr(dec.Decode(&tree))
	return tree
}

func readBytes(f *bytes.Reader, len int) ([]byte, error) {
	b := make([]byte, len)
	_, err := f.Read(b)
	if err != nil {
		return nil, err
	}
	return b, nil
}

func UnpackString(in *bytes.Reader, n uint16) (Text, error) {
	buf := make([]byte, n)
	_, e := in.Read(buf)
	if e != nil {
		return "", e
	}
	return Text(string(buf)), nil
}

func ReadMac(reader *bytes.Reader) uint64 {
	mac_byte := make([]byte, 6)
	reader.Read(mac_byte)
	mac := []byte{0, 0}
	mac = append(mac, mac_byte...)

	return binary.BigEndian.Uint64(mac)
}

func (section_header *Section_Header) Verify(datar *bytes.Reader) bool {
	var buf []byte

	datar.Read(buf)
	fmt.Println(section_header.Checksum, len(buf))
	return section_header.Checksum == adler32.Checksum(buf[:72])

}

func UnpackBytes(in *bytes.Reader, n uint16) (Bytes, error) {
	ret := make([]byte, n)
	if _, e := in.Read([]byte(ret)); e != nil {
		return nil, e
	}

	return Bytes(ret), nil
}

func (sitemap *SitemapPage) parseSitemapPageNoGzip(mem_seek *bytes.Reader) (byte_reader *bytes.Reader, err error) {
	// validate uncompressed size
	if mem_seek.Len() > max_sitemap_page_size {
		return mem_seek, max_sitemap_page_size_error
	}

	err = sitemap.determineIteratorFormat(mem_seek)
	return mem_seek, err
}

func UnmarshalStream(url string, reader io.Reader) (feed *Feed, err error) {
	// Read the stream into memory (we'll need to parse it twice)
	var contentReader *bytes.Reader
	var content []byte
	if content, err = ioutil.ReadAll(reader); err == nil {
		contentReader = bytes.NewReader(content)

		genericFeed := GenericFeed{}

		decoder := xml.NewDecoder(contentReader)
		decoder.CharsetReader = charset.NewReader

		// First pass - parse the feed as-is
		if err = decoder.Decode(&genericFeed); err != nil {
			// Error - check for invalid entities and correct as appropriate
			if fixed, fixedContent := fixEntities(content); fixed {
				// At least one replacement was made. Retry
				contentReader = bytes.NewReader(fixedContent)
				decoder = xml.NewDecoder(contentReader)
				decoder.CharsetReader = charset.NewReader

				// Try decoding again
				err = decoder.Decode(&genericFeed)
			}
		}

		if err != nil {
			return
		}

		var xmlFeed FeedMarshaler
		if genericFeed.XMLName.Space == "http://www.w3.org/1999/02/22-rdf-syntax-ns#" && genericFeed.XMLName.Local == "RDF" {
			xmlFeed = &rss1Feed{}
		} else if genericFeed.XMLName.Local == "rss" {
			xmlFeed = &rss2Feed{}
		} else if genericFeed.XMLName.Space == "http://www.w3.org/2005/Atom" && genericFeed.XMLName.Local == "feed" {
			xmlFeed = &atomFeed{}
		} else {
			err = errors.New("Unsupported type of feed (" +
				genericFeed.XMLName.Space + ":" + genericFeed.XMLName.Local + ")")
			return
		}

		contentReader.Seek(0, 0)

		decoder = xml.NewDecoder(contentReader)
		decoder.CharsetReader = charset.NewReader

		if err = decoder.Decode(xmlFeed); err == nil {
			if feed, err = xmlFeed.Marshal(); err == nil {
				feed.URL = url
			}
		}
	}

	return
}

func render_line(line *bytes.Reader, h int) {
	m_x, _ := termbox.Size()
	for x := 0; x <= m_x; x++ {
		if r, _, err := line.ReadRune(); err == nil {
			termbox.SetCell(x, h, r, termbox.ColorBlack, termbox.ColorWhite)
		} else {
			termbox.SetCell(x, h, ' ', termbox.ColorBlack, termbox.ColorWhite)
		}
	}
}

func (self *Question) unpackFlags(in *bytes.Reader) error {
	buf := make([]byte, 4)
	if _, e := in.Read(buf); e != nil {
		return e
	}

	self.Type = enc.Uint16(buf[0:2])
	self.Class = enc.Uint16(buf[2:4])

	return nil
}

func (self *RR) unpackFlags(in *bytes.Reader) error {
	var buf [8]byte
	if _, e := in.Read(buf[:]); e != nil {
		return e
	}
	self.Type = enc.Uint16(buf[0:2])
	self.Class = enc.Uint16(buf[2:4])
	self.TTL = enc.Uint32(buf[4:8])

	return nil
}

func copyResp(code int, headers http.Header, body *bytes.Reader, newRw http.ResponseWriter) {
	h := newRw.Header()

	for k, v := range headers {
		h[k] = append(h[k], v...)
	}

	newRw.WriteHeader(code)
	body.WriteTo(newRw)
	body.Seek(0, 0)
}