func Run() {
router := gin.Default()
router.LoadHTMLGlob("panel/templates/*")
router.Static("/static/", "static")
router.Static("/assets/", "assets")
router.GET("/", func(c *gin.Context) {
c.HTML(http.StatusOK, "main.html", gin.H{})
})
// get users from file
users := make(gin.Accounts)
file, err := os.Open("users.txt")
checkErr(err)
defer file.Close()
scanner := bufio.NewScanner(file)
for scanner.Scan() {
line := scanner.Text()
user := strings.Split(line, ":")
users[user[0]] = user[1]
}
checkErr(err)
mailer := router.Group("mailer", gin.BasicAuth(users))
{
mailer.GET("logout", func(c *gin.Context) {
c.HTML(http.StatusUnauthorized, "logout.html", nil)
})
mailer.GET("group", func(c *gin.Context) {
data := gin.H{
"groups": getGroups(),
}
c.HTML(http.StatusOK, "group.html", data)
})
mailer.POST("group", func(c *gin.Context) {
addGroup(c.PostForm("name"))
data := gin.H{
"groups": getGroups(),
}
c.HTML(http.StatusOK, "group.html", data)
})
mailer.GET("group/:id", func(c *gin.Context) {
data := gin.H{
"campaigns": getCampaigns(c.Param("id")),
}
c.HTML(http.StatusOK, "campaign.html", data)
})
mailer.POST("group/:id", func(c *gin.Context) {
addCampaigns(c.Param("id"), c.PostForm("name"))
data := gin.H{
"campaigns": getCampaigns(c.Param("id")),
}
c.HTML(http.StatusOK, "campaign.html", data)
})
mailer.GET("campaign/edit/:id", func(c *gin.Context) {
camp, err := getCampaignInfo(c.Param("id"))
if err == nil {
data := gin.H{
"ifaces": getIfaces(),
"campaign": camp,
}
c.HTML(http.StatusOK, "campaignEdit.html", data)
} else {
// blank 16x16 png
c.Header("Content-Type", "image/png")
output, _ := base64.StdEncoding.DecodeString("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAADUExURUxpcU3H2DoAAAABdFJOUwBA5thmAAAADUlEQVQY02NgGAXIAAABEAAB7JfjegAAAABJRU5ErkJggg==iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAADUExURUxpcU3H2DoAAAABdFJOUwBA5thmAAAAEklEQVQ4y2NgGAWjYBSMAuwAAAQgAAFWu83mAAAAAElFTkSuQmCC")
c.String(http.StatusOK, string(output))
}
})
mailer.POST("campaign/edit/:id", func(c *gin.Context) {
data := gin.H{
"ifaces": getIfaces(),
"campaign": updateCampaignInfo(
campaign{
Id: c.Param("id"),
IfaceId: c.PostForm("ifaceId"),
Name: c.PostForm("name"),
Subject: c.PostForm("subject"),
From: c.PostForm("from"),
FromName: c.PostForm("fromName"),
Message: c.PostForm("message"),
StartTime: c.PostForm("startTime"),
EndTime: c.PostForm("endTime"),
},
),
}
c.HTML(http.StatusOK, "campaignEdit.html", data)
})
mailer.GET("campaign/recipient/get/:id", func(c *gin.Context) {
data := gin.H{
"campaignId": c.Param("id"),
"recipients": getRecipients(c.Param("id"), "0", "10"),
}
c.HTML(http.StatusOK, "recipient.html", data)
})
mailer.GET("campaign/recipient/param/:id", func(c *gin.Context) {
data := gin.H{
"recipient": getRecipient(c.Param("id")),
"params": getRecipientParam(c.Param("id")),
}
c.HTML(http.StatusOK, "recipientParam.html", data)
})
mailer.GET("recipients/:id", hRecipients)
mailer.POST("recipients/:id", uploadRecipients)
}
router.GET("filemanager", func(c *gin.Context) {
if c.Query("mode") == "download" {
var n string
var d []byte
if c.Query("width") != "" && c.Query("height") != "" {
// Download resized
d = FilemanagerResize(c.Query("path"), c.Query("width"), c.Query("height"))
} else {
// Download file
n, d = FilemanagerDownload(c.Query("path"))
c.Header("Content-Disposition", "attachment; filename='"+n+"'")
}
c.Data(http.StatusOK, http.DetectContentType(d), d)
} else {
c.JSON(http.StatusOK, Filemanager(c.Query("mode"), c.Query("path"), c.Query("name"), c.Query("old"), c.Query("new")))
}
})
router.POST("filemanager", func(c *gin.Context) {
if c.PostForm("mode") == "add" {
file, head, err := c.Request.FormFile("newfile")
checkErr(err)
c.JSON(http.StatusOK, FilemanagerAdd(c.PostForm("currentpath"), head.Filename, file))
}
})
api := router.Group("api")
{
table := api.Group("mailer")
{
table.GET("recipients/:id", aRecipients)
}
}
router.Run(":7777")
}
func Serve(address, dbpath string) {
DBInit(dbpath)
AccountsInit()
route := gin.Default()
route.GET("/", Index)
route.LoadHTMLGlob("templates/*.html")
product := route.Group("/product", gin.BasicAuth(ACCOUNT))
{
product.GET(":id", getProduct)
product.GET("", queryProduct)
product.POST("", updateProduct)
product.POST(":id", updateProduct)
product.DELETE(":id", deleteProduct)
}
series := route.Group("/series", gin.BasicAuth(ACCOUNT))
{
series.POST("", addSeries)
}
validate := route.Group("/v")
{
validate.GET(":id", getSerie)
validate.POST(":id", claimSerie)
}
route.Static("/static", "static")
route.Static("/asset", "asset")
route.Run(address)
}
func TestLogRequest(t *testing.T) {
s := loadServerCtx()
s.AllowedApps = append(s.AllowedApps, "test")
s.AppPasswd["test"] = "pass"
s.in = make(chan *logData)
defer close(s.in)
s.out = make(chan *logMetrics)
defer close(s.out)
go logProcess(s.in, s.out)
r := gin.New()
auth := r.Group("/", gin.BasicAuth(s.AppPasswd))
auth.POST("/", s.processLogs)
req, _ := http.NewRequest("POST", "/", bytes.NewBuffer([]byte("LINE of text\nAnother line\n")))
req.SetBasicAuth("test", "pass")
resp := httptest.NewRecorder()
r.ServeHTTP(resp, req)
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
t.Error(err)
}
if string(body) != "OK" {
t.Error("resp body should match")
}
if resp.Code != 200 {
t.Error("should get a 200")
}
}
func main() {
r := gin.Default()
// Group using gin.BasicAuth() middleware
// gin.Accounts is a shortcut for map[string]string
authorized := r.Group("/admin", gin.BasicAuth(gin.Accounts{
"foo": "bar",
"austin": "1234",
"lena": "hello2",
"manu": "4321",
}))
// /admin/secrets endpoint
// hit "localhost:8080/admin/secrets
authorized.GET("/secrets", func(c *gin.Context) {
// get user, it was setted by the BasicAuth middleware
user := c.MustGet(gin.AuthUserKey).(string)
if secret, ok := secrets[user]; ok {
c.JSON(http.StatusOK, gin.H{"user": user, "secret": secret})
} else {
c.JSON(http.StatusOK, gin.H{"user": user, "secret": "NO SECRET :("})
}
})
// Listen and server on 0.0.0.0:8080
r.Run(":8080")
}
// Listen Tells Gin API to start
func Listen(iface string, s *discordgo.Session, logger *logging.Logger) {
// set the refs to point to main
var v1 *gin.RouterGroup
session = s
c := config.Get()
log = logger
if c.LogLevel != "debug" {
gin.SetMode(gin.ReleaseMode)
}
//r := gin.Default()
r := gin.New()
r.Use(loggerino())
r.Use(gin.Recovery())
if c.APIPassword != "" {
log.Info("Basic Authentication enabled for API")
v1 = r.Group("/v1", gin.BasicAuth(gin.Accounts{
c.APIUsername: c.APIPassword,
}))
} else {
log.Warning("DIGO_API_PASSWORD and DIGO_API_USERNAME are not set")
log.Warning("The API is open to all requests")
v1 = r.Group("/v1")
}
v1.GET("/version", versionV1)
v1.GET("/channels", channelsV1)
v1.POST("/message", messageV1)
go r.Run(iface)
log.Noticef("Digo API is listening on %s", c.APIInterface)
}
func main() {
flag.Parse()
if showv {
showVersion()
return
}
appConfig, err := config.LoadAppConfig(conf)
if err != nil {
fmt.Printf("config load err: %s\n", err)
os.Exit(-1)
}
if !debug {
gin.SetMode(gin.ReleaseMode)
}
r := gin.Default()
r.Static("/assets", "./ui/assets")
r.LoadHTMLGlob("ui/templates/*")
r.Use(appConfigMiddleware(appConfig))
if appConfig.Basic_auth.On {
r.Use(gin.BasicAuth(gin.Accounts{appConfig.Basic_auth.Username: appConfig.Basic_auth.Password}))
}
r.GET("/", controller.Home)
r.GET("/node", controller.Node)
r.GET("/cluster", controller.Cluster)
r.POST("/do", controller.Do)
r.Run(listen)
}
func main() {
gin.SetMode(gin.ReleaseMode)
s := loadServerCtx()
if s.Debug {
log.SetLevel(log.DebugLevel)
gin.SetMode(gin.DebugMode)
}
c, err := statsdClient(s.StatsdUrl)
if err != nil {
log.WithField("statsdUrl", s.StatsdUrl).Fatal("Could not connect to statsd")
}
r := gin.Default()
r.GET("/status", func(c *gin.Context) {
c.String(200, "OK")
})
if len(s.AppPasswd) > 0 {
auth := r.Group("/", gin.BasicAuth(s.AppPasswd))
auth.POST("/", s.processLogs)
}
s.in = make(chan *logData, bufferLen)
defer close(s.in)
s.out = make(chan *logMetrics, bufferLen)
defer close(s.out)
go logProcess(s.in, s.out)
go c.sendToStatsd(s.out)
log.Infoln("Server ready ...")
r.Run(":" + s.Port)
}
func startHTTP() {
log.Printf("Starting server on %s", gConfig.Host)
router := gin.Default()
if gConfig.HasAuth() {
router.Use(gin.BasicAuth(gin.Accounts{gConfig.UI.Username: gConfig.UI.Password}))
}
router.Use(gitserverHandler())
if gConfig.EnableCORS {
router.Use(corsHandler())
}
if !gConfig.UI.DisableUI {
router.StaticFS(gConfig.Repos.Path, http.Dir("./public/"))
}
router.GET("/", handler)
api.SetupRouter(router)
if einhorn.IsRunning() {
einhorn.Start(router, 0)
} else {
router.Run(gConfig.Host)
}
}
func (s schedule) Monitor(e *gin.Engine, path, username, password string) schedule {
r := e.RouterGroup
m := gin.Accounts{
username: password,
}
r.Use(gin.BasicAuth(m))
r.GET(path, JobHtml)
return s
}
func (s *Service) Run() error {
eng := gin.Default()
eng.LoadHTMLGlob(s.Config.App.TemplatesPath + "/*")
eng.Static("/assets", s.Config.App.AssetPath)
prefix := "/"
if s.Config.App.Prefix != "" {
prefix = s.Config.App.Prefix
}
g := eng.Group(prefix, gin.BasicAuth(gin.Accounts{
s.Config.Admin.Login: s.Config.Admin.Password,
}))
g.GET("/", func(c *gin.Context) {
posts, e := s.Store.GetSlice(10, 0)
res := gin.H{}
if e != nil {
fmt.Println(e)
res["error"] = e
}
res["posts"] = posts
c.HTML(200, "index.html", res)
})
g.Any("/create", func(c *gin.Context) {
rm := gin.H{}
if c.Request.Method == "POST" {
rm["message"] = "posted"
title := c.PostForm("title")
content := c.PostForm("content")
p := new(Post)
p.Title = title
p.Body = content
e := s.Store.Save(p)
if e != nil {
fmt.Println(e)
rm["error"] = e
}
}
c.HTML(200, "edit.html", rm)
})
g.GET("/p/:id", func(c *gin.Context) {
id := c.Param("id")
c.HTML(200, "show.html", gin.H{"da": id})
})
g.POST("/p/:id", func(c *gin.Context) {
})
return http.ListenAndServe(fmt.Sprintf(":%d", s.Config.App.Port), eng)
}
func (s *Server) Start() {
r := gin.Default()
r.StaticFS("/data", http.Dir(filepath.Join(s.FpRoot, "data")))
r.StaticFS("/assets", http.Dir("./assets"))
var api, ui gin.IRoutes
if s.AdminUser != "" {
accounts := gin.Accounts{s.AdminUser: s.AdminPass}
api = r.Group("/api", gin.BasicAuth(accounts))
ui = r.Group("/ui", gin.BasicAuth(accounts))
} else {
api = r.Group("/api")
ui = r.Group("/ui")
}
{
api.POST("/upload/:hash", s.upload)
api.POST("/nonexists", s.nonexists)
api.GET("/stat", s.stat)
api.GET("/tags", s.indexTags)
api.GET("/tags/:id", s.getTags)
api.POST("/tags/:id", s.postTags)
api.GET("/tags/:id/files/*path", s.getTagsFile)
api.GET("/tags/:id/versions", s.indexTagsVersions)
}
ui.GET("/*dummy", func(c *gin.Context) {
file, err := ioutil.ReadFile("./assets/index.html")
if err != nil {
c.AbortWithError(500, err)
return
}
c.Data(200, "text/html", file)
})
// redirect _admin/* to api/*
r.Any("/_admin/*path", func(c *gin.Context) {
c.Request.URL.Path = "/api" + c.Param("path")
r.ServeHTTP(c.Writer, c.Request)
})
r.Run(fmt.Sprintf(":%d", s.Port))
}
func startServer() {
router := gin.Default()
// Enable HTTP basic authentication only if both user and password are set
if options.AuthUser != "" && options.AuthPass != "" {
auth := map[string]string{options.AuthUser: options.AuthPass}
router.Use(gin.BasicAuth(auth))
}
router.GET("/", APIHome)
router.POST("/connect", APIConnect)
router.DELETE("/disconnect", APIClose)
router.GET("/databases", APIGetDatabases)
router.GET("/databases/:database/tables", APIGetDatabaseTables)
router.GET("/databases/:database/tables/:table/column", APIGetColumnOfTable)
router.GET("/databases/:database/views", APIGetDatabaseViews)
router.GET("/databases/:database/procedures", APIGetDatabaseProcedures)
router.GET("/databases/:database/functions", APIGetDatabaseFunctions)
router.POST("/databases/:database/actions/default", APISetDefaultDatabase)
router.GET("/info", APIInfo)
router.GET("/tables/:table/info", APIGetTableInfo)
router.GET("/tables/:table/indexes", APITableIndexes)
router.GET("/query", APIRunQuery)
router.POST("/query", APIRunQuery)
router.GET("/explain", APIExplainQuery)
router.POST("/explain", APIExplainQuery)
router.GET("/history", APIHistory)
router.GET("/static/:type/:name", APIServeAsset)
router.GET("/procedures/:procedure/parameters", APIProcedureParameters)
router.GET("/collation", APIGetCollationCharSet)
router.POST("/databases/:database/actions/alter", APIAlterDatabase)
router.DELETE("/databases/:database/actions/drop", APIDropDatabase)
router.DELETE("/databases/:database/tables/:table/actions/drop", APIDropTable)
router.DELETE("/databases/:database/tables/:table/actions/truncate", APITruncateTable)
router.GET("/databases/:database/procedures/:procedure", APIProcedureDefinition)
router.GET("/databases/:database/functions/:function", APIFunctionDefinition)
router.POST("/databases/:database/procedures/:procedure", APICreateProcedure)
router.POST("/databases/:database/functions/:function", APICreateFunction)
router.DELETE("/databases/:database/procedures/:procedure/actions/drop", APIDropProcedure)
router.GET("/databases/:database/views/:view", APIViewDefinition)
router.GET("/search/:query", apiSearch)
router.GET("/bookmarks", APIGetBookmarks)
router.POST("/bookmarks/:name", APISaveBookmark)
router.DELETE("/bookmarks/:name", APIDeleteBookmark)
router.GET("/updates", getUpdate)
fmt.Println("Starting server...")
go router.Run(fmt.Sprintf("%v:%v", options.HttpHost, options.HttpPort))
}
func main() {
r := gin.Default()
// Ping test
r.GET("/ping", func(c *gin.Context) {
c.String(200, "pong")
})
// Get user value
r.GET("/user/:name", func(c *gin.Context) {
user := c.Params.ByName("name")
value, ok := DB[user]
if ok {
c.JSON(200, gin.H{"user": user, "value": value})
} else {
c.JSON(200, gin.H{"user": user, "status": "no value"})
}
})
// Authorized group (uses gin.BasicAuth() middleware)
// Same than:
// authorized := r.Group("/")
// authorized.Use(gin.BasicAuth(gin.Credentials{
// "foo": "bar",
// "manu": "123",
//}))
authorized := r.Group("/", gin.BasicAuth(gin.Accounts{
"foo": "bar", // user:foo password:bar
"manu": "123", // user:manu password:123
}))
authorized.POST("admin", func(c *gin.Context) {
user := c.MustGet(gin.AuthUserKey).(string)
// Parse JSON
var json struct {
Value string `json:"value" binding:"required"`
}
if c.Bind(&json) {
DB[user] = json.Value
c.JSON(200, gin.H{"status": "ok"})
}
})
// Listen and Server in 0.0.0.0:8080
r.Run(":8080")
}
// RegistrarRotas realiza o registro de todas as rotas da aplicação.
func RegistrarRotas(r *gin.Engine, usuario, senha string) {
// Habilitando esquema de autorização simples
auth := r.Group("/", gin.BasicAuth(gin.Accounts{usuario: senha}))
auth.GET("/", Raiz)
auth.GET("/pagina/:pag", Pagina)
auth.GET("/formulario", Formulario)
auth.POST("/salvar", Salvar)
auth.GET("/remover/:id", Remover)
auth.GET("/editar/:id", Editar)
}
func (s *TwitterService) Run(cfg Config) error {
s.Migrate(cfg)
db, err := s.getDb(cfg)
if err != nil {
return err
}
db.SingularTable(true)
twitterResource := &TwitterResource{db: db}
r := gin.Default()
//gin.SetMode(gin.ReleaseMode)
r.Use(cors.Middleware(cors.Options{}))
ba := r.Group("/", gin.BasicAuth(gin.Accounts{
"paul": "1234",
"ming": "1234",
}))
ba.GET("/twitter", twitterResource.GetAllTwitters)
ba.GET("/twitter/:id", twitterResource.GetTwitter)
ba.POST("/twitter", twitterResource.CreateTwitter)
ba.PUT("/twitter/:id", twitterResource.UpdateTwitter)
ba.PATCH("/twitter/:id", twitterResource.PatchTwitter)
ba.DELETE("/twitter/:id", twitterResource.DeleteTwitter)
//for user
ba.GET("/user", twitterResource.GetAllUsers)
ba.GET("/user/:id", twitterResource.GetUser)
ba.POST("/user", twitterResource.CreateUser)
ba.PUT("/user/:id", twitterResource.UpdateUser)
ba.PATCH("/user/:id", twitterResource.PatchUser)
ba.DELETE("/user/:id", twitterResource.DeleteUser)
//user+twitter
ba.POST("/twitter/user/:id", twitterResource.CreateTwitterByUserId)
ba.GET("/user/:id/twitter", twitterResource.GetTwittersByUserId)
r.Run(cfg.SvcHost)
return nil
}
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 startServer() {
router := gin.Default()
// Enable HTTP basic authentication only if both user and password are set
if options.AuthUser != "" && options.AuthPass != "" {
auth := map[string]string{options.AuthUser: options.AuthPass}
router.Use(gin.BasicAuth(auth))
}
api.SetupRoutes(router)
fmt.Println("Starting server...")
go func() {
err := router.Run(fmt.Sprintf("%v:%v", options.HttpHost, options.HttpPort))
if err != nil {
fmt.Println("Cant start server:", err)
os.Exit(1)
}
}()
}
func main() {
r := gin.Default()
authorized := r.Group("", gin.BasicAuth(gin.Accounts{
"admin": "admin",
}))
env := handlers.InitEnv()
defer env.Destroy()
r.Static("/assets", "./assets")
r.GET("/", handlers.Index)
// Knots handlers
r.GET("/knots", env.AllKnot)
r.GET("/knots/:id", env.OneKnot)
authorized.POST("/knots", env.NewKnot)
authorized.PUT("/knots/:id", env.UpdateKnot)
authorized.DELETE("/knots/:id", env.DeleteKnot)
r.Run(":8001")
}
func startServer(port uint, adminPassword string) {
router := gin.Default()
router.Static("/assets", "./assets")
router.GET("/", func(c *gin.Context) {
showProjects(c)
})
authorized := router.Group("/add", gin.BasicAuth(gin.Accounts{
"admin": adminPassword,
}))
authorized.GET("", func(c *gin.Context) {
render.New(c).HTML(http.StatusOK, "add.tmpl", nil)
})
authorized.POST("", func(c *gin.Context) {
addNewProject(c)
})
router.Run(fmt.Sprintf(":%v", port))
}
func main() {
r := gin.Default()
r.Static("/assets", "./assets")
r.LoadHTMLGlob("templates/*")
/*Arduino 接入路由*/
r.POST("/device/locate", D_Locate)
/*AJAX 请求路由*/
r.GET("/ajax/location", GetLocation)
r.GET("/ajax/location/all", GetAllLocation)
/*控制台路由*/
authorized := r.Group("/admin", gin.BasicAuth(gin.Accounts{
"admin": "123456",
}))
authorized.GET("/", Index)
authorized.GET("/location/list", List)
authorized.GET("/location/delete/:id", Delete)
r.Run(":8080")
}
func main() {
appConfig, err := config.LoadAppConfig(APP_CONFIG_PATH)
if err != nil {
fmt.Println("发生错误：", err.Error())
os.Exit(-1)
}
r := gin.Default()
r.Static("/assets", "./ui/assets")
r.LoadHTMLGlob("ui/templates/*")
r.Use(appConfigMiddleware(appConfig))
if appConfig.Basic_auth.On == "yes" {
r.Use(gin.BasicAuth(gin.Accounts{appConfig.Basic_auth.Username: appConfig.Basic_auth.Password}))
}
r.GET("/", controller.Home)
r.POST("/do", controller.Do)
var port string
flag.StringVar(&port, "listen", ":8080", "listen address")
flag.Parse()
r.Run(port)
}
func main() {
defer glog.Flush()
flag.StringVar(&kubeclient.KubeConfigFile, "kubeconfig", "kubeconfig.json", "Specify the target API server")
flag.Set("logtostderr", "true")
flag.Parse()
kubeclient.Init()
portMapping = regexp.MustCompile(`PortMapping\((.*)\)`)
r := gin.Default()
r.Static("/js", "js")
r.Static("/css", "css")
r.Static("/fonts", "fonts")
r.Static("/img", "img")
r.LoadHTMLGlob("pages/*.html")
a := r.Group("/", gin.BasicAuth(gin.Accounts{
"admin": "secretsigma",
"bamboo": "oobmab",
"default": "test123",
"rds": "rrddss",
"rds-test": "rrddsstt",
}))
a.GET("/", overview)
a.GET("/namespaces/:ns", listOthersInNamespace)
a.GET("/namespaces/:ns/pods", listPodsInNamespace)
a.GET("/namespaces/:ns/pods/:po", describePod)
a.GET("/namespaces/:ns/pods/:po/log", readPodLog)
a.GET("/namespaces/:ns/pods/:po/containers/:ct/log", readContainerLog)
a.GET("/namespaces/:ns/pods/:po/edit", editPod)
a.GET("/namespaces/:ns/replicationcontrollers/:rc/edit", editReplicationController)
a.GET("/namespaces/:ns/services/:svc/edit", editService)
a.GET("/namespaces/:ns/endpoints/:ep/edit", editEndpoints)
a.GET("/nodes/:no/edit", editNode)
a.GET("/namespaces/:ns/events", listEventsInNamespace)
a.GET("/nodes", listNodes)
a.GET("/nodes/:no", describeNode)
a.GET("/help", help)
a.GET("/config", config)
a.GET("/namespaces/:ns/replicationcontrollers.form", showReplicationControllerForm)
a.POST("/namespaces/:ns/replicationcontrollers", createReplicationController)
a.GET("/namespaces/:ns/services.form", showServiceForm)
a.POST("/namespaces/:ns/services", createService)
a.POST("/namespaces/:ns/pods.form", showPodsForm)
a.POST("/namespaces/:ns/pods", performPodsAction)
a.POST("/config/update", updateConfig)
a.POST("/namespaces/:ns/pods/:po/update", updatePod)
a.POST("/namespaces/:ns/pods/:po/export", updateReplicationControllerWithPod)
a.POST("/namespaces/:ns/pods/:po/import", updatePodWithReplicationController)
a.POST("/namespaces/:ns/services/:svc/update", updateService)
a.POST("/namespaces/:ns/services/:svc/delete", deleteService)
a.POST("/namespaces/:ns/endpoints/:ep/update", updateEndpoints)
a.POST("/namespaces/:ns/endpoints/:ep/delete", deleteEndpoints)
a.POST("/namespaces/:ns/replicationcontrollers/:rc/update", updateReplicationController)
a.POST("/namespaces/:ns/replicationcontrollers/:rc/delete", deleteReplicationController)
a.POST("/nodes/:no/update", updateNode)
a.POST("/nodes/:no/delete", deleteNode)
certFile := "kubecon.crt"
keyFile := "kubecon.key"
alternateIPs := []net.IP{net.ParseIP("61.160.36.122")}
alternateDNS := []string{"kubecon"}
if err := util.GenerateSelfSignedCert("61.160.36.122", certFile, keyFile, alternateIPs, alternateDNS); err != nil {
glog.Errorf("Unable to generate self signed cert: %v", err)
} else {
glog.Infof("Using self-signed cert (%s, %s)", certFile, keyFile)
}
r.RunTLS(":8080", certFile, keyFile)
}
func main() {
model.InitTool()
r := gin.Default()
authorized := r.Group("/admin", gin.BasicAuth(gin.Accounts{
"admin": "123456",
}))
r.Use(middleware.Cookie())
r.LoadHTMLGlob("templates/*")
r.Static("/assets", "./assets")
r.GET("/", ShowIndex)
r.GET("/user/register", UserRegisterHandler)
r.GET("/user/logout", UserLogout)
r.POST("/user/register", UserRegisterHandler)
r.GET("/user/login", UserLogin)
r.POST("/user/login", UserLogin)
r.POST("address/new", NewAddress)
r.POST("address/del", DelAddress)
/* Admin */
authorized.GET("/", func(c *gin.Context) {
c.HTML(http.StatusOK, "admin_index.html", nil)
})
authorized.GET("/goods", func(c *gin.Context) {
cate := model.Category{Top: 0}
cates := cate.GetTopListNot()
goods := model.Goods{}
goods_list := goods.GetAll()
obj := make(map[string]interface{})
obj["cates"] = cates
obj["goods_list"] = goods_list
c.HTML(http.StatusOK, "admin_goods.html", obj)
})
authorized.POST("/goods/add", func(c *gin.Context) {
file, _, err := c.Request.FormFile("photo")
if err != nil {
fmt.Println(err)
return
}
defer file.Close()
timestamp := fmt.Sprintf("%d", time.Now().Unix())
saveFilePath := "./assets/data/goods/" + timestamp + ".png"
photo, err := os.OpenFile(saveFilePath, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
fmt.Println(err)
return
}
defer photo.Close()
io.Copy(photo, file)
name := c.PostForm("name")
price, _ := strconv.ParseFloat(c.PostForm("price"), 64)
cate_id, _ := strconv.Atoi(c.PostForm("cate"))
desc := c.PostForm("description")
cate := model.Category{}
cate.Get(cate_id)
fmt.Println(cate)
goods := model.Goods{Name: name, Price: price, Description: desc, Cate: cate, Photo: timestamp + ".png"}
fmt.Println(goods)
if goods.InsertToDB() {
c.Redirect(http.StatusMovedPermanently, "/admin/goods")
}
})
authorized.POST("/goods/modify", func(c *gin.Context) {
m_id, _ := strconv.Atoi(c.PostForm("m-id"))
g := model.Goods{}
g.Get(m_id)
name := c.PostForm("m-name")
price, _ := strconv.ParseFloat(c.PostForm("m-price"), 64)
cate_id, _ := strconv.Atoi(c.PostForm("m-cate"))
desc := c.PostForm("m-description")
cate := model.Category{}
cate.Get(cate_id)
g.Name = name
g.Price = price
g.Cate = cate
g.Description = desc
file, _, err := c.Request.FormFile("m-photo")
if file != nil {
defer file.Close()
rm_err := os.Remove("./assets/data/goods/" + g.Photo)
if rm_err != nil {
fmt.Println(err)
}
timestamp := fmt.Sprintf("%d", time.Now().Unix())
saveFilePath := "./assets/data/goods/" + timestamp + ".png"
photo, err := os.OpenFile(saveFilePath, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
fmt.Println(err)
return
}
defer photo.Close()
io.Copy(photo, file)
g.Photo = timestamp + ".png"
}
g.Update()
c.Redirect(http.StatusMovedPermanently, "/admin/goods")
})
authorized.POST("/goods/delete/", func(c *gin.Context) {
id, _ := strconv.Atoi(c.PostForm("id"))
goods := model.Goods{}
goods.Get(id)
goods.Delete()
c.JSON(http.StatusOK, gin.H{"message": "ok"})
})
authorized.GET("/goods/:id", func(c *gin.Context) {
goods_id, _ := strconv.Atoi(c.Param("id"))
goods := model.Goods{}
goods.Get(goods_id)
c.JSON(http.StatusOK, goods)
})
authorized.GET("/order", func(c *gin.Context) {
c.HTML(http.StatusOK, "admin_order.html", nil)
})
authorized.GET("/category", func(c *gin.Context) {
cate := model.Category{Top: 0}
top_cates := cate.GetTopList()
cates := cate.GetAll()
obj := make(map[string]interface{})
obj["top_cates"] = top_cates
obj["cates"] = cates
c.HTML(http.StatusOK, "admin_category.html", obj)
})
authorized.POST("/category/add", func(c *gin.Context) {
top, _ := strconv.Atoi(c.PostForm("top"))
name := c.PostForm("name")
cate := model.Category{Name: name, Top: top}
if cate.InsertToDB() {
c.Redirect(http.StatusMovedPermanently, "/admin/category")
}
})
authorized.POST("/category/modify", func(c *gin.Context) {
top, _ := strconv.Atoi(c.PostForm("top"))
name := c.PostForm("name")
cate := model.Category{Name: name, Top: top}
id, _ := strconv.Atoi(c.PostForm("id"))
cate.Update(id)
c.Redirect(http.StatusMovedPermanently, "/admin/category")
})
authorized.POST("/category/delete", func(c *gin.Context) {
id, _ := strconv.Atoi(c.PostForm("id"))
cate := model.Category{}
cate.Delete(id)
c.JSON(http.StatusOK, gin.H{"message": "ok"})
})
authorized.GET("/category/:id", func(c *gin.Context) {
cate_id, _ := strconv.Atoi(c.Param("id"))
cate := model.Category{}
cate.Get(cate_id)
c.JSON(http.StatusOK, cate)
})
r.Run(":8080")
}
func main() {
// Setup the Radio instance
Radio = radioman.NewRadio("RadioMan")
if err := Radio.Init(); err != nil {
logrus.Fatalf("Failed to initialize the radio: %v", err)
}
if err := Radio.StdPopulate(); err != nil {
logrus.Fatalf("Failed to populate the radio: %v", err)
}
// Setup the web server
router := gin.Default()
public := router.Group("/")
admin := router.Group("/")
liquidsoap := router.Group("/")
// Admin auth
// FIXME: make accounts dynamic
accounts := gin.Accounts{"admin": "admin"}
admin.Use(gin.BasicAuth(accounts))
// FIXME: add authentication on liquidsoap next handler
public.GET("/ping", func(c *gin.Context) {
c.String(200, "pong")
})
staticPrefix := "./radioman/web"
if os.Getenv("WEBDIR") != "" {
staticPrefix = os.Getenv("WEBDIR")
}
public.StaticFile("/", path.Join(staticPrefix, "static/index.html"))
public.Static("/static", path.Join(staticPrefix, "static"))
public.Static("/bower_components", path.Join(staticPrefix, "bower_components"))
admin.StaticFile("/admin/", path.Join(staticPrefix, "static/admin/index.html"))
admin.GET("/api/playlists", playlistsEndpoint)
admin.GET("/api/playlists/:name", playlistDetailEndpoint)
admin.PATCH("/api/playlists/:name", playlistUpdateEndpoint)
admin.GET("/api/playlists/:name/tracks", playlistTracksEndpoint)
admin.GET("/api/radios/default", defaultRadioEndpoint)
public.GET("/api/radios/default/endpoints", radioEndpointsEndpoint)
admin.POST("/api/radios/default/skip-song", radioSkipSongEndpoint)
admin.POST("/api/radios/default/play-track", radioPlayTrackEndpoint)
admin.POST("/api/radios/default/set-next-track", radioSetNextTrackEndpoint)
admin.GET("/api/tracks/:hash", trackDetailEndpoint)
liquidsoap.GET("/api/liquidsoap/getNextSong", getNextSongEndpoint)
public.GET("/playlist.m3u", m3uPlaylistEndpoint)
// Launch routines
go Radio.UpdatePlaylistsRoutine()
// Start web server mainloop
port := os.Getenv("PORT")
if port == "" {
port = "8000"
}
router.Run(fmt.Sprintf(":%s", port))
}
func basicAuthorizer() gin.HandlerFunc {
accounts := gin.Accounts{}
accounts[utils.Cfg.ApiAuthSettings.User] = utils.Cfg.ApiAuthSettings.Password
return gin.BasicAuth(accounts)
}
func TestFull(t *testing.T) {
s := loadServerCtx()
s.AllowedApps = append(s.AllowedApps, "test")
s.AppPasswd["test"] = "pass"
s.in = make(chan *logData)
defer close(s.in)
s.out = make(chan *logMetrics)
defer close(s.out)
addr := "localhost:1201"
udpAddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
t.Fatal(err)
}
server, err := net.ListenUDP("udp", udpAddr)
if err != nil {
t.Fatal(err)
}
defer server.Close()
c, err := statsdClient(addr)
if err != nil {
t.Fatal(err)
}
go logProcess(s.in, s.out)
go c.sendToStatsd(s.out)
r := gin.New()
auth := r.Group("/", gin.BasicAuth(s.AppPasswd))
auth.POST("/", s.processLogs)
data := make([]byte, 1024)
for _, tt := range fullTests {
req, _ := http.NewRequest("POST", "/", bytes.NewBuffer([]byte(tt.Req)))
req.SetBasicAuth("test", "pass")
resp := httptest.NewRecorder()
r.ServeHTTP(resp, req)
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
t.Error(err)
}
if string(body) != "OK" {
t.Error("resp body should match")
}
if resp.Code != 200 {
t.Error("should get a 200")
}
if tt.cnt != len(tt.Expected) {
t.Error("Count of expected results isn't equal to inputs")
}
for i := 0; i < tt.cnt; i++ {
n, err := server.Read(data)
if err != nil {
t.Fatal(err)
}
message := data[:n]
findEqual := false
for j := 0; j < len(tt.Expected); j++ {
if string(message) == tt.Expected[j] {
findEqual = true
}
}
if findEqual == false {
t.Errorf("Expected: %s. Actual: %s", tt.Expected[i], string(message))
}
}
}
time.Sleep(1 * time.Second)
}