Example #1
0
// GetWebService return a new gin.Engine
func GetWebService(store storage.Storage, auth *Authentication) *echo.Echo {
	log.Printf("[DEBUG] [abraracourcix] Creating web service using %v",
		store)
	ws := v1.NewWebService(store)
	e := echo.New()
	// Middleware
	e.Use(middleware.Logger())
	e.Use(middleware.Recover())
	// Routes
	e.Get("/", ws.Help())
	e.Get("/:url", ws.Redirect())
	e.Get("/api/version", ws.DisplayAPIVersion())
	v1 := e.Group("/api/v1")
	if auth != nil {
		log.Printf("[INFO] [abraracourcix] Setup secure mode : %v", auth)
		v1.Use(middleware.BasicAuth(func(user string, pwd string) bool {
			if user == auth.Username && pwd == auth.Password {
				return true
			}
			return false
		}))
	}
	v1.Get("/urls/:url", ws.URLShow())
	v1.Post("/urls", ws.URLCreate())
	v1.Get("/stats/:url", ws.URLStats())
	return e
}
Example #2
0
func main() {

	// Bluemix or local config options -- just local in this repo
	var port string
	port = DEFAULT_PORT

	var host string
	host = DEFAULT_HOST

	e := echo.New()

	// Basic Authentication
	e.Use(mw.BasicAuth(func(usr, pwd string) bool {
		if usr == appUser && pwd == appPass {
			return true
		}
		return false
	}))

	// Routes
	e.Post("/send", send)

	log.Printf("Starting mailservice on %+v:%+v\n", host, port)

	// Start server
	e.Run(host + ":" + port)

}
Example #3
0
func main() {
	// Echo instance
	e := echo.New()

	// Debug mode
	e.Debug()

	//------------
	// Middleware
	//------------

	// Logger
	e.Use(mw.Logger())

	// Recover
	e.Use(mw.Recover())

	// Basic auth
	e.Use(mw.BasicAuth(func(usr, pwd string) bool {
		if usr == "joe" && pwd == "secret" {
			return true
		}
		return false
	}))

	// Gzip
	e.Use(mw.Gzip())

	// Routes
	e.Get("/", hello)

	// Start server
	e.Run(":1323")
}
Example #4
0
func (s *ApiServer) RegisterMiddleware() {
	//s.Use(mw.Logger())
	s.Use(mw.LoggerWithConfig(mw.LoggerConfig{
		Format: `{"time":"${time_rfc3339}","remote_ip":"${remote_ip}",` +
			`"method":"${method}","uri":"${uri}","status":${status}, "latency":${latency},` +
			`"latency_human":"${latency_human}","bytes_in":${bytes_in},` +
			`"bytes_out":${bytes_out}}` + "\n",
		Output: golog.GlobalSqlLogger,
	}))
	s.Use(mw.Recover())
	s.Use(mw.BasicAuth(s.CheckAuth))
}
Example #5
0
func echoServer() {
	e := echo.New()
	e.Use(middleware.Logger())
	e.Post("/rsvp", echo.HandlerFunc(requestAddRsvp))

	admin := e.Group("/rsvp")
	admin.Use(middleware.BasicAuth(checkAuth))
	admin.Get("/list", echo.HandlerFunc(requestListRsvp))
	admin.Get("/backup", echo.HandlerFunc(requestBoltBackup))

	e.Static("/", *rootDir)

	fmt.Println("Starting Server:", *httpServ)
	e.Run(standard.New(*httpServ))
}
Example #6
0
// AuthMiddleware checks login credentials.
func AuthMiddleware(rootUsername, rootPassword string, s store.Store) echo.MiddlewareFunc {
	return middleware.BasicAuth(func(username, password string) bool {
		if username == rootUsername {
			return password == rootPassword
		}

		user, err := s.GetUserByUsername(username)
		if err != nil {
			log.Error("Failed to retrieve user: ", err)
			return false
		}

		return bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(password)) == nil
	})
}
Example #7
0
// GetWebService return a new gin.Engine
func GetWebService(auth *Authentication) *echo.Echo {
	log.Printf("[DEBUG] Creating web service")
	ws := v1.NewWebService()
	e := echo.New()
	// Middleware
	e.Use(middleware.Logger())
	e.Use(middleware.Recover())
	// Routes
	e.Get("/", ws.Help())
	e.Get("/api/version", ws.DisplayAPIVersion())
	v1 := e.Group("/api/v1")
	if auth != nil {
		log.Printf("[INFO] Setup secure mode : %v", auth)
		v1.Use(middleware.BasicAuth(func(user string, pwd string) bool {
			if user == auth.Username && pwd == auth.Password {
				return true
			}
			return false
		}))
	}
	return e
}
Example #8
0
File: main.go Project: nubunto/vise
func main() {
	app := cli.NewApp()
	app.Usage = "Serve temporary and unimportant files"
	app.Flags = []cli.Flag{
		cli.IntFlag{
			Name:  "port, p",
			Value: 8080,
			Usage: "The port which to listen",
		},
		cli.StringFlag{
			Name:  "upload-path, u",
			Value: "uploaded",
			Usage: "The directory on which to save uploaded data",
		},
	}
	app.Action = func(c *cli.Context) {
		uppath.UploadedPath = c.String("upload-path")
		err := uppath.EnsureDirectories("data", "uploaded")
		if err != nil {
			log.Fatal(err)
		}

		err = persistence.Init()
		if err != nil {
			log.Fatal(err)
		}
		defer persistence.Close()

		vise := echo.New()

		vise.SetLogPrefix("vise")
		vise.Use(mw.Logger())
		vise.Use(mw.Recover())

		apiEndpoint := vise.Group("/api")
		apiEndpoint.POST("/save", api.SaveFile)
		apiEndpoint.GET("/links", api.GetLinks)
		apiEndpoint.GET("/:token/links", api.GetTokenLinks)
		apiEndpoint.GET("/download/:file", api.DownloadFile)

		private := vise.Group("/private")
		private.Use(mw.BasicAuth(func(usr, pwd string) bool {
			return usr == os.Getenv("VISE_USER") && pwd == os.Getenv("VISE_PWD")
		}))
		private.GET("/stats", func(c echo.Context) error {
			return c.JSON(http.StatusOK, persistence.DbStats())
		})
		private.GET("/inspect", func(c echo.Context) error {
			d, err := persistence.Inspect()
			if err != nil {
				return err
			}
			return c.JSON(http.StatusOK, d)
		})

		vise.Use(mw.Logger())
		vise.Use(mw.Recover())

		//assets := http.FileServer(assetFS())
		//vise.GET("/", assets)
		//vise.Get("/static/*", assets)

		destroyer.Scan()

		port := strconv.Itoa(c.Int("port"))
		if err != nil {
			log.Fatal(err)
		}
		//log.Fatal(http.ListenAndServe(":"+port, vise))
		vise.Run(standard.New(":" + port))

	}
	app.Run(os.Args)
}
Example #9
0
// Run This starts the api listening on the port supplied
func Run(port int, database string) {
	db, err := models.NewDB(database)
	if err != nil {
		log.Panic(err)
	}

	env := &Env{db, "me"}

	// Echo instance
	e := echo.New()
	// Gives pretty formatting
	// e.SetDebug(true)

	if basicAuth != "" {
		e.Use(middleware.BasicAuth(func(username, password string) bool {
			match := fmt.Sprintf("%s:%s", username, password)

			if match == basicAuth {
				return true
			}
			return false
		}))
	}

	// Middleware
	e.Use(middleware.Logger())
	e.Use(middleware.Recover())

	// Route => handler
	e.GET("/", func(c echo.Context) error {
		message := "1, 2, 3. Lets go!"
		response := &responseMessage{
			Message: message,
		}
		return c.JSON(http.StatusOK, response)
	})

	e.POST("/alist", func(c echo.Context) error {
		uuid := getUUID()
		fmt.Println(uuid)
		fmt.Println(len(uuid))
		message := fmt.Sprintf("I want to upload alist with uuid: %s", uuid)
		response := &responseMessage{
			Message: message,
		}
		return c.JSON(http.StatusOK, response)
	})

	e.PUT("/alist/:uuid", func(c echo.Context) error {
		uuid := c.Param("uuid")
		message := fmt.Sprintf("I want to alter alist with uuid: %s", uuid)
		response := &responseMessage{
			Message: message,
		}
		return c.JSON(http.StatusOK, response)
	})

	e.PATCH("/alist/:uuid", func(c echo.Context) error {
		uuid := c.Param("uuid")
		message := fmt.Sprintf("I want to alter alist with uuid: %s", uuid)
		response := &responseMessage{
			Message: message,
		}
		return c.JSON(http.StatusOK, response)
	})

	e.GET("/alist/:uuid", func(c echo.Context) error {
		uuid := c.Param("uuid")
		alist, err := env.db.GetAlist(uuid)
		if err != nil {
			message := fmt.Sprintf("Failed to find alist with uuid: %s", uuid)
			response := new(responseMessage)
			response.Message = message
			return c.JSON(http.StatusBadRequest, *response)
		}
		return c.JSON(http.StatusOK, *alist)
	})

	e.GET("/alist/by/:uuid", func(c echo.Context) error {
		uuid := c.Param("uuid")
		alists, err := env.db.GetListsBy(uuid)
		if err != nil {
			message := fmt.Sprintf("Failed to find all lists.")
			response := new(responseMessage)
			response.Message = message
			return c.JSON(http.StatusBadRequest, *response)
		}
		return c.JSON(http.StatusOK, alists)
	})

	// Start server
	listenOn := fmt.Sprintf(":%d", port)
	e.Run(standard.New(listenOn))
}
Example #10
-1
File: server.go Project: xtfly/gofd
// OnStart ...
func (s *Server) OnStart(c *common.Config, e *echo.Echo) error {
	go func() { s.sessionMgnt.Start() }()

	e.Use(middleware.BasicAuth(s.Auth))
	e.POST("/api/v1/server/tasks", s.CreateTask)
	e.DELETE("/api/v1/server/tasks/:id", s.CancelTask)
	e.GET("/api/v1/server/tasks/:id", s.QueryTask)
	e.POST("/api/v1/server/tasks/status", s.ReportTask)

	return nil
}