func run() {
logFile, logErr := os.OpenFile(*logFileName, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)
if logErr != nil {
fmt.Println("Fail to find", *logFile, "cServer start Failed")
os.Exit(1)
}
log.SetOutput(logFile)
log.Printf("CM Server Start")
CACHE = NewCache(PATH + "cache")
defer CACHE.Close()
CACHE.All()
gin.SetMode(gin.ReleaseMode)
//g := gin.Default()
g := gin.New()
g.Use(gin.Recovery())
g.Use(gin.LoggerWithWriter(logFile))
g.Use(gzip.Gzip(gzip.DefaultCompression))
g.POST("/cm/settings", postSettings)
g.GET("/cm/settings", getSettings)
g.GET("/cm/menus", func(c *gin.Context) {
c.JSON(http.StatusOK, CACHE.menus)
})
g.NoRoute(func(c *gin.Context) {
c.String(http.StatusNotFound, "404")
})
g.Run(":8011")
}
func NewRouter() *gin.Engine {
gin.SetMode(gin.ReleaseMode)
router := gin.Default()
router.RedirectTrailingSlash = true
router.RedirectFixedPath = true
router.Use(gzip.Gzip(gzip.DefaultCompression))
router.Use(middleware.ContentTypeCheckerMiddleware())
router.Use(middleware.RequestIdMiddleware())
router.Use(middleware.RevisionMiddleware())
router.Use(cors.Middleware(cors.Config{
Origins: "*",
Methods: "GET, PUT, POST, DELETE, PATCH, OPTIONS",
RequestHeaders: "Origin, Authorization, Content-Type",
ExposedHeaders: "",
MaxAge: 1728000,
Credentials: true,
ValidateHeaders: false,
}))
return router
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
role := config.mustGetString("postgres", "role")
database := config.mustGetString("postgres", "database")
ip := config.mustGetString("postgres", "ip")
password := config.mustGetString("postgres", "password")
services.InitDBConnection(role, password, database, ip)
api_key := config.mustGetString("parsemap", "api_key")
r := gin.New()
r.Use(gzip.Gzip(gzip.DefaultCompression))
r.Use(gin.Logger())
r.Use(gin.Recovery())
r.Use(gin.ErrorLogger())
v2 := r.Group("/v2")
services.GetHandlersV2(v2, api_key)
var wg sync.WaitGroup
wg.Add(2)
go startServer(r, &wg)
go startTLSServer(r, &wg)
wg.Wait()
}
func main() {
r := gin.Default()
r.Use(gzip.Gzip(gzip.DefaultCompression))
r.GET("/ping", func(c *gin.Context) {
c.String(200, "pong "+fmt.Sprint(time.Now().Unix()))
})
// Listen and Server in 0.0.0.0:8080
r.Run(":8080")
}
// Run runs the setup server which is used to configure the application on the
// first run or when the -i/--initial option is used.
func Run() {
gin.SetMode(gin.ReleaseMode)
r := gin.New()
r.Use(gin.Recovery())
r.Use(gzip.Gzip(gzip.DefaultCompression))
r.LoadHTMLGlob("templates/*")
r.Static("/static", "./assets")
r.Static("/favicon.ico", "./assets/favicon.ico")
r.GET("/", index)
r.POST("/", configure)
fmt.Println("Please go to http://127.0.0.1:8008 to setup goploader.")
r.Run(":8008")
}
func main() {
r := gin.Default()
r.Use(gzip.Gzip(gzip.DefaultCompression))
r.GET("/bson", func(c *gin.Context) {
//data, err := bson.Marshal(&Image{Name: "people_top_hair_000"})
data, err := bson.Marshal(gin.H{"name": "people_top_hair_000", "path": "assect/images/hair"})
if err != nil {
panic(err)
}
c.Data(http.StatusOK, "application/bson", data)
})
r.GET("/json", func(c *gin.Context) {
c.JSON(http.StatusOK, &Image{Name: "people_top_hair_000"})
})
r.Static("/html", "./html")
r.Run(":8080") // listen and serve on 0.0.0.0:8080
}
func main() {
r := gin.Default()
r.Use(gzip.Gzip(gzip.DefaultCompression))
// Group using gin.BasicAuth() middleware
authorized := r.Group("/")
if len(config.Accounts) > 0 {
authorized.Use(gin.BasicAuth(config.Accounts))
}
for _, f := range config.StaticFS {
authorized.StaticFS("/"+f, http.Dir(f))
}
authorized.GET(config.HomeUrl, func(c *gin.Context) {
c.JSON(http.StatusOK, "home!")
})
r.Run(config.ListenAddress)
}
func main() {
flag.Parse()
session, err := mgo.Dial(*uri)
if err != nil {
log.Fatal(err)
}
service := namesearch.New(namesearch.Session(session))
router := gin.Default()
router.Use(gzip.Gzip(gzip.DefaultCompression))
router.Use(static.Serve("/", static.LocalFile("static", true)))
router.GET("/v1/namesearch/", service.NameSearch)
router.GET("/v1/namesearch/:query", service.NameSearch)
router.Run(*listen)
}
func Init(db *bolt.DB, _port ...string) {
DB = db
gin.SetMode(gin.ReleaseMode)
router := gin.Default()
router.Use(gzip.Gzip(gzip.DefaultCompression))
router.GET("/", bucketList)
router.GET("/rest/:bucket/:action", restGetHandler)
router.POST("/rest", restPostHandler)
router.GET("/bucket/:name/*nested", bucketContent)
port := "3333"
if len(_port) > 0 && _port[0] != "" {
port = _port[0]
}
err := http.ListenAndServe(":"+port, router)
if err != nil {
panic(err)
}
}
func main() {
flag.Parse()
// Pass variables to packages
model.SessionLength = *SESSION_LENGTH
model.DbUser = *DB_USER
model.DbPass = *DB_PASS
model.DbName = *DB_NAME
model.DbHost = *DB_HOST
log.Print("Initializing database backend")
model.DbMap = model.InitDb()
log.Print("Initializing session backend")
common.ActiveSession = &common.SessionConnector{
Address: *REDIS_HOST,
Password: *REDIS_PASSWORD,
DatabaseId: int64(*REDIS_DBID),
}
err := common.ActiveSession.Connect()
if err != nil {
panic(err)
}
log.Print("Initializing web services")
m := gin.New()
m.Use(gin.Logger())
m.Use(gin.Recovery())
// Enable gzip compression
m.Use(gzip.Gzip(gzip.DefaultCompression))
// Serve up the static UI...
m.Static("/ui", "./ui")
m.StaticFile("/favicon.ico", "./ui/favicon.ico")
// ... with a redirection for the root page
m.GET("/", func(c *gin.Context) {
c.Redirect(http.StatusMovedPermanently, "./ui/index.html")
})
// All authorized pieces live in /api
a := m.Group("/api")
// JWT pieces
auth := m.Group("/auth")
auth.POST("/login", getAuthMiddleware().LoginHandler)
auth.GET("/refresh_token", getAuthMiddleware().RefreshHandler)
auth.DELETE("/logout", authMiddlewareLogout)
auth.GET("/logout", authMiddlewareLogout) // for compatibility -- really shouldn't use this
// Iterate through initializing API maps
for k, v := range common.ApiMap {
f := make([]string, 0)
if v.Authenticated {
f = append(f, "AUTH")
}
log.Printf("Adding handler /api/%s [%s]", k, strings.Join(f, ","))
g := a.Group("/" + k)
if v.Authenticated {
g.Use(getAuthMiddleware().MiddlewareFunc())
}
v.RouterFunction(g)
}
if *HTTPS_KEY != "" && *HTTPS_CERT != "" {
log.Printf("Launching https on port :%d", *HTTPS_PORT)
go func() {
log.Fatal(manners.ListenAndServeTLS(fmt.Sprintf(":%d", *HTTP_PORT), *HTTPS_CERT, *HTTPS_KEY, m))
}()
}
// HTTP
log.Printf("Launching http on port :%d", *HTTP_PORT)
log.Fatal(manners.ListenAndServe(fmt.Sprintf(":%d", *HTTP_PORT), m))
}
func main() {
flag.Parse()
os.Chdir(*basePath)
if *dbfile == "" {
fmt.Println(errors.New("Err: dbfile can't be blank"))
flag.Usage()
return
}
dbf, err := os.OpenFile(*dbfile, os.O_RDWR|os.O_CREATE, 0700)
if err != nil {
panic(err.Error())
}
defer dbf.Close()
dbh := newDbfileHandler(dbf)
r := gin.Default()
r.Use(gzip.Gzip(gzip.DefaultCompression))
apiHeader := func(ctx *gin.Context) {
ctx.Header("Content-Type", "application/json")
ctx.Header("Access-Control-Allow-Headers", "Content-Type")
ctx.Header("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE")
ctx.Header("Access-Control-Allow-Credentials", "true")
ctx.Header("Access-Control-Allow-Origin", "*")
}
// Dump data data output
r.GET("/db", apiHeader, func(ctx *gin.Context) {
ctx.JSON(200, dbh.collection)
})
// Retrun th given language translation
r.GET("/translation/:lang", apiHeader, func(ctx *gin.Context) {
lang := ctx.Param("lang")
secArr := make([]Section, 0, 10)
for _, trans := range dbh.collection {
secArr = append(secArr, toSectionStruct(&trans, lang))
}
ctx.JSON(200, gin.H{
"result": true,
"data": secArr,
})
})
r.GET("/translation/:lang/:section", apiHeader, func(ctx *gin.Context) {
lang := ctx.Param("lang")
sectionName := ctx.Param("section")
trans := newTranslation()
err := dbh.Section(sectionName, trans)
if err != nil {
ctx.JSON(404, gin.H{
"result": false,
"err": err.Error(),
})
return
}
ctx.JSON(200, gin.H{
"result": true,
"data": toSectionStruct(trans, lang),
})
})
// Create/Update section translation in given language
r.POST("/translation/:to_lang/:section", apiHeader, func(ctx *gin.Context) {
var err error
section := ctx.Param("section")
toLang := ctx.Param("to_lang")
sec := new(Section)
err = ctx.BindJSON(sec)
if err != nil {
ctx.JSON(400, gin.H{
"result": false,
"err": err.Error(),
})
return
}
trans := newTranslation()
err = dbh.Section(section, trans)
isNewSection := err != nil
//new section name
if sec.RenameTo != "" {
trans.Section = sec.RenameTo
}
//check any removed item
for o, _ := range trans.Items {
if _, ok := sec.Items[o]; !ok {
delete(trans.Items, o)
}
}
//check any new item or translated language
for o, it := range sec.Items {
newOriginalItem := true
for o2, _ := range trans.Items {
if o == o2 {
//rename its key
if it.RenameTo != "" && it.RenameTo != o {
trans.Items[it.RenameTo] = trans.Items[o]
delete(trans.Items, o)
trans.Items[it.RenameTo][toLang] = it.TranslateTo
} else {
trans.Items[o][toLang] = it.TranslateTo
}
newOriginalItem = false
break
}
}
if newOriginalItem {
if _, ok := trans.Items[o]; !ok {
trans.Items[o] = make(TranslationItem)
}
trans.Items[o][toLang] = it.TranslateTo
}
}
if isNewSection {
trans.Section = section
err = dbh.Append(*trans)
} else {
err = dbh.Update(section, *trans)
}
if err != nil {
ctx.JSON(500, gin.H{
"result": false,
"err": err.Error(),
})
}
ctx.JSON(200, gin.H{
"result": true,
})
})
r.OPTIONS("*path", apiHeader, func(ctx *gin.Context) {
//nothing
})
if *debug {
r.StaticFile("/", "static/src/index.html")
r.Static("/js", "static/src/js")
r.Static("/img", "static/src/img")
r.Static("/css", "static/src/css")
r.Static("/bower_components", "static/src/bower_components")
r.Static("/tpl", "static/src/tpl")
} else {
r.GET("/static/*path", getAsset)
r.GET("/", getHome)
}
r.Run(*host)
}
func main() {
app := gin.New()
// Initialize config file
conf := config.LoadConfig()
// Version
version := client.Version{Build: BuildTime, Hash: GitHash}
// Use Logger, Cross-Origin Ressource and GZIP compression middleware
app.Use(client.LoggerMiddleware())
app.Use(client.CORSMiddleware())
app.Use(gzip.Gzip(gzip.DefaultCompression))
rootusers, emergencyusers, OAuth2Endpoint, err := config.LoadAuthConf(conf)
if err != nil {
glog.Errorf("Could not load configuration. Reason: %s", err.Message)
panic("Could not load configuration for Baboon. Exiting.")
}
glog.Infof("%+v", rootusers)
app.GET("/api/version", version.BaboonVersion)
if *gtmenabled {
publicGTM := app.Group("/api/gtms/:trafficmanager")
{
publicGTM.GET("/pools", client.GTMPoolList)
publicGTM.GET("/pools/:pool", client.GTMPoolNameList)
publicGTM.GET("/pools/:pool/members", client.GTMPoolMemberList)
publicGTM.GET("/wideips", client.GTMWipList)
publicGTM.GET("/wideips/:wideip", client.GTMWipNameList)
publicGTM.GET("/irules", client.GTMIRuleList)
publicGTM.GET("/irules/:irule", client.GTMIRuleNameList)
}
privateGTM := app.Group("/api/gtms/:trafficmanager")
privateGTM.Use(ginoauth2.Auth(ginoauth2.UidCheck, *OAuth2Endpoint, rootusers))
{
privateGTM.POST("/pools", client.GTMPoolPost)
privateGTM.POST("/pools/:pool/members", client.GTMPoolMemberPost)
privateGTM.POST("/wideips", client.GTMWideipPost)
privateGTM.DELETE("/pools/:pool", client.GTMPoolDelete)
privateGTM.DELETE("/wideips/:wideip", client.GTMWipDelete)
privateGTM.DELETE("/pools/:pool/members", client.GTMPoolMemberDelete)
}
emergencyGTM := app.Group("/api/gtms/:trafficmanager")
emergencyGTM.Use(ginoauth2.Auth(ginoauth2.UidCheck, *OAuth2Endpoint, emergencyusers))
{
emergencyGTM.PUT("/pools/:pool/members", client.GTMPoolMemberStatusPut)
emergencyGTM.PUT("/pools", client.GTMPoolStatusPut)
}
}
if *ltmenabled {
publicLTM := app.Group("/api/ltms/:lbpair")
{
publicLTM.GET("/pools", client.LTMPoolList)
publicLTM.GET("/pools/:pool", client.LTMPoolNameList)
publicLTM.GET("/pools/:pool/members", client.LTMPoolMemberList)
publicLTM.GET("/devices", client.LTMDeviceList)
publicLTM.GET("/devices/:devicename", client.LTMDeviceNameList)
publicLTM.GET("/virtuals", client.LTMVirtualServerList)
publicLTM.GET("/virtuals/:virtual", client.LTMVirtualServerNameList)
publicLTM.GET("/virtuals/:virtual/rules", client.LTMFWRuleList)
publicLTM.GET("/virtuals/:virtual/profiles", client.LTMProfileList)
publicLTM.GET("/datagroups", client.LTMDataGroupList)
publicLTM.GET("/datagroups/:datagroupname", client.LTMDataGroupNameList)
publicLTM.GET("/blacklist", client.LTMBlackAddressList)
publicLTM.GET("/whitelist", client.LTMWhiteAddressList)
publicLTM.GET("/irules", client.LTMIRuleList)
publicLTM.GET("/irules/:irule", client.LTMIRuleNameList)
}
privateLTM := app.Group("/api/ltms/:lbpair")
privateLTM.Use(ginoauth2.Auth(ginoauth2.UidCheck, *OAuth2Endpoint, rootusers))
{
privateLTM.POST("/pools", client.LTMPoolPost)
privateLTM.POST("/virtuals", client.LTMVirtualServerPost)
privateLTM.POST("/pools/:pool/members", client.LTMPoolMemberPost)
privateLTM.POST("/datagroups", client.LTMDataGroupPost)
privateLTM.PUT("/pools", client.LTMPoolPut)
privateLTM.PUT("/pools/:pool/members", client.LTMPoolMemberPut)
privateLTM.DELETE("/pools/:pool", client.LTMPoolDelete)
privateLTM.DELETE("/pools/:pool/members", client.LTMPoolMemberDelete)
privateLTM.DELETE("/datagroups", client.LTMDataGroupDelete)
privateLTM.PUT("/datagroups/:datagroupname", client.LTMDataGroupItemPut)
privateLTM.PATCH("/datagroups/:datagroupname", client.LTMDataGroupItemPatch)
//To do: privateLTM.DELETE("/datagroups/:direction/:datagroupname", client.LTMDataGroupItemDelete)
}
emergencyLTM := app.Group("/api/ltms/:lbpair")
emergencyLTM.Use(ginoauth2.Auth(ginoauth2.UidCheck, *OAuth2Endpoint, emergencyusers))
{
emergencyLTM.PATCH("/blacklist", client.LTMBlockIPPatch)
emergencyLTM.PATCH("/whitelist", client.LTMWhiteIPPatch)
emergencyLTM.DELETE("/whitelist", client.LTMRemoveWhiteIPPatch)
emergencyLTM.DELETE("/blacklist", client.LTMRemoveBlockIPPatch)
}
}
switch {
case *sslenabled:
run := app.RunTLS(fmt.Sprintf(":%s", strconv.Itoa(*port)),
conf.Security["certFile"],
conf.Security["keyFile"])
if run != nil {
fmt.Println("Could not start web server,", run.Error())
}
default:
run := app.Run(fmt.Sprintf(":%s", strconv.Itoa(*port)))
if run != nil {
fmt.Println("Could not start web server,", run.Error())
}
}
}
/*
GZIP compress responses
*/
func GZIP() gin.HandlerFunc {
return gzip.Gzip(gzip.DefaultCompression)
}
