post: golang context and di

1a. Initial Middleware.go

func AddMessageMiddleware(message string, next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    oldCtx := nil         // Get context from request
    newCtx := oldCtx      // modify context
    next.ServeHTTP(w, r)  // pass request to child handler
  })
}

1b. Middleware with context.go

func AddMessageMiddleware(message string, next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    oldCtx := r.Context()                     // Get context from request
    newCtx := oldCtx                          // modify context
    next.ServeHTTP(w, r.WithContext(newCtx))  // pass request to child handler
  })
}

1c. Middleware with context value.go

func AddMessageMiddleware(message string, next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    oldCtx := r.Context()                                   // Get context from request
    newCtx := context.WithValue(oldCtx, "message", message) // modify context
    next.ServeHTTP(w, r.WithContext(newCtx))                // pass request to child handler
  })
}

1d. Middleware cleaned.go

const MessageContextKey = "message"

func AddMessageMiddleware(message string, next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    ctx := context.WithValue(r.Context(), MessageContextKey, message)
    next.ServeHTTP(w, r.WithContext(ctx))
  })
}

1e. Middleware handler.go

func RespondWithMessage(w http.ResponseWriter, r *http.Request) {
  message := r.Context().Value(MessageContextKey)
  if message == nil {
    http.Error(w, "No message provided", http.StatusInternalServerError)
  } else {
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(message.(string)))  // possible panic from conversion
  }
}

1f. Middleware useage.go

func main() {
  helloHandler := AddMessageMiddleware("Hello!", http.HandlerFunc(RespondWithMessage))
  goodbyeHandler := AddMessageMiddleware("Goodbye!", http.HandlerFunc(RespondWithMessage))
  noMessageHandler := http.HandlerFunc(RespondWithMessage)

  mux := new(http.ServeMux)
  mux.Handle("/hello", helloHandler)
  mux.Handle("/goodbye", goodbyeHandler)
  mux.Handle("/error", noMessageHandler)

  http.ListenAndServe(":8000", mux)
}

2. Context DI.go

const MyDependencyContextKey = ""

type MyDependency interface {
  Value() string
}

func MyHandler(w http.ResponseWriter, r *http.Request) {
  myDependency := r.Context().Value(MyDependencyContextKey)
  if myDependency == nil {
    http.Error(w, "MyDependency does not exist", http.StatusInternalServerError)
    return
  } else {
    dependency, ok := myDependency.(MyDependency)
    if ok {
      w.WriteHeader(http.StatusOK)
      w.Write([]byte(dependency.Value()))
    } else {
      http.Error(w, ""MyDependency is of the wrong type."", http.StatusInternalServerError)
    }
  }
}

3a. struct DI sependencies.go

type Database interface {  }

type UserManager interface {
  GetUser(id int) (User, error)
  AuthenticateUser(username, password string) (int, error)
}

type User interface {
  Id() int
  Name() string
}

3b. struct DI constructors.go

func NewPooledDatabaseConnection(url string) Database { ... }

func NewDatabaseUserManager(databaseConn Database) UserManager { ... }

3c. struct DI auth middleware.go

const UserIdContextKey = "UserId"

type Authenticator interface {
  Authenticate(next http.Handler) http.Handler
}

type basicAuthenticator struct {
  UserManager UserManager
}

func NewBasicAuthenticator(UserManager UserManager) Authenticator {
  return basicAuthenticator{UserManager: UserManager}
}

func (a basicAuthenticator) Authenticate(next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    username, password, ok := r.BasicAuth()
    if ok {
      userId, err := a.UserManager.AuthenticateUser(username, password)
      if err == nil {
				ctx := context.WithValue(r.Context(), UserIdContextKey, userId)
        next.ServeHTTP(w, r.WithContext(ctx))
      } else {
        a.showLogin(w)
      }
    } else {
      a.showLogin(w)
    }
  })
}

func (a basicAuthenticator) showLogin(w http.ResponseWriter) {
  w.Header().Set("WWW-Authenticate", "Basic realm=\"Login\"")
  http.Error(w, "Requires Login", http.StatusUnauthorized)
}

3d.struct DI handler.go

type userHttpHandler struct {
  userManager UserManager
}

func NewUserHttpHandler(userManager UserManager) http.Handler {
  return userHttpHandler{userManager: userManager}
}

func (h userHttpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  if r.Method == http.MethodGet {
    userId := r.Context().Value(UserIdContextKey)
    if userId == nil {
      http.Error(w, "No user", http.StatusInternalServerError)
    } else {
      user, err := h.userManager.GetUser(userId.(int))
      if err == nil {
        w.Header().Set("Content-Type", "text/plain")
        w.WriteHeader(http.StatusOK)
        fmt.Fprintf(w, "Hello %s!", user.Name())
      } else {
        http.Error(w, "No user", http.StatusNotFound)
      }
    }
  } else {
    http.Error(w, "Invalid Method", http.StatusMethodNotAllowed)
  }
}

3e. struct DI example.go

func main() {
  // create dependencies
  databaseConn := NewPooledDatabaseConnection("user:pass@localhost:3000")
  userManager := NewDatabaseUserManager(databaseConn)

  // setup handler
  authenticator := NewBasicAuthenticator(userManager)
  userHttpHandler := NewUserHttpHandler(userManager)

  // create and run the server
  mux := http.NewServeMux()
  mux.Handle("/user", userHttpHandler)

  server := &http.Server{
    Addr: ":8080",
    Handler: authenticator.Authenticate(mux),
  }
  err := server.ListenAndServe()
	if err != nil {
		fmt.Println(err.Error())
	}
}

3f. struct DI facebookgo-inject.go

type userHttpHandler struct {
  UserManager UserManager `inject:""`
}