func (h *healthcheck) ServeHTTP(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
proxyWriter, ok := rw.(utils.ProxyResponseWriter)
var accessLogRecord *schema.AccessLogRecord
if ok {
alr := proxyWriter.Context().Value("AccessLogRecord")
if alr == nil {
h.logger.Error("AccessLogRecord not set on context", errors.New("failed-to-access-log-record"))
}
accessLogRecord = alr.(*schema.AccessLogRecord)
}
if h.userAgent == "" || r.Header.Get("User-Agent") == h.userAgent {
rw.Header().Set("Cache-Control", "private, max-age=0")
rw.Header().Set("Expires", "0")
draining := atomic.LoadInt32(h.heartbeatOK) == 0
if !draining {
rw.WriteHeader(http.StatusOK)
rw.Write([]byte("ok\n"))
r.Close = true
if ok {
accessLogRecord.StatusCode = http.StatusOK
}
} else {
rw.WriteHeader(http.StatusServiceUnavailable)
r.Close = true
if ok {
accessLogRecord.StatusCode = http.StatusServiceUnavailable
}
}
return
}
next(rw, r)
}
func materialHandler(key string, w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
panic("expected GET")
}
untrustedDocName, err := url.QueryUnescape(r.URL.RawQuery)
if err != nil {
panic(err)
}
log.Printf("%v downloaded %v", key, untrustedDocName)
// TODO(arjun): this is no longer a file path, but a URL fragment, I think
docDir, docName := filepath.Split(untrustedDocName)
if docDir != "" {
log.Printf("%v SECURITY ERROR %v trying to read document %v", r.RemoteAddr,
key, untrustedDocName)
w.WriteHeader(http.StatusBadRequest)
r.Close = true
return
}
log.Printf("%v %v downloaded %v", r.RemoteAddr, key, docName)
w.Header().Add("Content-Disposition",
fmt.Sprintf("inline; filename = %q", docName))
w.Header().Add("Content-Type", "application/pdf")
err = dept.DownloadFile(docName, w)
if err != nil {
log.Printf("dept.DownloadFile(%v, _) error: %v", docName, err)
w.WriteHeader(http.StatusBadRequest)
r.Close = true
}
}
func delHighlightHandler(key string, w http.ResponseWriter, r *http.Request) {
var arg FetchCommentsEnv
err := util.StringToJSON(key, &arg)
if err != nil {
log.Printf("FATAL ERROR decoding closure %v in setScoreHandler", key)
w.WriteHeader(500)
return
}
if r.Method != "POST" {
log.Printf("%v SECURITY ERROR %v trying to %v to %v", r.RemoteAddr,
arg.ReviewerId, r.Method, r.URL)
w.WriteHeader(http.StatusBadRequest)
r.Close = true
return
}
err = dept.DelHighlight(arg.AppId, string(arg.ReviewerId))
if err != nil {
w.WriteHeader(http.StatusBadRequest)
r.Close = true
log.Printf("%v ERROR DelHighlight(%v, %v): %v", r.RemoteAddr, arg.AppId,
arg.ReviewerId, err)
return
}
w.WriteHeader(200)
}
// Given a request, follow the segments through sitetree to find the page that is being requested. Doesn't
// understand actions, so just finds the page. Returns ID of SiteTree_Live record or 0 if it can't find a
// matching page.
// @todo Understand BaseController actions, or break on the furthest it gets up the tree
// @todo cache site tree
func findPageToRender(r *http.Request) (int, error) {
siteCache := getSiteCache()
if siteCache != nil {
id, found := siteCache.findPageToRender(r)
if found {
// fmt.Printf("page cache hit %d\n", id)
return id, nil
}
}
s := strings.Trim(r.URL.Path, "/")
path := strings.Split(s, "/")
if len(path) == 0 || path[0] == "" {
// find a home page ID
r, e := orm.Query("select \"ID\" from \"SiteTree_Live\" where \"URLSegment\"='home' and \"ParentID\"=0")
defer r.Close()
if e != nil {
return 0, e
}
if !r.Next() {
return 0, nil
}
var ID int
e = r.Scan(&ID)
return ID, e
}
currParentID := 0
for _, p := range path {
r, e := orm.Query("select \"ID\",\"ParentID\" from \"SiteTree_Live\" where \"URLSegment\"='" + p + "' and \"ParentID\"=" + strconv.Itoa(currParentID))
defer r.Close()
if e != nil {
return 0, e
}
if !r.Next() {
return 0, nil
}
var ID, ParentID int
e = r.Scan(&ID, &ParentID)
currParentID = ID
}
// if we get to the end, we've found a matching ID in SiteTree_Live
return currParentID, nil
}
// OfferingList parse the yaml files from the repository configuration file defined in the seettings package
// And then returns it json representation
func OfferingList(r *http.Request) (int, []byte, error) {
settings := settings.Get()
rootRepository := settings.OfferingRepositoryPath
var response []byte
sendOffering := func(path string, info os.FileInfo, err error) error {
stat, err := os.Stat(path)
if err != nil {
return err
}
if stat.IsDir() && path != rootRepository {
return filepath.SkipDir
}
matched, err := filepath.Match("*.yaml", info.Name())
if err != nil {
return err // this is fatal.
}
if matched {
r, err := os.Open(path)
if err != nil {
return err
}
data, err := ioutil.ReadAll(r)
defer r.Close()
if err != nil {
return err
}
var nodeTypes map[string]toscalib.NodeType
err = yaml.Unmarshal(data, &nodeTypes)
if err != nil {
return err
}
response, err = json.MarshalIndent(nodeTypes, "", " ")
if err != nil {
return err
}
}
return nil
}
err := filepath.Walk(rootRepository, sendOffering)
if err != nil {
log.Println(err)
return http.StatusInternalServerError, nil, err
}
return http.StatusOK, response, nil
}
func post(url_ string, oauthHeaders map[string]string) (r *http.Response, err error) {
var req http.Request
req.Method = "POST"
req.ProtoMajor = 1
req.ProtoMinor = 1
req.Close = true
req.Header = map[string][]string{
"Authorization": {"OAuth "},
}
req.TransferEncoding = []string{"chunked"}
first := true
for k, v := range oauthHeaders {
if first {
first = false
} else {
req.Header["Authorization"][0] += ",\n "
}
req.Header["Authorization"][0] += k + "=\"" + v + "\""
}
req.URL, err = url.Parse(url_)
if err != nil {
return nil, err
}
return send(&req)
}
func proxyAsync(tlsConfig *tls.Config, addr string, w http.ResponseWriter, r *http.Request, callback func(*http.Response)) error {
log.WithFields(log.Fields{"request": fmt.Sprintf("%+v", r)}).Debug("proxyAsync")
// Use a new client for each request
client, scheme := newClientAndScheme(tlsConfig)
// RequestURI may not be sent to client
r.RequestURI = ""
r.URL.Scheme = scheme
r.URL.Host = addr
r.Close = true
log.WithFields(log.Fields{"method": r.Method, "url": r.URL}).Debug("Proxy request")
resp, err := client.Do(r)
if err != nil {
log.WithFields(log.Fields{"request": r, "error": err}).Error("proxyAsync:client.Do(r)")
return err
}
copyHeader(w.Header(), resp.Header)
w.WriteHeader(resp.StatusCode)
io.Copy(NewWriteFlusher(w), resp.Body)
if callback != nil {
callback(resp)
}
// cleanup
resp.Body.Close()
log.WithFields(log.Fields{"method": r.Method, "url": r.URL}).Debug("Proxy request: closeIdleConnections(client)....")
closeIdleConnections(client)
log.WithFields(log.Fields{"method": r.Method, "url": r.URL}).Debug("Proxy request: closeIdleConnections(client)....Done")
return nil
}
// This function alters the original request - adds/removes headers, removes hop headers,
// changes the request path.
func rewriteRequest(req *http.Request, cmd *command.Forward, upstream *command.Upstream) *http.Request {
outReq := new(http.Request)
*outReq = *req // includes shallow copies of maps, but we handle this below
outReq.URL.Scheme = upstream.Scheme
outReq.URL.Host = fmt.Sprintf("%s:%d", upstream.Host, upstream.Port)
if len(cmd.RewritePath) != 0 {
outReq.URL.Path = cmd.RewritePath
}
outReq.URL.RawQuery = req.URL.RawQuery
outReq.Proto = "HTTP/1.1"
outReq.ProtoMajor = 1
outReq.ProtoMinor = 1
outReq.Close = false
glog.Infof("Proxying request to: %v", outReq)
outReq.Header = make(http.Header)
netutils.CopyHeaders(outReq.Header, req.Header)
if clientIP, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
// TODO(pquerna): configure this? Not all backends properly parse the header..
if TRUST_FORWARD_HEADER {
if prior, ok := outReq.Header["X-Forwarded-For"]; ok {
clientIP = strings.Join(prior, ", ") + ", " + clientIP
}
}
outReq.Header.Set("X-Forwarded-For", clientIP)
}
if req.TLS != nil {
outReq.Header.Set("X-Forwarded-Proto", "https")
} else {
outReq.Header.Set("X-Forwarded-Proto", "http")
}
if req.Host != "" {
outReq.Header.Set("X-Forwarded-Host", req.Host)
}
outReq.Header.Set("X-Forwarded-Server", vulcanHostname)
if len(cmd.RemoveHeaders) != 0 {
netutils.RemoveHeaders(cmd.RemoveHeaders, outReq.Header)
}
// Add generic instructions headers to the request
if len(cmd.AddHeaders) != 0 {
glog.Info("Proxying instructions headers:", cmd.AddHeaders)
netutils.CopyHeaders(outReq.Header, cmd.AddHeaders)
}
// Remove hop-by-hop headers to the backend. Especially
// important is "Connection" because we want a persistent
// connection, regardless of what the client sent to us.
netutils.RemoveHeaders(hopHeaders, outReq.Header)
return outReq
}
func (f *Forwarder) copyRequest(req *http.Request, u *url.URL) *http.Request {
outReq := new(http.Request)
*outReq = *req // includes shallow copies of maps, but we handle this below
outReq.URL = utils.CopyURL(req.URL)
outReq.URL.Scheme = u.Scheme
outReq.URL.Host = u.Host
// workaround for https://github.com/golang/go/issues/10433
outReq.URL.Opaque = mergeStartingSlashes(req.RequestURI)
// raw query is already included in RequestURI, so ignore it to avoid dupes
outReq.URL.RawQuery = ""
// Do not pass client Host header unless optsetter PassHostHeader is set.
if f.passHost != true {
outReq.Host = u.Host
}
outReq.Proto = "HTTP/1.1"
outReq.ProtoMajor = 1
outReq.ProtoMinor = 1
// Overwrite close flag so we can keep persistent connection for the backend servers
outReq.Close = false
outReq.Header = make(http.Header)
utils.CopyHeaders(outReq.Header, req.Header)
if f.rewriter != nil {
f.rewriter.Rewrite(outReq)
}
return outReq
}
// jsonRPCRead is the RPC wrapper around the jsonRead function to handles
// reading and responding to RPC messages.
func jsonRPCRead(w http.ResponseWriter, r *http.Request, s *rpcServer) {
r.Close = true
if atomic.LoadInt32(&s.shutdown) != 0 {
return
}
body, err := btcjson.GetRaw(r.Body)
if err != nil {
log.Errorf("RPCS: Error getting json message: %v", err)
return
}
// Error is intentionally ignored here. It's used in in the
// websocket handler to tell when a method is not supported by
// the standard RPC API, and is not needed here. Error logging
// is done inside jsonRead, so no need to log the error here.
reply, _ := jsonRead(body, s, nil)
log.Tracef("[RPCS] reply: %v", reply)
msg, err := btcjson.MarshallAndSend(reply, w)
if err != nil {
log.Errorf(msg)
return
}
log.Debugf(msg)
}
func (c *Client) Do(request *http.Request) (*http.Response, error) {
for headerKey, headerVal := range c.Authly.AuthMap {
request.Header.Add(headerKey, headerVal)
}
request.Close = true
response, err := c.HTTPClient.Do(request)
if err != nil {
return nil, err
}
supported := response.Header.Get(c.versionHeader)
format := `################################################################
WARNING: You're using an unsupported version of %s.
You must have at least version %s, your current
version is %s.
################################################################
`
if !validateVersion(supported, c.currentVersion) {
fmt.Println(format)
fmt.Println(supported)
}
if response.StatusCode > 399 {
defer response.Body.Close()
result, _ := ioutil.ReadAll(response.Body)
return response, errors.New(string(result))
}
return response, nil
}
func main() {
f, err := os.OpenFile("./file.exe", os.O_RDWR, 0666) //其实这里的 O_RDWR应该是 O_RDWR|O_CREATE，也就是文件不存在的情况下就建一个空文件，但是因为windows下还有BUG，如果使用这个O_CREATE，就会直接清空文件，所以这里就不用了这个标志，你自己事先建立好文件。
if err != nil {
panic(err)
}
stat, err := f.Stat() //获取文件状态
if err != nil {
panic(err)
}
f.Seek(stat.Size(), 0) //把文件指针指到文件末，当然你说为何不直接用 O_APPEND 模式打开，没错是可以。我这里只是试验。
url := "http://dl.google.com/chrome/install/696.57/chrome_installer.exe"
var req http.Request
req.Method = "GET"
//req.UserAgent = UA
req.Close = true
req.URL, err = http.ParseURL(url)
if err != nil {
panic(err)
}
header := http.Header{}
header.Set("Range", "bytes="+strconv.Itoa64(stat.Size)+"-")
req.Header = header
resp, err := http.DefaultClient.Do(&req)
if err != nil {
panic(err)
}
written, err := io.Copy(f, resp.Body)
if err != nil {
panic(err)
}
println("written: ", written)
}
func (proxy *Proxy) copyRequest(r *http.Request) *http.Request {
proxyRequest := new(http.Request)
*proxyRequest = *r
proxyRequest.Proto = "HTTP/1.1"
proxyRequest.ProtoMajor = 1
proxyRequest.ProtoMinor = 1
proxyRequest.Close = false
proxyRequest.Header = make(http.Header)
proxyRequest.URL.Scheme = "http"
proxyRequest.URL.Path = r.URL.Path
for key, values := range r.Header {
for _, value := range values {
proxyRequest.Header.Add(key, value)
}
}
for _, headerName := range ignoredHeaderNames {
proxyRequest.Header.Del(headerName)
}
if requestHost, _, err := net.SplitHostPort(r.RemoteAddr); err == nil {
if values, ok := proxyRequest.Header["X-Forwarded-For"]; ok {
requestHost = strings.Join(values, ", ") + ", " + requestHost
}
proxyRequest.Header.Set("X-Forwarded-For", requestHost)
}
return proxyRequest
}
// copyRequest creates a new proxy request with some modifications from an original request.
func copyRequest(originalRequest *http.Request) *http.Request {
pr := new(http.Request)
*pr = *originalRequest
pr.Proto = "HTTP/1.1"
pr.ProtoMajor = 1
pr.ProtoMinor = 1
pr.Close = false
pr.Header = make(http.Header)
pr.URL.Scheme = "http"
pr.URL.Path = originalRequest.URL.Path
// Copy all header fields.
for key, values := range originalRequest.Header {
for _, value := range values {
pr.Header.Add(key, value)
}
}
// Remove ignored header fields.
for _, header := range ignoredHeaderNames {
pr.Header.Del(header)
}
// Append this machine's host name into X-Forwarded-For.
if requestHost, _, err := net.SplitHostPort(originalRequest.RemoteAddr); err == nil {
if originalValues, ok := pr.Header["X-Forwarded-For"]; ok {
requestHost = strings.Join(originalValues, ", ") + ", " + requestHost
}
pr.Header.Set("X-Forwarded-For", requestHost)
}
return pr
}
func (f *Forwarder) copyRequest(req *http.Request, u *url.URL) *http.Request {
outReq := new(http.Request)
*outReq = *req // includes shallow copies of maps, but we handle this below
outReq.URL = utils.CopyURL(req.URL)
outReq.URL.Scheme = u.Scheme
outReq.URL.Host = u.Host
outReq.URL.Opaque = req.RequestURI
// raw query is already included in RequestURI, so ignore it to avoid dupes
outReq.URL.RawQuery = ""
// Go doesn't implicitly pass the host header unless you set Host on the request
outReq.Host = u.Host
outReq.Proto = "HTTP/1.1"
outReq.ProtoMajor = 1
outReq.ProtoMinor = 1
// Overwrite close flag so we can keep persistent connection for the backend servers
outReq.Close = false
outReq.Header = make(http.Header)
utils.CopyHeaders(outReq.Header, req.Header)
if f.rewriter != nil {
f.rewriter.Rewrite(outReq)
}
return outReq
}
// jsonRPCRead is the RPC wrapper around the jsonRead function to handle reading
// and responding to RPC messages.
func jsonRPCRead(w http.ResponseWriter, r *http.Request, s *rpcServer) {
r.Close = true
if atomic.LoadInt32(&s.shutdown) != 0 {
return
}
body, err := btcjson.GetRaw(r.Body)
if err != nil {
rpcsLog.Errorf("Error getting json message: %v", err)
return
}
var reply btcjson.Reply
cmd, jsonErr := parseCmd(body)
if cmd != nil {
// Unmarshaling at least a valid JSON-RPC message succeeded.
// Use the provided id for errors.
id := cmd.Id()
reply.Id = &id
}
if jsonErr != nil {
reply.Error = jsonErr
} else {
reply = standardCmdReply(cmd, s)
}
rpcsLog.Tracef("reply: %v", reply)
msg, err := btcjson.MarshallAndSend(reply, w)
if err != nil {
rpcsLog.Errorf(msg)
return
}
rpcsLog.Debugf(msg)
}
func Send(method string, url string, content []byte, headers map[string]string, user string, password string) (*http.Response, []byte) {
var req *http.Request
var err error
if content != nil {
req, err = http.NewRequest(method, url, bytes.NewBuffer(content))
} else {
req, err = http.NewRequest(method, url, nil)
}
CheckError(err)
req.Close = true
if user != "" && password != "" {
req.SetBasicAuth(user, password)
}
if headers != nil {
for name := range headers {
req.Header.Set(name, headers[name])
}
}
client := &http.Client{}
resp, err := client.Do(req)
CheckError(err)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
return resp, body
}
// submitRequest uses a given client and submits the specified request.
func (c *SecureContext) submitRequest(rw http.ResponseWriter, req *http.Request, url string, client *http.Client, responseHandler ResponseHandler) {
// Prevents lingering goroutines from living forever.
// http://stackoverflow.com/questions/16895294/how-to-set-timeout-for-http-get-requests-in-golang/25344458#25344458
client.Timeout = 5 * time.Second
// In case the body is not of io.Closer.
if req.Body != nil {
defer req.Body.Close()
}
req.Close = true
// Make a new request.
request, _ := http.NewRequest(req.Method, url, req.Body)
// In case the body is not of io.Closer.
if request.Body != nil {
defer request.Body.Close()
}
request.Close = true
// Send the request.
res, err := client.Do(request)
if res != nil {
defer res.Body.Close()
}
if err != nil {
rw.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(rw, "unknown error. try again")
return
}
// Should return the same status.
rw.WriteHeader(res.StatusCode)
responseHandler(&rw, res)
}
func download(dictId string, dictNum string, downUrl string) {
fileName := SAVEPATH + dictId + "-" + dictNum + ".scel"
f, err := os.OpenFile(fileName, os.O_RDWR|os.O_CREATE, 0666) //其实这里的 O_RDWR应该是 O_RDWR|O_CREATE，也就是文件不存在的情况下就建一个空文件，但是因为windows下还有BUG，如果使用这个O_CREATE，就会直接清空文件，所以这里就不用了这个标志，你自己事先建立好文件。
if err != nil {
panic(err)
}
defer f.Close()
var req http.Request
req.Method = "GET"
req.Close = true
req.URL, _ = url.Parse(downUrl)
header := http.Header{}
header.Set("User-Agent", UA)
header.Set("Host", HOST)
header.Set("Referer", REFERER+dictId)
req.Header = header
resp, err := http.DefaultClient.Do(&req)
if err == nil {
if resp.StatusCode == 200 {
fmt.Println(dictId + ":sucess")
_, err = io.Copy(f, resp.Body)
if err != nil {
panic(err)
}
} else {
fmt.Println(dictId + ":" + strconv.Itoa(resp.StatusCode))
}
defer resp.Body.Close()
} else {
fmt.Println(dictId + ":error")
}
}
func (l *HttpLocation) copyRequest(req *http.Request, body netutils.MultiReader, endpoint endpoint.Endpoint) *http.Request {
outReq := new(http.Request)
*outReq = *req // includes shallow copies of maps, but we handle this below
// Set the body to the enhanced body that can be re-read multiple times and buffered to disk
outReq.Body = body
endpointURL := endpoint.GetUrl()
outReq.URL.Scheme = endpointURL.Scheme
outReq.URL.Host = endpointURL.Host
outReq.URL.Opaque = req.RequestURI
// raw query is already included in RequestURI, so ignore it to avoid dupes
outReq.URL.RawQuery = ""
outReq.Proto = "HTTP/1.1"
outReq.ProtoMajor = 1
outReq.ProtoMinor = 1
// Overwrite close flag so we can keep persistent connection for the backend servers
outReq.Close = false
outReq.Header = make(http.Header)
netutils.CopyHeaders(outReq.Header, req.Header)
return outReq
}
func (c *Client) Do(request *http.Request) (*http.Response, error) {
if token, err := readToken(); err == nil {
request.Header.Set("Authorization", "bearer "+token)
}
request.Close = true
response, err := c.HTTPClient.Do(request)
err = c.detectClientError(err)
if err != nil {
return nil, err
}
supported := response.Header.Get(c.versionHeader)
format := `################################################################
WARNING: You're using an unsupported version of %s.
You must have at least version %s, your current
version is %s.
Please go to http://docs.tsuru.io/en/latest/install/client.html
and download the last version.
################################################################
`
if !validateVersion(supported, c.currentVersion) {
fmt.Fprintf(c.context.Stderr, format, c.progname, supported, c.currentVersion)
}
if response.StatusCode > 399 {
defer response.Body.Close()
result, _ := ioutil.ReadAll(response.Body)
return response, errors.New(string(result))
}
return response, nil
}
func getCodes() {
//并发写文件必须要有锁啊，怎么还是串行程序的思维啊。
fileName := "./data/data.html"
f, err := os.Create(fileName) //其实这里的 O_RDWR应该是 O_RDWR|O_CREATE，也就是文件不存在的情况下就建一个空文件，但是因为windows下还有BUG，如果使用这个O_CREATE，就会直接清空文件，所以这里就不用了这个标志，你自己事先建立好文件。
if err != nil {
panic(err)
}
defer f.Close()
urls := "http://quote.eastmoney.com/stocklist.html"
var req http.Request
req.Method = "GET"
req.Close = true
req.URL, err = url.Parse(urls)
if err != nil {
panic(err)
}
header := http.Header{}
header.Set("User-Agent", UA)
req.Header = header
resp, err := http.DefaultClient.Do(&req)
if err == nil {
if resp.StatusCode == 200 {
io.Copy(f, resp.Body)
} else {
fmt.Println("http get StatusCode")
}
defer resp.Body.Close()
} else {
fmt.Println("http get error")
}
}
func (p *ReverseProxy) ServeHTTP(req *http.Request) (*http.Response, error) {
transport := p.Transport
if transport == nil {
transport = http.DefaultTransport
}
outreq := new(http.Request)
*outreq = *req // includes shallow copies of maps, but okay
p.Director(outreq)
outreq.Proto = "HTTP/1.1"
outreq.ProtoMajor = 1
outreq.ProtoMinor = 1
outreq.Close = false
// Remove hop-by-hop headers to the backend. Especially
// important is "Connection" because we want a persistent
// connection, regardless of what the client sent to us. This
// is modifying the same underlying map from req (shallow
// copied above) so we only copy it if necessary.
copiedHeaders := false
for _, h := range hopHeaders {
if outreq.Header.Get(h) != "" {
if !copiedHeaders {
outreq.Header = make(http.Header)
copyHeader(outreq.Header, req.Header)
copiedHeaders = true
}
outreq.Header.Del(h)
}
}
if clientIP, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
// If we aren't the first proxy retain prior
// X-Forwarded-For information as a comma+space
// separated list and fold multiple headers into one.
if prior, ok := outreq.Header["X-Forwarded-For"]; ok {
clientIP = strings.Join(prior, ", ") + ", " + clientIP
}
outreq.Header.Set("X-Forwarded-For", clientIP)
}
res, err := transport.RoundTrip(outreq)
if err != nil {
return res, err
}
for _, p := range *p.Plugins {
p.Outbound(res)
}
for _, h := range hopHeaders {
res.Header.Del(h)
}
return res, nil
}
func (s *Session) Write(r *http.Request, t int) *Error {
// session must be active to perform write
if !s.IsOpen() {
return ErrorTranscodeFailed
}
log.Printf("Writing data from client %s to session %d", r.RemoteAddr, s.UID)
// check request compatibility (mime type, content)
if err := s.ValidateRequest(r, t); err != nil {
return err
}
// reset session close timeout (potential race condition with timeout handler)
s.Timer.Stop()
// go live
s.live = true
// leave live state on exit
defer func() { s.live = false }()
// push data into pipe until body is empty or EOF (broken pipe)
written, err := io.Copy(s.Pipe, r.Body)
log.Printf("Written %d bytes to session %d", written, s.UID)
// collect session statistics
s.CallsIn++
s.BytesIn += r.ContentLength
s.BytesOut += written
// error handling
if err == nil && written == 0 {
// normal session close on source request (empty body)
log.Printf("Closing session %d down for good", s.UID)
// close the http session
r.Close = true
s.Close()
r.Body.Close()
return nil
} else if err != nil {
// session close due to broken pipe (transcoder)
log.Printf("Closing session %d on broken pipe.", s.UID)
s.Close()
r.Body.Close()
return ErrorTranscodeFailed
}
r.Body.Close()
// restart timer on success
s.Timer = time.AfterFunc(time.Duration(s.c.Server.Session_timeout)*time.Second,
func() { s.HandleTimeout() })
return nil
}
func forward(w http.ResponseWriter, r *http.Request) {
id := r.FormValue("id")
body := r.FormValue("body")
log.Println("the body", body)
ConnectedClients[id].Write([]byte(body))
log.Println(r.Body.Close())
r.Close = true
io.WriteString(w, "\n")
}
func prepareRequest(req *http.Request) *http.Request {
outreq := new(http.Request)
*outreq = *req // includes shallow copies of maps, but okay
// Pass the Request-URI verbatim without any modifications.
//
// NOTE: An exception must be made if the Request-URI is a path
// beginning with "//" (e.g. "//foo/bar") because then
// req.URL.RequestURI() would interpret req.URL.Opaque as being a URI
// with the scheme stripped and so generate a URI like scheme:opaque
// (e.g. "http://foo/bar") which would be incorrect, see:
// https://github.com/golang/go/blob/f75aafd/src/net/url/url.go#L913-L931
//
// It is ok to make this exception because the fallback to
// req.URL.EscapedPath will generate the correct Request-URI.
if !strings.HasPrefix(req.RequestURI, "//") {
outreq.URL.Opaque = strings.Split(strings.TrimPrefix(req.RequestURI, req.URL.Scheme+":"), "?")[0]
}
outreq.URL.Scheme = "http"
outreq.Proto = "HTTP/1.1"
outreq.ProtoMajor = 1
outreq.ProtoMinor = 1
outreq.Close = false
// Remove hop-by-hop headers to the backend.
outreq.Header = make(http.Header)
copyHeader(outreq.Header, req.Header)
for _, h := range hopHeaders {
outreq.Header.Del(h)
}
// remove the Upgrade header and headers referenced in the Connection
// header if HTTP < 1.1 or if Connection header didn't contain "upgrade":
// https://tools.ietf.org/html/rfc7230#section-6.7
if !req.ProtoAtLeast(1, 1) || !isConnectionUpgrade(req.Header) {
outreq.Header.Del("Upgrade")
// Especially important is "Connection" because we want a persistent
// connection, regardless of what the client sent to us.
outreq.Header.Del("Connection")
// A proxy or gateway MUST parse a received Connection header field before a
// message is forwarded and, for each connection-option in this field, remove
// any header field(s) from the message with the same name as the
// connection-option, and then remove the Connection header field itself (or
// replace it with the intermediary's own connection options for the
// forwarded message): https://tools.ietf.org/html/rfc7230#section-6.1
tokens := strings.Split(req.Header.Get("Connection"), ",")
for _, hdr := range tokens {
outreq.Header.Del(hdr)
}
}
return outreq
}
func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, outreq *http.Request, respUpdateFn respUpdateFn) error {
transport := p.Transport
if transport == nil {
transport = http.DefaultTransport
}
p.Director(outreq)
outreq.Proto = "HTTP/1.1"
outreq.ProtoMajor = 1
outreq.ProtoMinor = 1
outreq.Close = false
res, err := transport.RoundTrip(outreq)
if err != nil {
return err
} else if respUpdateFn != nil {
respUpdateFn(res)
}
if res.StatusCode == http.StatusSwitchingProtocols && strings.ToLower(res.Header.Get("Upgrade")) == "websocket" {
res.Body.Close()
hj, ok := rw.(http.Hijacker)
if !ok {
return nil
}
conn, _, err := hj.Hijack()
if err != nil {
return err
}
defer conn.Close()
backendConn, err := net.Dial("tcp", outreq.URL.Host)
if err != nil {
return err
}
defer backendConn.Close()
outreq.Write(backendConn)
go func() {
io.Copy(backendConn, conn) // write tcp stream to backend.
}()
io.Copy(conn, backendConn) // read tcp stream from backend.
} else {
defer res.Body.Close()
for _, h := range hopHeaders {
res.Header.Del(h)
}
copyHeader(rw.Header(), res.Header)
rw.WriteHeader(res.StatusCode)
p.copyResponse(rw, res.Body)
}
return nil
}
func (c *Client) newRequest(method, apiPath string, options *RequestOptions) (*http.Request, error) {
if c.client == nil {
return nil, errors.New("Client has not been authenticated")
}
urlPath := path.Join("api", apiVersion, apiPath)
if options != nil && options.QueryParams != nil && len(*options.QueryParams) > 0 {
urlPath = urlPath + "?" + options.QueryParams.Encode()
}
rel, err := url.Parse(urlPath)
if err != nil {
return nil, err
}
u := c.BaseUrl.ResolveReference(rel)
buf := new(bytes.Buffer)
if options != nil && options.JsonBody != nil {
err := json.NewEncoder(buf).Encode(options.JsonBody)
if err != nil {
return nil, err
}
}
var req *http.Request
if options != nil && options.RawBody != nil {
req, err = http.NewRequest(method, u.String(), options.RawBody)
req.ContentLength = options.RawBodyLength
} else {
req, err = http.NewRequest(method, u.String(), buf)
}
if err != nil {
return nil, err
}
req.Close = true
req.TransferEncoding = []string{"identity"}
req.Header.Add("Accept", "application/json")
req.Header.Add("User-Agent", c.UserAgent)
if options != nil && options.JsonBody != nil {
req.Header.Set("Content-Type", "application/json")
}
if options != nil && options.Headers != nil {
for key, value := range *options.Headers {
req.Header.Set(key, value)
}
}
return req, nil
}
func ShutdownRequestHandler(w *bytes.Buffer, req *http.Request) error {
LogRequest("Shutdown", req)
req.Close = true
log.Critical("[Quit Gracefully]")
os.Exit(1)
return nil
}
func download(downUrl1 string) {
str := strings.Split(downUrl1, ".")
dirPath := SAVEPATH + str[0]
fileName := SAVEPATH + downUrl1
var downUrl string
if downUrl1[0:1] == "/" {
downUrl = HOST + downUrl1
} else {
downUrl = downUrl1
}
fmt.Print(downUrl)
fmt.Print("\n")
if !isDirExists(dirPath) { //目录不存在，则进行创建。
err := os.MkdirAll(dirPath, 777) //递归创建目录，linux下面还要考虑目录的权限设置。
if err != nil {
panic(err)
}
}
f, err := os.OpenFile(fileName, os.O_RDWR|os.O_CREATE, 0666) //其实这里的 O_RDWR应该是 O_RDWR|O_CREATE，也就是文件不存在的情况下就建一个空文件，但是因为windows下还有BUG，如果使用这个O_CREATE，就会直接清空文件，所以这里就不用了这个标志，你自己事先建立好文件。
if err != nil {
panic(err)
}
defer f.Close()
var req http.Request
req.Method = "GET"
req.Close = true
req.URL, _ = url.Parse(downUrl)
header := http.Header{}
header.Set("User-Agent", UA)
header.Set("Host", HOST)
req.Header = header
resp, err := http.DefaultClient.Do(&req)
if err == nil {
if resp.StatusCode == 200 {
fmt.Println(":sucess")
_, err = io.Copy(f, resp.Body)
if err != nil {
panic(err)
}
} else {
fmt.Println(strconv.Itoa(resp.StatusCode))
}
defer resp.Body.Close()
} else {
fmt.Println(":error")
}
}