deprecated_overflow_gateway.../main.go
crusader d3f40ec6be ing
2017-08-30 20:48:38 +09:00

151 lines
3.8 KiB
Go

package main
import (
"context"
"encoding/json"
"log"
"time"
"go.uber.org/zap"
"google.golang.org/grpc"
"github.com/garyburd/redigo/redis"
"github.com/valyala/fasthttp"
"git.loafle.net/commons_go/config"
"git.loafle.net/commons_go/logging"
backGRpc "git.loafle.net/overflow/overflow_api_server/golang"
"git.loafle.net/overflow/overflow_gateway_web/handler/file"
"git.loafle.net/overflow/overflow_gateway_web/handler/web"
gws "git.loafle.net/overflow/overflow_gateway_websocket"
grpcPool "git.loafle.net/overflow/overflow_grpc_pool"
subscriberRedis "git.loafle.net/overflow/overflow_subscriber/redis"
)
var logger *zap.Logger
func main() {
config.SetConfigName("config")
config.AddConfigPath(".")
err := config.ReadInConfig()
if nil != err {
log.Fatalf("config error: %v", err)
}
ctx, cancel := NewContext()
defer cancel()
logger = logging.WithContext(ctx)
defer logger.Sync()
o := &gws.ServerOptions{
OnConnection: onConnection,
OnDisconnected: onDisconnected,
OnCheckOrigin: onCheckOrigin,
HandshakeTimeout: time.Duration(config.GetInt("websocket.HandshakeTimeout")) * time.Second,
ReadBufferSize: config.GetInt("websocket.ReadBufferSize"),
WriteBufferSize: config.GetInt("websocket.WriteBufferSize"),
EnableCompression: config.GetBool("websocket.EnableCompression"),
}
s := gws.NewServer(ctx, o)
rPool := &redis.Pool{
MaxIdle: config.GetInt("redis.pool.MaxIdle"),
IdleTimeout: time.Duration(config.GetInt("redis.pool.IdleTimeout")) * time.Second,
Dial: func() (redis.Conn, error) {
return redis.Dial(config.GetString("redis.network"), config.GetString("redis.addr"))
},
}
defer func() {
rPool.Close()
}()
noti := subscriberRedis.New(ctx, rPool.Get())
noti.Subscribe("web", func(channel string, payload string) {
logger.Info("Subscribe",
zap.String("channel", channel),
zap.String("payload", payload),
)
})
bo := &grpcPool.Options{
MaxIdle: config.GetInt("grpc.pool.MaxIdle"),
MaxCapacity: config.GetInt("grpc.pool.MaxCapacity"),
Creators: func() (*grpc.ClientConn, interface{}, error) {
var err error
conn, err := grpc.Dial(config.GetString("grpc.addr"), grpc.WithInsecure())
if nil != err {
return nil, nil, err
}
c := backGRpc.NewOverflowApiServerClient(conn)
return conn, c, nil
},
}
bPool, err := grpcPool.New(ctx, bo)
if nil != err {
logger.Panic("Cannot create Pool of GRPC")
}
wh := web.New(ctx, bPool)
fh := file.New(ctx)
s.HandleSocket(config.GetString("handlers.web.entry"), wh.GetSocketOption())
s.HandleSocket(config.GetString("handlers.file.entry"), fh.GetSocketOption())
s.ListenAndServe(config.GetString("server.addr"))
}
func NewContext() (context.Context, context.CancelFunc) {
var err error
ctx := context.Background()
logConfig := config.Sub("logging")
buf, err := logConfig.Marshal("json")
if err != nil {
panic(err)
}
var cfg zap.Config
if err = json.Unmarshal(buf, &cfg); err != nil {
panic(err)
}
logger, err := cfg.Build()
if err != nil {
panic(err)
}
ctx = logging.NewContext(ctx, logger)
ctx, cancel := context.WithCancel(ctx)
return ctx, cancel
}
func onCheckOrigin(ctx *fasthttp.RequestCtx) bool {
if origin := string(ctx.Request.Header.Peek("Origin")); origin != "" {
ctx.Response.Header.Set("Access-Control-Allow-Origin", origin)
if string(ctx.Method()) == "OPTIONS" && string(ctx.Request.Header.Peek("Access-Control-Request-Method")) != "" {
ctx.Response.Header.Set("Access-Control-Allow-Headers", "Content-Type, Accept")
ctx.Response.Header.Set("Access-Control-Allow-Methods", "GET, HEAD, POST, PUT, DELETE")
}
}
return true
}
func onConnection(soc gws.Socket) {
logger.Info("connect",
zap.String("path", soc.Path()),
zap.String("id", soc.ID()),
)
}
func onDisconnected(soc gws.Socket) {
logger.Info("disconnect",
zap.String("path", soc.Path()),
zap.String("id", soc.ID()),
)
}