package main

 import (

     "context"

     "flag"

     "fmt"

     "log"

     "net"

     "net/http"

     "net/http/httputil"

     "net/url"

     "strings"

     "sync"

     "sync/atomic"

     "time"

 )

 const (

     Attempts int = iota

     Retry

 )

 //定义结构体

 //后端保存关于服务器的数据

 type Backend struct {

     URL          *url.URL

     Alive        bool

     mux          sync.RWMutex

     ReverseProxy *httputil.ReverseProxy

 }

 //跟踪所有后端，以及一个计算器变量

 type ServerPool struct {

     backends []*Backend

     current  uint64

 }

 // SetAlive

 func (b *Backend) SetAlive(alive bool) {

     b.mux.Lock()

     b.Alive = alive

     b.mux.Unlock()

 }

 // 如果后端还活着，IsAlive 返回 true

 func (b *Backend) IsAlive() (alive bool) {

     b.mux.RLock()

     alive = b.Alive

     b.mux.RUnlock()

     return

 }

 // lb 对入向请求进行负载均衡

 func lb(w http.ResponseWriter, r *http.Request) {

     //重试次数，如果已经达到最大上限，就终结这个请求

     attempts := GetAttemptsFromContext(r)

     if attempts >  {

         log.Printf("%s(%s) Max attempts reached, terminating\n", r.RemoteAddr, r.URL.Path)

         http.Error(w, "Service not available", http.StatusServiceUnavailable)

         return

     }

     peer := serverPool.GetNextPeer()

     if peer != nil {

         peer.ReverseProxy.ServeHTTP(w, r)

         return

     }

     http.Error(w, "Service not available", http.StatusServiceUnavailable)

 }

 // 自动增加计数器并返回一个索引，使用atomic 保证原子性

 //通过原子操作递增 current 的值，并通过对 slice 的长度取模来获得当前索引值。所以，返回值总是介于 0 和 slice 的长度之间，毕竟我们想要的是索引值，而不是总的计数值。

 func (s *ServerPool) NextIndex() int {

     return int(atomic.AddUint64(&s.current, uint64()) % uint64(len(s.backends)))

 }

 // GetNextPeer返回下一个活动的对等点以获取连接

 //找到可用的服务器后，我们将它标记为当前可用服务器。

 func (s *ServerPool) GetNextPeer() *Backend {

     // 循环整个后端，找出一个活动后端

     next := s.NextIndex()

     l := len(s.backends) + next // 从next开始移动一个完整的周期

     for i := next; i < l; i++ {

         idx := i % len(s.backends)     // take an index by modding

         if s.backends[idx].IsAlive() { // if we have an alive backend, use it and store if its not the original one

             if i != next {

                 atomic.StoreUint64(&s.current, uint64(idx))

             }

             return s.backends[idx]

         }

     }

     return nil

 }

 // GetAttemptsFromContext 返回尝试次数

 func GetRetryFromContext(r *http.Request) int {

     if retry, ok := r.Context().Value(Retry).(int); ok {

         return retry

     }

     return

 }

 // healthCheck runs a routine for check status of the backends every 2 mins

 // healthCheck 返回一个 routine，每 2 分钟检查一次后端的状态

 func healthCheck() {

     t := time.NewTicker(time.Second * )

     for {

         select {

         case <-t.C:

             log.Println("Starting health check...")

             serverPool.HealthCheck()

             log.Println("Health check completed")

         }

     }

 }

 // HealthCheck ping后端并更新状态

 func (s *ServerPool) HealthCheck() {

     for _, b := range s.backends {

         status := "up"

         alive := isBackendAlive(b.URL)

         b.SetAlive(alive)

         if !alive {

             status = "down"

         }

         log.Printf("%s [%s]\n", b.URL, status)

     }

 }

 // isAlive checks whether a backend is Alive by establishing a TCP connection

 // isAlive 通过建立 TCP 连接检查后端是否还活着

 func isBackendAlive(u *url.URL) bool {

     timeout :=  * time.Second

     conn, err := net.DialTimeout("tcp", u.Host, timeout)

     if err != nil {

         log.Println("Site unreachable, error: ", err)

         return false

     }

     _ = conn.Close() // 不需要维护连接，把它关闭

     return true

 }

 // GetAttemptsFromContext returns the attempts for request

 func GetAttemptsFromContext(r *http.Request) int {

     if attempts, ok := r.Context().Value(Attempts).(int); ok {

         return attempts

     }

     return

 }

 // AddBackend to the server pool

 func (s *ServerPool) AddBackend(backend *Backend) {

     s.backends = append(s.backends, backend)

 }

 // MarkBackendStatus changes a status of a backend

 func (s *ServerPool) MarkBackendStatus(backendURL *url.URL, alive bool) {

     for _, b := range s.backends {

         if b.URL.String() == backendURL.String() {

             b.SetAlive(alive)

             break

         }

     }

 }

 var serverPool ServerPool

 func main() {

     var serverList string

     var port int

     flag.StringVar(&serverList, "backends", "http://localhost:3302,http://localhost:3303,http://localhost:3304", "Load balanced backends, use commas to separate")

     flag.IntVar(&port, "port", , "Port to serve")

     flag.Parse()

     if len(serverList) ==  {

         log.Fatal("Please provide one or more backends to load balance")

     }

     // 解析服务器

     tokens := strings.Split(serverList, ",")

     //range类似迭代器，可以遍历

     for _, tok := range tokens {

         serverURL, err := url.Parse(tok)

         if err != nil {

             log.Fatal(err)

         }

         //使用 httputil.NewSingleHostReverseProxy(url) 初始化一个反向代理

         proxy := httputil.NewSingleHostReverseProxy(serverURL)

         //在发生错误时，ReverseProxy 会触发 ErrorHandler 回调函数，我们可以利用它来检查故障。

         proxy.ErrorHandler = func(writer http.ResponseWriter, request *http.Request, e error) {

             log.Printf("[%s] %s\n", serverURL.Host, e.Error())

             retries := GetRetryFromContext(request)

             if retries <  {

                 select {

                 case <-time.After( * time.Millisecond):

                     ctx := context.WithValue(request.Context(), Retry, retries+)

                     proxy.ServeHTTP(writer, request.WithContext(ctx))

                 }

                 return

             }

             // 在三次重试之后，把这个后端标记为宕机

             serverPool.MarkBackendStatus(serverURL, false)

             // 同一个请求在尝试了几个不同的后端之后，增加计数

             attempts := GetAttemptsFromContext(request)

             log.Printf("%s(%s) Attempting retry %d\n", request.RemoteAddr, request.URL.Path, attempts)

             ctx := context.WithValue(request.Context(), Attempts, attempts+)

             lb(writer, request.WithContext(ctx))

         }

         serverPool.AddBackend(&Backend{

             URL:          serverURL,

             Alive:        true,

             ReverseProxy: proxy,

         })

         log.Printf("Configured server: %s\n", serverURL)

     }

     // 初始化服务器，并添加处理器

     // create http server

     server := http.Server{

         Addr:    fmt.Sprintf(":%d", port),

         Handler: http.HandlerFunc(lb),

     }

     // start health checking

     go healthCheck()

     log.Printf("Load Balancer started at :%d\n", port)

     if err := server.ListenAndServe(); err != nil {

         log.Fatal(err)

     }

 }

package main

import (

    "flag"

    "fmt"

    "log"

    "net/http"

    "strconv"

)

func sayhelloName(w http.ResponseWriter, r *http.Request) {

    r.ParseForm()                                //解析参数，默认是不会解析的

    fmt.Fprintln(w, "Hello moon!")               //这个写入到w的是输出到客户端的

    fmt.Fprintln(w, "count:"+strconv.Itoa(port)) //这个写入到w的是输出到客户端的

    count++

    fmt.Fprintln(w, "count:"+strconv.Itoa(count)) //这个写入到w的是输出到客户端的

}

var port int

var count int

func main() {

    flag.IntVar(&port, "port", , "duan端口号，默认3302")

    // 【必须调用】从 arguments 中解析注册的 flag

    flag.Parse()

    fmt.Printf("port=%v \n", port)

    http.HandleFunc("/", sayhelloName)                      //设置访问的路由

    err := http.ListenAndServe(":"+strconv.Itoa(port), nil) //设置监听的端口

    if err != nil {

        log.Fatal("ListenAndServe: ", err)

    }

}