package/token-go
1
0
Fork 0
mirror of https://github.com/weloe/token-go.git synced 2025-10-05 23:46:52 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

feat: add sso-server, sso-client config examples

Browse Source
This commit is contained in:
weloe
2023-07-24 12:43:27 +08:00
parent 4aa6df57df
commit a3d97bece9
3 changed files with 274 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Readme.md
View File

@@ -190,7 +190,9 @@ func CheckAuth(w http.ResponseWriter, req *http.Request) {
} }
``` ```
## SSO ## SSO
SSO-Server examples: https://github.com/weloe/token-go/blob/master/examples/sso/sso-server/sso-server.go
SSO-Client examples: https://github.com/weloe/token-go/blob/master/examples/sso/sso-client-3/sso-client.go
## Api ## Api

132
examples/sso/sso-client-3/sso-client.go Normal file
View File

@@ -0,0 +1,132 @@
package main
import (
"encoding/json"
"fmt"
tokenGo "github.com/weloe/token-go"
"github.com/weloe/token-go/config"
"github.com/weloe/token-go/model"
"github.com/weloe/token-go/sso"
"io"
"io/ioutil"
"log"
"net/http"
"strconv"
"strings"
)
var enforcer *tokenGo.Enforcer
var ssoEnforcer *sso.SsoEnforcer
func main() {
var err error
// use default adapter
adapter := tokenGo.NewDefaultAdapter()
enforcer, err = tokenGo.NewEnforcer(adapter)
if err != nil {
log.Fatal(err)
}
// enable logger
enforcer.EnableLog()
ssoOptions := &config.SsoOptions{
AuthUrl: "/sso/auth",
IsSlo: true,
IsHttp: true,
SloUrl: "/sso/signout",
CheckTicketUrl: "/sso/checkTicket",
ServerUrl: "http://token-go-sso-server.com:9000",
SendHttp: func(url string) (string, error) {
response, err := http.Get(url)
if err != nil {
log.Printf("http.Get() failed: %v", err)
return "", err
}
defer func(Body io.ReadCloser) {
err = Body.Close()
if err != nil {
log.Printf("read response body failed: %v", err)
}
}(response.Body)
body, err := ioutil.ReadAll(response.Body)
if err != nil {
log.Printf("ioutil.ReadAll() failed: %v", err)
return "", err
}
return string(body), nil
},
}
signOptions := &config.SignOptions{
SecretKey: "kQwIOrYvnXmSDkwEiFngrKidMcdrgKor",
IsCheckNonce: true,
}
ssoEnforcer, err = sso.NewSsoEnforcer(&sso.Options{
SsoOptions: ssoOptions,
SignOptions: signOptions,
Enforcer: enforcer,
})
if err != nil {
log.Fatalf("NewSsoEnforcer() failed: %v", err)
}
engine := new(Engine)
log.Fatal(http.ListenAndServe(":9001", engine))
}
// Engine is the uni handler for all requests
type Engine struct{}
func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if req.URL.String() == "/" {
isLogin, err := enforcer.IsLogin(tokenGo.NewHttpContext(req, w))
if err != nil {
fmt.Fprintf(w, "enforcer.IsLogin() failed: %v", err)
return
}
response := "<h2>token-go SSO-Client</h2> <p>isLogin = " + strconv.FormatBool(isLogin) + "</p> <p><a href=\"javascript:location.href='/sso/login?back='+ encodeURIComponent(location.href);\">login</a> <a href='/sso/logout?back=self'>logout</a></p>"
w.Header().Set("Content-Type", "text/html")
fmt.Fprint(w, response)
} else if strings.HasPrefix(req.URL.String(), "/sso/") {
res := ssoEnforcer.ClientDispatcher(tokenGo.NewHttpContext(req, w))
result, ok := res.(*model.Result)
if ok {
bytes, err := json.Marshal(result)
if err != nil {
fmt.Fprintf(w, "json.Marshal() = %v", err)
return
}
_, err = w.Write(bytes)
if err != nil {
fmt.Fprintf(w, "w.Write() = %v", err)
return
}
return
}
html, ok := res.(string)
if ok {
w.Header().Set("Content-Type", "text/html")
fmt.Fprintf(w, "%s", html)
return
}
bytes, err := json.Marshal(model.Ok())
if err != nil {
fmt.Fprintf(w, "json.Marshal() = %v", err)
return
}
_, err = w.Write(bytes)
if err != nil {
fmt.Fprintf(w, "w.Write() = %v", err)
return
}
} else {
fmt.Fprintf(w, "not this api")
}
}

140
examples/sso/sso-server/sso-server.go Normal file
View File

@@ -0,0 +1,140 @@
package main
import (
"encoding/json"
"fmt"
tokenGo "github.com/weloe/token-go"
"github.com/weloe/token-go/config"
"github.com/weloe/token-go/ctx"
"github.com/weloe/token-go/model"
"github.com/weloe/token-go/sso"
"io"
"io/ioutil"
"log"
"net/http"
"strings"
)
var enforcer *tokenGo.Enforcer
var ssoEnforcer *sso.SsoEnforcer
func main() {
var err error
// use default adapter
adapter := tokenGo.NewDefaultAdapter()
enforcer, err = tokenGo.NewEnforcer(adapter)
if err != nil {
log.Fatal(err)
}
// enable logger
enforcer.EnableLog()
ssoOptions := &config.SsoOptions{
Mode: "",
TicketTimeout: 300,
AllowUrl: "*",
IsSlo: true,
IsHttp: true,
ServerUrl: "http://token-go-sso-server.com:9000",
NotLoginView: func() interface{} {
msg := "not log in SSO-Server, please visit <a href='/sso/doLogin?name=tokengo&pwd=123456' target='_blank'> doLogin </a>"
return msg
},
DoLoginHandle: func(name string, pwd string, ctx ctx.Context) (interface{}, error) {
if name != "tokengo" {
return "name error", nil
}
if pwd != "123456" {
return "pwd error", nil
}
token, err := enforcer.Login("1001", ctx)
if err != nil {
return nil, err
}
return model.Ok().SetData(token), nil
},
SendHttp: func(url string) (string, error) {
response, err := http.Get(url)
if err != nil {
log.Printf("http.Get() failed: %v", err)
return "", err
}
defer func(Body io.ReadCloser) {
err = Body.Close()
if err != nil {
log.Printf("read response body failed: %v", err)
}
}(response.Body)
body, err := ioutil.ReadAll(response.Body)
if err != nil {
log.Printf("ioutil.ReadAll() failed: %v", err)
return "", err
}
return string(body), nil
},
}
signOptions := &config.SignOptions{
SecretKey: "kQwIOrYvnXmSDkwEiFngrKidMcdrgKor",
IsCheckNonce: true,
}
ssoEnforcer, err = sso.NewSsoEnforcer(&sso.Options{
SsoOptions: ssoOptions,
SignOptions: signOptions,
Enforcer: enforcer,
})
if err != nil {
log.Fatalf("NewSsoEnforcer() failed: %v", err)
}
engine := new(Engine)
log.Fatal(http.ListenAndServe(":9000", engine))
}
// Engine is the uni handler for all requests
type Engine struct{}
func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if strings.HasPrefix(req.URL.String(), "/sso/") {
res := ssoEnforcer.ServerDisPatcher(tokenGo.NewHttpContext(req, w))
result, ok := res.(*model.Result)
if ok {
bytes, err := json.Marshal(result)
if err != nil {
fmt.Fprintf(w, "json.Marshal() = %v", err)
return
}
_, err = w.Write(bytes)
if err != nil {
fmt.Fprintf(w, "w.Write() = %v", err)
return
}
return
}
html, ok := res.(string)
if ok {
w.Header().Set("Content-Type", "text/html")
fmt.Fprintf(w, "%s", html)
return
}
bytes, err := json.Marshal(model.Ok())
if err != nil {
fmt.Fprintf(w, "json.Marshal() = %v", err)
return
}
_, err = w.Write(bytes)
if err != nil {
fmt.Fprintf(w, "w.Write() = %v", err)
return
}
} else {
fmt.Fprintf(w, "not this api")
}
}