Golang Header.Write方法代码示例

func headersToWriter(h http.Header, w io.Writer) error {
	if err := h.Write(w); err != nil {
		return err
	}
	// ReadMIMEHeader expects a trailing newline
	_, err := w.Write([]byte("\r\n"))
	return err
}

func buildHTTPResponse(bufrw *bufio.ReadWriter) {
	var newHeader http.Header = make(http.Header)

	newHeader.Add("Access-Control-Allow-Origin", "*")
	newHeader.Add("Content-Type", "application/json; charset=UTF-8")
	newHeader.Add("Cache-Control", "no-cache")
	newHeader.Add("X-AppServer", "GoAPP")
	// write status line
	bufrw.WriteString("HTTP/1.1 200 OK" + "\r\n")
	// write headers
	_ = newHeader.Write(bufrw)
	// write a black line
	bufrw.WriteString("\n")
}

func (c *SessionClient) dialTCP(service string, action string) (net.Conn, error) {

	burl, err := url.Parse(c.APIURL)
	if err != nil {
		return nil, err
	}
	burl.Path += fmt.Sprintf("%s/session/%s/conn/%s%s/tcp", c.Prefix, c.ID, service, action)
	req, err := http.NewRequest("GET", burl.String(), nil)
	req.Header.Set("X-Auth-Session", c.authToken)
	if err != nil {
		return nil, err
	}

	var conn net.Conn
	if burl.Scheme == "https" {
		conn, err = tls.Dial("tcp", burl.Host, c.TLSConfig)
	} else {
		conn, err = net.Dial("tcp", burl.Host)
	}
	if err != nil {
		return nil, err
	}

	br := bufio.NewReader(conn)
	bw := bufio.NewWriter(conn)
	bw.WriteString("GET " + burl.RequestURI() + " HTTP/1.1\r\n")
	bw.WriteString("Host: " + burl.Host + "\r\n")
	bw.WriteString("Connection: Upgrade\r\n")
	header := http.Header{}
	header.Set("X-Auth-Session", c.authToken)
	err = header.Write(bw)
	if err != nil {
		return nil, err
	}
	bw.WriteString("\r\n")
	if err = bw.Flush(); err != nil {
		return nil, err
	}

	resp, err := http.ReadResponse(br, &http.Request{Method: "GET"})
	if err != nil {
		return nil, err
	}
	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("sessionClient.dialTCP: http response error %s", resp.Status)
	}

	return conn, nil
}

// WriteHeader writes the HTTP status line and headers to writer `w`.
func WriteHeader(w io.Writer, h http.Header, code int) error {
	text := http.StatusText(code)
	if text == "" {
		return errors.New("header: invalid status code")
	}
	statusCode := strconv.Itoa(code)
	io.WriteString(w, "HTTP/1.0 "+statusCode+" "+text+"\r\n")

	if h != nil {
		if err := h.Write(w); err != nil {
			return err
		}
	}

	_, err := io.WriteString(w, "\r\n")
	return err
}

func getHeaderBuffer(code int, headers http.Header) (*bytes.Buffer, error) {
	headerBuffer := &bytes.Buffer{}
	if _, err := headerBuffer.Write([]byte(fmt.Sprintf("HTTP/1.1 %d %s\r\n", code, http.StatusText(code)))); err != nil {
		return nil, err
	}

	//Write headers
	if err := headers.Write(headerBuffer); err != nil {
		return nil, err
	}
	// ReadMIMEHeader expects a trailing newline
	if _, err := headerBuffer.Write([]byte("\r\n")); err != nil {
		return nil, err
	}

	return headerBuffer, nil
}

func NewHTTPClient(conn io.ReadWriteCloser, path string, header http.Header) (*Client, error) {
	if header == nil {
		header = make(http.Header)
	}
	header.Set("Accept", "application/vnd.flynn.rpc-hijack+gob")

	fmt.Fprintf(conn, "CONNECT %s HTTP/1.0\r\n", path)
	header.Write(conn)
	conn.Write([]byte("\r\n"))

	// Require successful HTTP response
	// before switching to RPC protocol.
	resp, err := http.ReadResponse(bufio.NewReader(conn), &http.Request{Method: "CONNECT"})
	if err != nil || resp.Status != connected {
		if err == nil {
			err = errors.New("unexpected HTTP response: " + resp.Status)
		}
		return nil, err
	}
	return NewClient(conn), nil
}

func (s *TestSuite) writeHeaders(headers http.Header) string {
	buf := &bytes.Buffer{}
	headers.Write(buf)

	return buf.String()
}

// extraHeaders may be nil
// waitForContinue may be nil
func writeRequestFull(req *http.Request, w io.Writer, usingProxy bool, extraHeaders http.Header, waitForContinue func() bool) error {
	// Find the target host. Prefer the Host: header, but if that
	// is not given, use the host from the request URL.
	//
	// Clean the host, in case it arrives with unexpected stuff in it.
	host := cleanHost(req.Host)
	if host == "" {
		if req.URL == nil {
			return errMissingHost
		}
		host = cleanHost(req.URL.Host)
	}

	// According to RFC 6874, an HTTP client, proxy, or other
	// intermediary must remove any IPv6 zone identifier attached
	// to an outgoing URI.
	host = removeZone(host)

	ruri := req.URL.RequestURI()
	if usingProxy && req.URL.Scheme != "" && req.URL.Opaque == "" {
		ruri = req.URL.Scheme + "://" + host + ruri
	} else if req.Method == "CONNECT" && req.URL.Path == "" {
		// CONNECT requests normally give just the host and port, not a full URL.
		ruri = host
	}
	// TODO(bradfitz): escape at least newlines in ruri?

	// Wrap the writer in a bufio Writer if it's not already buffered.
	// Don't always call NewWriter, as that forces a bytes.Buffer
	// and other small bufio Writers to have a minimum 4k buffer
	// size.
	var bw *bufio.Writer
	if _, ok := w.(io.ByteWriter); !ok {
		bw = bufio.NewWriter(w)
		w = bw
	}

	_, err := fmt.Fprintf(w, "%s %s HTTP/1.1\r\n", valueOrDefault(req.Method, "GET"), ruri)
	if err != nil {
		return err
	}

	// Header lines
	_, err = fmt.Fprintf(w, "Host: %s\r\n", host)
	if err != nil {
		return err
	}

	// Use the defaultUserAgent unless the Header contains one, which
	// may be blank to not send the header.
	userAgent := defaultUserAgent
	if _, ok := req.Header["User-Agent"]; ok {
		userAgent = req.Header.Get("User-Agent")
	}
	if userAgent != "" {
		_, err = fmt.Fprintf(w, "User-Agent: %s\r\n", userAgent)
		if err != nil {
			return err
		}
	}

	// Process Body,ContentLength,Close,Trailer
	tw, err := newTransferWriter(req)
	if err != nil {
		return err
	}
	err = tw.WriteHeader(w)
	if err != nil {
		return err
	}

	err = req.Header.WriteSubset(w, reqWriteExcludeHeader)
	if err != nil {
		return err
	}

	if extraHeaders != nil {
		err = extraHeaders.Write(w)
		if err != nil {
			return err
		}
	}

	_, err = io.WriteString(w, "\r\n")
	if err != nil {
		return err
	}

	// Flush and wait for 100-continue if expected.
	if waitForContinue != nil {
		if bw, ok := w.(*bufio.Writer); ok {
			err = bw.Flush()
			if err != nil {
				return err
			}
		}

		if !waitForContinue() {
//.........这里部分代码省略.........

/**
 * Prepares and dispatches a response via ResponseWriter for a publish API request
 */
func apiRequestPublish(w http.ResponseWriter, r *http.Request) {
	path := strings.Split(r.URL.Path, "/")

	statisticsIncrement(RUNTIME_PUBLISHES_RECEIVED)

	message, err := getMessageFromPost(r)
	if err != nil {
		statisticsIncrement(RUNTIME_PUBLISHES_FAILURE)
		statisticsIncrement(RUNTIME_PUBLISHES_FAILURE_400)
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	auth, err := getAuthentication(r)
	if err != nil {
		statisticsIncrement(RUNTIME_PUBLISHES_FAILURE)
		statisticsIncrement(RUNTIME_PUBLISHES_FAILURE_401)
		header := http.Header{}
		header.Add("WWW-Authenticate", "Basic realm=hare")
		header.Add("Status", "HTTP/1.1 401")
		_ = header.Write(w)
		return
	}

	vhost := getUriValue(path, 1)
	if len(vhost) < 1 {
		statisticsIncrement(RUNTIME_PUBLISHES_FAILURE)
		statisticsIncrement(RUNTIME_PUBLISHES_FAILURE_404)
		http.NotFound(w, r)
		return
	}

	definition := &ConnectionDefinition{
		vhost,
		auth["user"],
		auth["pass"],
	}

	//Ensure we have a connection to VHOST
	_, _, err = GetConnection(*definition)
	if err != nil {
		statisticsIncrement(RUNTIME_PUBLISHES_FAILURE)
		if err == amqp.ErrVhost || err == amqp.ErrCredentials {
			statisticsIncrement(RUNTIME_PUBLISHES_FAILURE_403)
			w.WriteHeader(http.StatusForbidden)
			return
		} else {
			statisticsIncrement(RUNTIME_PUBLISHES_FAILURE_500)
			w.WriteHeader(http.StatusInternalServerError)
			return
		}
		return
	}

	exchange := getUriValue(path, 2)
	routingKey := getUriValue(path, 3)

	if err := publish(*definition, exchange, routingKey, *message); err != nil {
		statisticsIncrement(RUNTIME_PUBLISHES_FAILURE)
		statisticsIncrement(RUNTIME_PUBLISHES_FAILURE_500)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	statisticsIncrement(RUNTIME_PUBLISHES_SUCCESS)
	w.WriteHeader(http.StatusNoContent)
	return
}

func HeaderToString(header http.Header) (s string) {
	buf := &bytes.Buffer{}
	header.Write(buf)
	return string(buf.Bytes())
}

// extraHeaders may be nil
func write(req *http.Request, w io.Writer, usingProxy bool, extraHeaders http.Header) error {
	host := req.Host
	if host == "" {
		if req.URL == nil {
			return errors.New("http: Request.Write on Request with no Host or URL set")
		}
		host = req.URL.Host
	}

	ruri := req.URL.RequestURI()
	if usingProxy && req.URL.Scheme != "" && req.URL.Opaque == "" {
		ruri = req.URL.Scheme + "://" + host + ruri
	} else if req.Method == "CONNECT" && req.URL.Path == "" {
		// CONNECT requests normally give just the host and port, not a full URL.
		ruri = host
	}
	// TODO(bradfitz): escape at least newlines in ruri?

	bw := bufio.NewWriter(w)
	fmt.Fprintf(bw, "%s %s HTTP/1.1\r\n", valueOrDefault(req.Method, "GET"), ruri)

	// Header lines
	fmt.Fprintf(bw, "Host: %s\r\n", host)

	// Use the defaultUserAgent unless the Header contains one, which
	// may be blank to not send the header.
	userAgent := defaultUserAgent
	if req.Header != nil {
		if ua := req.Header["User-Agent"]; len(ua) > 0 {
			userAgent = ua[0]
		}
	}
	if userAgent != "" {
		fmt.Fprintf(bw, "User-Agent: %s\r\n", userAgent)
	}

	// Process Body,ContentLength,Close,Trailer
	tw, err := newTransferWriter(req)
	if err != nil {
		return err
	}
	err = tw.WriteHeader(bw)
	if err != nil {
		return err
	}

	// TODO: split long values?  (If so, should share code with Conn.Write)
	err = req.Header.WriteSubset(bw, reqWriteExcludeHeader)
	if err != nil {
		return err
	}

	if extraHeaders != nil {
		err = extraHeaders.Write(bw)
		if err != nil {
			return err
		}
	}

	io.WriteString(bw, "\r\n")

	// Write body and trailer
	err = tw.WriteBody(bw)
	if err != nil {
		return err
	}

	return bw.Flush()
}

func Upload(url string, file_path string, header http.Header, check string, conc int) error {

	var md5Hash hash.Hash

	r, err := os.Open(file_path)
	if err != nil {
		if file_path == "" {
			r = os.Stdin
		} else {
			return err
		}
	}

	defer r.Close()

	log.Println("Check option: ", check)

	if check == "metadata" {
		// precalculate md5 for http header
		md5Hash, err := md5Calc(r)
		if err != nil {
			return err
		}
		if header == nil {
			header = make(http.Header)
		}

		md5Header := fmt.Sprintf("%x", md5Hash.Sum(nil))
		header.Set(checkSumHeader, md5Header)
		log.Println("POST REQ HEADER:")
		header.Write(os.Stderr)
	}
	k := Keys{AccessKey: os.Getenv("AWS_ACCESS_KEY"),
		SecretKey: os.Getenv("AWS_SECRET_KEY"),
	}
	s3_ := New("", k)
	b := s3_.Bucket("rm-dev-repos")
	key, _ := url_.Parse(url)
	path := key.Path
	c := DefaultConfig
	c.Concurrency = conc
	w, err := b.PutWriter(path, header, c)

	if err != nil {
		return err
	}
	mw := io.MultiWriter(w)

	if check == "file" {
		md5Hash = md5.New()
		mw = io.MultiWriter(md5Hash, w)

	}

	if _, err := io.Copy(mw, r); err != nil {
		return err
	}
	if err := w.Close(); err != nil {
		return err
	}

	// Write md5 to file and upload
	if check == "file" {
		if err := md5FileUpload(md5Hash, url, b); err != nil {
			return err
		}
	}

	return nil
}