Esempio n. 1
0
func main() {
	m := martini.Classic()
	m.Post("/text", binding.Bind(DisplayMessage{}), createText)
	m.Post("/image", binding.MultipartForm(ImageMessage{}), createImage)
	m.Post("/display", binding.Bind(IDMessage{}), displayImage)
	m.Run()
}
Esempio n. 2
0
func init() {
	// BASE_URL, AUTH_USER and AUTH_PASS, AWS_S3_BASE_URL are not required or else wercker tests would fail
	baseURL = os.Getenv("BASE_URL")
	authUser = os.Getenv("AUTH_USER")
	authPass = os.Getenv("AUTH_PASS")
	s3BaseURL = os.Getenv("AWS_S3_BASE_URL")

	if awsAuth, err := aws.EnvAuth(); err != nil {
		// not required or else wercker tests would fail
		log.Println(err)
	} else {
		// TODO(jrubin) allow region to be chosen by env variable
		s3Data := s3.New(awsAuth, aws.USWest2)
		s3Bucket = s3Data.Bucket(os.Getenv("AWS_S3_BUCKET_NAME"))
	}

	m = martini.Classic()

	m.Use(gzip.All())
	m.Use(render.Renderer())

	m.Get("/", func() string {
		return "hello, world"
	})

	m.Post(
		"/v1/transcribe",
		auth.Basic(authUser, authPass),
		strict.Accept("application/json"),
		strict.ContentType("application/x-www-form-urlencoded"),
		binding.Bind(transcribeData{}),
		binding.ErrorHandler,
		handleTranscribe,
	)

	m.Post(
		"/v1/transcribe/process",
		strict.ContentType("application/x-www-form-urlencoded"),
		binding.Bind(telapi.TranscribeCallbackData{}),
		binding.ErrorHandler,
		handleTranscribeProcess,
	)

	m.Post(
		"/v1/transcribe/upload",
		auth.Basic(authUser, authPass),
		strict.Accept("application/json"),
		binding.MultipartForm(transcribeUploadData{}),
		binding.ErrorHandler,
		handleTranscribeUpload,
	)

	m.Router.NotFound(strict.MethodNotAllowed, strict.NotFound)
}
Esempio n. 3
0
//martini Handler
func UploadHandlers() []martini.Handler {
	var upload = func(fileData FileData, data UploadData, w http.ResponseWriter) {
		retJsonp := &UploadRetJsonp{MessengerJs: MessengerJs, UpTime: data.UpTime}

		if strings.ToUpper(data.Dir) != "IMAGE" {
			retJsonp.Err(w, "dir wrong:"+data.Dir)
			return
		}

		imgFile, err := fileData.ImgFile.Open()
		if err != nil {
			retJsonp.Err(w, "ImgFile:"+err.Error())
			return
		}

		//取得bucket
		bucket, err := bucketdb.FindByName(data.Bucket)
		if err != nil {
			retJsonp.Err(w, "FindByName:"+err.Error())
			return
		}

		if bucket.Uptoken == "" {
			if err := bucket.NewUptoken(); err != nil {
				retJsonp.Err(w, "NewUptoken:"+err.Error())
				return
			}
			if err := bucket.Save(); err != nil {
				retJsonp.Err(w, "Save:"+err.Error())
				return
			}
		}

		//上传内容到Qiniu
		var ret qio.PutRet
		// ret       	变量用于存取返回的信息,详情见 qio.PutRet
		// uptoken   	为业务服务器端生成的上传口令
		// key:imgName	为文件存储的标识
		// r:imgFile   	为io.Reader类型,用于从其读取数据
		// extra     	为上传文件的额外信息,可为空, 详情见 qio.PutExtra, 可选
		err = qio.Put(nil, &ret, bucket.Uptoken, fileData.ImgName(), imgFile, nil)
		if err != nil {
			bucket.LogErr()
			retJsonp.Err(w, "Put:"+err.Error())
			return
		}

		//上传成功,返回给KindEditor
		//w.Header().Set("Content-type", "application/json")
		retJsonp.Respose(w, bucket.ImgUrl(ret.Key))
	}
	return []martini.Handler{binding.MultipartForm(FileData{}), binding.Form(UploadData{}), upload}
}
Esempio n. 4
0
func main() {

	server := martini.Classic()
	config := InitConfig()

	//添加中间件
	server.Use(render.Renderer(render.Options{ //render中间件可以把对象方便的序列化为xml或者json
		Directory:  "./html",
		Extensions: []string{".html"},
		Charset:    "UTF-8",
	}))
	server.Use(martini.Static("public")) //静态文件服务

	//添加路由
	//第一个参数是url路径,
	//之后的参数是处理该路径请求的处理函数,
	//可以添加多个,依次调用
	//方法名表示该路径的HTTP方法,表示只能用GET访问该路径。
	server.Get("/", cookie.Bind(UserCookie{}), handleHome)

	//Group是父路径下添加子路径,下面url分别表示/sched/all, /sched/all, /sched/delete。
	//在父路径里添加的处理函数在子路径中都会运行,
	//比如下面的cookie.Bind(UserCookie{}),该方法返回值是一个函数,表示这个路径以及所有的子路径都绑定了一个cookie。
	server.Group("/sched", func(r martini.Router) {
		r.Post("/add", binding.Form(Sched{}), handleAddSched)
		r.Get("/all", handleGetSched)
		r.Post("/delete", handleDelSched)
	}, cookie.Bind(UserCookie{}))

	server.Group("/user", func(r martini.Router) {
		r.Post("/login", binding.Form(UserLoginForm{}), LoginHandler)
		r.Post("/logout")
		r.Post("/register", binding.Form(UserRegisterForm{}), RegisterHandler)
		r.Post("/checklogin", cookie.Bind(UserCookie{}), CheckLoginHandler)
		r.Group("/bkimg", func(rr martini.Router) {
			rr.Post("/upload", binding.MultipartForm(Bkimg{}), UploadBkimg)
			rr.Get("/get", GetBkimg)
		}, cookie.Bind(UserCookie{}))

	})

	//映射服务
	logger := log.New(os.Stdout, "[martini] ", log.Llevel|log.Lshortfile|log.Lmodule)
	//Map方法传入的对象可以被传入到处理函数的对应参数中。
	server.Map(logger)
	server.Map(config)

	server.RunOnAddr(":" + config.Server.Port)

}
Esempio n. 5
0
File: main.go Progetto: jf/gwp
func main() {
	m := martini.Classic()
	m.Use(render.Renderer(render.Options{
		Directory:  "templates",
		Extensions: []string{".html"},
	}))
	m.Use(martini.Static("public"))

	m.Get("/", upload)
	m.Post("/mosaic", binding.MultipartForm(UploadForm{}), mosaic)

	TILESDB = make(map[string][3]float64)
	go tilesDB()
	m.Run()

}
Esempio n. 6
0
func main() {
	// Set up logging for CLI
	log.SetPrefix("")
	log.SetFlags(0) // Remove the timestamp

	// Connect to redis
	err := redisInit()
	if err != nil {
		log.Println("Connecting to redis failed", err)
	}

	app := cli.NewApp()
	app.Name = "pixlserv"
	app.Usage = "transform and serve images"
	app.Version = "1.0"
	app.Commands = []cli.Command{
		{
			Name:  "run",
			Usage: "Runs the server (run [config-file])",
			Action: func(c *cli.Context) {
				// Set up logging for server
				log.SetPrefix("[pixlserv] ")

				if len(c.Args()) < 1 {
					log.Println("You need to provide a path to a config file")
					return
				}
				configFilePath := c.Args().First()

				// Initialise configuration
				err := configInit(configFilePath)
				if err != nil {
					log.Println("Configuration reading failed:", err)
					return
				}
				log.Printf("Running with config: %+v", Config)

				// Initialise authentication
				err = authInit()
				if err != nil {
					log.Println("Authentication initialisation failed:", err)
					return
				}

				// Initialise storage
				err = storageInit()
				if err != nil {
					log.Println("Storage initialisation failed:", err)
					return
				}

				// Run the server
				m := martini.Classic()
				if Config.throttlingRate > 0 {
					m.Use(throttler(Config.throttlingRate))
				}
				m.Use(func(res http.ResponseWriter, req *http.Request) {
					if uploadURLRe.MatchString(req.URL.Path) {
						// The upload handler returns JSON
						res.Header().Set("Content-Type", "application/json")
					}
				})
				m.Get("/", func() string {
					return "It works!"
				})
				m.Get("/((?P<apikey>[A-Z0-9]+)/)?image/:parameters/**", transformationHandler)
				m.Post("/((?P<apikey>[A-Z0-9]+)/)?upload", binding.MultipartForm(UploadForm{}), uploadHandler)
				go m.Run()

				// Wait for when the program is terminated
				ch := make(chan os.Signal)
				signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
				<-ch

				// Clean up
				redisCleanUp()
				storageCleanUp()
			},
		},
		{
			Name:  "api-key",
			Usage: "Manages API keys",
			Subcommands: []cli.Command{
				{
					Name:  "add",
					Usage: "Adds a new one",
					Action: func(c *cli.Context) {
						key, err := generateKey()
						if err != nil {
							log.Println("Adding a new API key failed, please try again")
							return
						}

						log.Println("Key added:", key)
					},
				},
				{
					Name:  "info",
					Usage: "Shows information about a key (info [key])",
					Action: func(c *cli.Context) {
						if len(c.Args()) < 1 {
							log.Println("You need to provide an existing key")
							return
						}
						key := c.Args().First()
						permissions, err := infoAboutKey(key)
						if err != nil {
							log.Println(err.Error())
							return
						}
						log.Println("Key:", key)
						log.Println("Permissions:", permissions)
					},
				},
				{
					Name:  "list",
					Usage: "Shows all keys",
					Action: func(c *cli.Context) {
						keys, err := listKeys()
						if err != nil {
							log.Println("Retrieving the list of all keys failed")
							return
						}

						log.Println("Keys:", keys)
					},
				},
				{
					Name:  "modify",
					Usage: "Modifies permissions for a key (modify [key] [add/remove] [" + authPermissionsOptions() + "])",
					Action: func(c *cli.Context) {
						if len(c.Args()) < 3 {
							log.Println("You need to provide an existing key, operation and a permission")
							return
						}
						key := c.Args().First()
						err := modifyKey(key, c.Args()[1], c.Args()[2])
						if err != nil {
							log.Println(err.Error())
							return
						}
						log.Println("The key has been updated")
					},
				},
				{
					Name:  "remove",
					Usage: "Removes an existing key (remove [key])",
					Action: func(c *cli.Context) {
						if len(c.Args()) < 1 {
							log.Println("You need to provide an existing key")
							return
						}
						err := removeKey(c.Args().First())
						if err != nil {
							log.Println(err.Error())
							return
						}
						log.Println("The key was successfully removed")
					},
				},
			},
		},
	}

	app.Run(os.Args)
}
Esempio n. 7
0
func main() {
	m := martini.Classic()

	// Gzip all
	m.Use(gzip.All())

	// Create sessions cookie store
	store := sessions.NewCookieStore([]byte(utils.AppCfg.SecretKey()))
	m.Use(sessions.Sessions("pixelrelay", store))

	// Setup render options
	m.Use(render.Renderer(render.Options{
		Directory: "templates",                            // Specify what path to load the templates from.
		Layout:    "layout",                               // Specify a layout template. Layouts can call {{ yield }} to render the current template.
		Charset:   "UTF-8",                                // Sets encoding for json and html content-types.
		Delims:    render.Delims{Left: "{[", Right: "]}"}, // Sets delimiters to the specified strings.
	}))

	// Setup DB
	dbh := db.Init(&db.Dbh{})
	m.Map(dbh)

	// Setup static file handling
	opts := martini.StaticOptions{SkipLogging: false, Expires: utils.ExpiresHeader}
	m.Use(martini.Static("static", opts))

	// Auth user and assign to session
	m.Use(middleware.UserAuth(models.User{}, dbh))

	// Encoder for .html or .json encoding
	m.Use(encoder.MapEncoder)

	// Setup Page
	p := models.InitPage(&models.Page{})
	m.Map(p)

	// Set up routes
	m.Get("/", controllers.Index)

	// Images
	m.Get("/image/:name", middleware.VerifyFile, controllers.ImagePage)
	m.Get("/o/:name", middleware.VerifyFile, controllers.Image)
	m.Get("/i/:name", middleware.VerifyFile, controllers.ImageModified)
	m.Get("/t/:name", middleware.VerifyFile, controllers.Thumb)
	m.Get("/image/trash/:album/:name", middleware.AuthRequired, controllers.ImageTrash)
	m.Get("/image/recover/:album/:name", middleware.AuthRequired, controllers.ImageRecover)

	// Albums
	m.Get("/albums", controllers.Albums)
	m.Get("/album/:name", controllers.Album)
	m.Get("/album/:name/qr", controllers.QR)
	m.Get("/:user/albums", controllers.Albums)
	m.Get("/:user/album/:name", controllers.Album)
	m.Get("/album/:name/private/:state", controllers.AlbumPrivate)

	m.Get("/album/:name/:key", controllers.Album)

	m.Post("/album/create", middleware.AuthRequired, controllers.AlbumCreate)
	m.Post("/album/update", middleware.AuthRequired, controllers.AlbumUpdate)
	m.Post("/album/delete/:name", middleware.AuthRequired, controllers.AlbumDelete)
	m.Post("/album/recover/:name", middleware.AuthRequired, controllers.AlbumRecover)
	m.Post("/album/move", middleware.AuthRequired, controllers.AlbumMove)

	// Tag
	m.Get("/tags", controllers.Tags)
	m.Get("/tag/:tag", controllers.Tagged)
	m.Post("/tag", middleware.AuthRequired, controllers.TagImage)

	// Auth
	m.Get("/login", controllers.Login)
	m.Post("/login", binding.Bind(forms.Login{}), binding.ErrorHandler, controllers.LoginPost)
	m.Get("/logout", controllers.Logout)

	// Upload
	m.Post("/up", middleware.Verify, binding.MultipartForm(models.ImageUpload{}), controllers.UploadImage)

	// 404
	m.NotFound(controllers.NotFound)

	// Account
	m.Get("/account", middleware.AuthRequired, controllers.Account)

	// Profile
	m.Get("/profile/:name", controllers.Profile)

	// Testing
	m.Get("/test/hash", test.Hash)
	m.Get("/test/hash/:user_id/:image_id", test.Hash)
	m.Get("/test/list", middleware.AuthRequired, test.List)
	m.Get("/test/listdb", middleware.AuthRequired, test.ListDB)
	m.Get("/test/listt", middleware.AuthRequired, test.ListThumb)
	m.Get("/test/uploader", middleware.AuthRequired, test.Uploader)

	// Start server and begin listening for HTTP requests
	// Watch for non-https requests and redirect to https
	// If request method is POST and path is /up
	//   discard file and redirect to correct https route
	log.Printf("Listening for \x1b[32;1mHTTP\x1b[0m connections on \x1b[32;1m%s\x1b[0m\n", utils.AppCfg.ListenOn())
	go http.ListenAndServe(utils.AppCfg.ListenOn(), http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		urlPath := r.URL.Path
		url := strings.Join([]string{utils.AppCfg.Url(), urlPath}, "")

		// Check if path is for the Upload controller.
		// Redirect client to HTTPS end point
		if urlPath == "/up" && r.Method == "POST" {
			ur := models.UploadResult{
				Code:   http.StatusFound,
				Result: "HTTPS Required",
				Name:   url,
			}
			log.Println(ur.String())

			// Move uploaded file to DevNull
			file, _, _ := r.FormFile("uploaded_file")
			defer file.Close()
			out, err := os.Create(os.DevNull)
			if err != nil {
				log.Println(err)
			}
			defer out.Close()
			_, err = io.Copy(out, file)
			if err != nil {
				log.Println(err)
			}

			// Respond with JSON that server requires HTTPS and correct path.
			w.Header().Set("X-Content-Type-Options", "nosniff")
			w.Header().Set("Expires", utils.ExpiresHeader())
			w.Header().Set("Content-Type", "application/json")
			fmt.Fprint(w, ur)
			return
		}

		log.Println("Redirect: ", url)
		http.Redirect(w, r, url, http.StatusFound)
	}))

	// Start server and begin listening for TLS requests
	log.Printf("Listening for \x1b[32;1mTLS\x1b[0m connections on \x1b[32;1m%s\x1b[0m\n", utils.AppCfg.TLSListenOn())
	go http.ListenAndServeTLS(utils.AppCfg.TLSListenOn(), "./tls/cert.pem", "./tls/key.pem", m)

	/******************************************
	*	INITIAL SETUP
	*
	*   Creates the initial tables
	*   Populates the default admin user
	*
	*   Potential security risks are present
	*   if this mode is left running.
	*	restart server with the "-init" flag
	*   unset.
	*
	*   usage: -init
	 */
	if *flagInit {
		fmt.Println("\x1b[31;1mInitial Setup flag (-init) has been set to \x1b[32;1mTRUE\x1b[0m")
		fmt.Println("\x1b[31;1mOnce setup is complete please restart server with this flag disabled.\x1b[0m")

		// Add default tables
		dbh.AddTables()

		su := martini.Classic()

		store := sessions.NewCookieStore([]byte(utils.AppCfg.SecretKey()))
		su.Use(sessions.Sessions("pixelrelay", store))
		su.Use(render.Renderer(render.Options{
			Directory: "templates", // Specify what path to load the templates from.
			Layout:    "layout",    // Specify a layout template. Layouts can call {{ yield }} to render the current template.
			Charset:   "UTF-8",     // Sets encoding for json and html content-types.
		}))
		su.Get("/setup", controllers.SetupAdmin)
		su.Post("/setup", binding.Bind(forms.SetupAdmin{}), binding.ErrorHandler, controllers.SetupAdminPost)
		// Start server and begin listening for requests
		log.Printf("Listening for connections on \x1b[32;1m%s\x1b[0m\n", utils.AppCfg.ListenOnSetup())

		go http.ListenAndServe(utils.AppCfg.ListenOnSetup(), su)
	}

	/******************************************
	*	MIGRATE DATABASE UPDATES
	*
	*   Migrates changes to database tables
	*
	*   You should backup the database before
	*   migrating. As there is a potential risk
	*   of data loss
	*
	*   usage: -migrate
	 */
	if *flagMigrate {
		dbh.MigrateDB()
	}

	select {}
}