func serve(ctx *cli.Context) error {
clientID := ctx.String("client-id")
clientSecret := ctx.String("client-secret")
var config settings.Config
var err error
if ctx.String("config") != "" {
config, err = settings.Parse(ctx.String("config"))
if err != nil {
logs.Error(err)
}
}
if config.Debug() {
logs.Level(logs.DebugLevel)
}
redisSettings, err := config.Redis()
client := redis.NewClient(&redis.Options{Addr: redisSettings.String()})
if _, err := client.Ping().Result(); err != nil {
return err
}
logs.Debug("Connected to Redis at %s", redisSettings.String())
store := components.NewRedisStore(client)
proxy := goproxy.NewProxyHttpServer()
if config.Debug() {
proxy.Verbose = true
}
// Treat only requests with an SID cookie or POSTing username and password.
var session = goproxy.ReqConditionFunc(func(req *http.Request, ctx *goproxy.ProxyCtx) bool {
_, err := req.Cookie("SID")
return err == nil || (req.Method == "POST" && req.FormValue("username") != "" && req.FormValue("password") != "") // The form is already parsed.
})
proxy.NonproxyHandler = http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
dump, _ := httputil.DumpRequest(req, true)
fmt.Println(string(dump))
req.URL.Scheme = req.Header.Get("X-Scheme")
req.URL.Host = req.Host
proxy.ServeHTTP(w, req)
})
proxy.OnRequest(session).DoFunc(
func(req *http.Request, ctx *goproxy.ProxyCtx) (*http.Request, *http.Response) {
//dump, _ := httputil.DumpRequest(req, true)
//fmt.Println(string(dump))
cookie, err := req.Cookie("SID")
if err == nil {
session, err := store.Load(cookie.Value)
if err != nil {
return req, goproxy.NewResponse(req, "text/plain", http.StatusForbidden, "Invalid cookie")
}
req.Header.Del("Cookie")
req.Header.Add("Authorization", "Bearer "+session.AccessToken)
return req, nil
}
// Perform an OAuth "Resource Owner Password Credentials Grant"
req.Form.Add("grant_type", "password")
req.SetBasicAuth(clientID, clientSecret)
// We must update the body and the content size for our new post value.
var buffer io.Reader = strings.NewReader(req.Form.Encode())
req.Body = ioutil.NopCloser(buffer)
switch v := buffer.(type) {
case *bytes.Buffer:
req.ContentLength = int64(v.Len())
case *bytes.Reader:
req.ContentLength = int64(v.Len())
case *strings.Reader:
req.ContentLength = int64(v.Len())
}
//req.RequestURI = "" // Must be removed for client requests
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return req, nil
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return req, nil
}
// TODO: Check http status for errors
access := new(components.AccessData)
if err := json.Unmarshal(body, access); err != nil {
return req, nil
}
session := &components.Session{
ID: strings.TrimRight(base64.StdEncoding.EncodeToString(uuid.NewRandom()), "="),
AccessToken: access.AccessToken,
RefreshToken: access.RefreshToken,
ExpiresIn: access.ExpiresIn,
}
if err := store.Save(session); err != nil {
return req, nil
}
// TODO: Give a json response to clients
resp = goproxy.NewResponse(req, "text/plain", http.StatusOK, "")
cookie = &http.Cookie{Name: "SID", Value: session.ID}
resp.Header.Add("Set-Cookie", cookie.String())
return req, resp
},
)
server, err := config.Server()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Info("Listening on %s", server.String())
return http.ListenAndServe(server.String(), proxy)
}
func serve(ctx *cli.Context) error {
var err error
var config settings.Config
if ctx.String("config") != "" {
config, err = settings.Parse(ctx.String("config"))
if err != nil {
logs.Error(err)
}
}
if config.Debug() {
logs.Level(logs.DebugLevel)
}
dialect, args, err := config.SqlDB()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("database type: %s", dialect)
var app = application.New()
if app.Components["DB"], err = databases.InitGORM(dialect, args); err != nil {
logs.Critical(err)
os.Exit(1)
}
logs.Debug("connected to %s", args)
if config.Migrate() {
app.Components["DB"].(*gorm.DB).AutoMigrate(models.Models()...)
logs.Debug("database migrated successfully")
}
redisSettings, err := config.Redis()
client := redis.NewClient(&redis.Options{Addr: redisSettings.String()})
if _, err := client.Ping().Result(); err != nil {
return err
}
logs.Debug("Connected to Redis at %s", redisSettings.String())
app.Components["Redis"] = client
cfg := osin.NewServerConfig()
cfg.AllowedAuthorizeTypes = osin.AllowedAuthorizeType{osin.CODE, osin.TOKEN}
cfg.AllowedAccessTypes = osin.AllowedAccessType{osin.AUTHORIZATION_CODE,
osin.REFRESH_TOKEN, osin.PASSWORD}
oauthServer := osin.NewServer(cfg, components.NewRedisStorage(client))
app.Components["OAuth"] = oauthServer
app.Components["Templates"] = views.Templates()
app.Components["Mux"] = gojimux.New()
if config.Debug() {
app.Components["DB"].(*gorm.DB).LogMode(true)
app.Use(router.Logger)
}
app.Use(app.Apply)
app.Get("/oauth2/authorize", controllers.Authorize)
app.Post("/oauth2/token", controllers.Token)
app.Get("/oauth2/info", controllers.Info)
app.Post("/users/register", controllers.Register)
app.Get("/users/:id", controllers.RetrieveUser)
app.Get("/groups", controllers.RetrieveGroupCollection)
app.Post("/groups", controllers.CreateGroup)
app.Get("/groups/:id", controllers.RetrieveGroup)
app.Delete("/groups/:id", controllers.DeleteGroup)
app.Patch("/groups/:id", controllers.UpdateGroup)
server, err := config.Server()
if err != nil {
logs.Critical(err)
os.Exit(1)
}
return app.Serve(server.String())
}