Beispiel #1
1
func (fe *Frontend) RunServer(blocking bool) http.Handler {
	api := rest.NewApi()
	api.Use(&rest.AuthBasicMiddleware{
		Realm: "test zone",
		Authenticator: func(userId string, password string) bool {
			if userId == fe.cfg.Network.Username &&
				password == fe.cfg.Network.Password {
				return true
			}
			return false
		},
	})
	api.Use(rest.DefaultDevStack...)
	router, err := rest.MakeRouter(
		rest.Get("/subnets", fe.GetAllSubnets),
		rest.Get("/subnets/#id", fe.GetSubnet),
		rest.Post("/subnets", fe.CreateSubnet),
		rest.Put("/subnets/#id", fe.UpdateSubnet),
		rest.Delete("/subnets/#id", fe.DeleteSubnet),
		rest.Post("/subnets/#id/bind", fe.BindSubnet),
		rest.Delete("/subnets/#id/bind/#mac", fe.UnbindSubnet),
		rest.Put("/subnets/#id/next_server/#ip", fe.NextServer),
	)
	if err != nil {
		log.Fatal(err)
	}
	api.SetApp(router)

	connStr := fmt.Sprintf(":%d", fe.cfg.Network.Port)
	log.Println("Web Interface Using", connStr)
	if blocking {
		if fe.cert_pem == "" || fe.key_pem == "" {
			log.Fatal(http.ListenAndServe(connStr, api.MakeHandler()))
		} else {
			log.Fatal(http.ListenAndServeTLS(connStr, fe.cert_pem, fe.key_pem, api.MakeHandler()))
		}
	}
	return api.MakeHandler()
}
Beispiel #2
0
func Route() (rest.App, error) {

	return rest.MakeRouter(
		// 新增某个服务
		rest.Post("/apps", restGuarder(handler.CreateAppsHandler)),
		// 获取所有服务的基本信息
		rest.Get("/apps", restGuarder(handler.GetInfoAppsHandler)),
		// TODO 获取某一个服务的详细信息
		rest.Get("/apps/*appId", restGuarder(handler.GetSingleAppsHandler)),
		// 删除某一个服务的所有实例
		rest.Delete("/apps/*appId", restGuarder(handler.DeleteAppsHandler)),
		// 新增或者更新一批服务
		rest.Post("/apps/updater", restGuarder(handler.CreateOrUpdateAppsHandler)),
		// 回滚一批服务
		rest.Post("/apps/rollback", restGuarder(handler.RollbackAppsHandler)),
		// 新增一批组信息
		rest.Post("/groups", restGuarder(handler.DeployGroupsHandler)),

		// 给新增容器获取一个IP
		rest.Get("/ipholder/*cId", restGuarder(handler.CreateIpForContainer)),
		// 给删除容器释放所占用的IP
		rest.Delete("/ipholder/*cId", restGuarder(handler.DeleteIpForContainer)),

		// 填写某个容器信息
		rest.Post("/containers", restGuarder(handler.CreateContainerInfo)),
		// 更新容器状态
		rest.Post("/containers/:cId/:cState", restGuarder(handler.UpdateStateContainerInfo)),
		// 软删除容器
		rest.Delete("/containers/soft/*cId", restGuarder(handler.MaskContainerInfo)),
	)
}
Beispiel #3
0
func initRoutes(restApi *rest.Api) {
	authController := &AuthController{}
	appController := &ApplicationController{}
	typesController := &TypesController{}

	router, err := rest.MakeRouter(
		rest.Put(authController.Path(), authController.RegisterUserHandler),
		rest.Post(authController.Path(), authController.LoginUserHandler),
		rest.Put("/:appId"+authController.Path(), authController.AppRegisterUserHandler),
		rest.Post("/:appId"+authController.Path(), authController.AppLoginUserHandler),

		rest.Post(appController.Path(), appController.CreateApplicationHandler),
		rest.Get(appController.Path(), appController.GetApplicationsHandler),
		rest.Get(appController.Path()+"/:appId", appController.GetApplicationHandler),
		rest.Delete(appController.Path()+"/:appId", appController.DeleteApplicationHandler),
		rest.Put(appController.Path()+"/:appId", appController.UpdateApplicationHandler),

		rest.Post("/:appId"+typesController.Path(), typesController.CreateTypeHandler),
		rest.Delete("/:appId"+typesController.Path()+"/:typeName", typesController.DeleteType),
		rest.Post("/:appId"+typesController.Path()+"/:typeName", typesController.InsertInTypeHandler),
		rest.Get("/:appId"+typesController.Path()+"/:typeName", typesController.GetTypeDataHandler),
		rest.Get("/:appId"+typesController.Path()+"/:typeName/:itemId", typesController.GetTypeItemById),
		rest.Put("/:appId"+typesController.Path()+"/:typeName/:itemId", typesController.UpdateTypeItemById),
		rest.Delete("/:appId"+typesController.Path()+"/:typeName/:itemId", typesController.DeleteTypeItemById),
	)

	if err != nil {
		log.Fatal(err)
	}

	restApi.SetApp(router)
}
Beispiel #4
0
func main() {
	var err error

	api := rest.NewApi()

	// Enable basic middlewares.
	api.Use(rest.DefaultDevStack...)
	// Enable CORS middleware.
	api.Use(&rest.CorsMiddleware{
		RejectNonCorsRequests: false,
		OriginValidator: func(origin string, request *rest.Request) bool {
			return true
		},
		AllowedMethods: []string{"GET", "POST", "PUT", "DELETE"},
		AllowedHeaders: []string{
			"Accept", "Content-Type", "X-Custom-Header", "Origin"},
		AccessControlAllowCredentials: true,
		AccessControlMaxAge:           3600,
	})
	// Enable token validation middleware.
	api.Use(&mw.AuthMW{})

	router, err := rest.MakeRouter(
		// cards.
		rest.Get("/cards", GetUserCards),
		rest.Get("/cards/:cid", GetCard),
		rest.Post("/cards", CreateCard),
		rest.Put("/cards/:cid", UpdateCard),
		rest.Delete("/cards/:cid", DeleteCard),

		rest.Get("/challenge", GetChallenge),
		rest.Post("/results", SaveResult),

		// user endpoints.
		rest.Get("/users/:uid", GetUser),
		rest.Put("/users/:uid", UpdateUser),
		rest.Delete("/users/:uid", DeleteUser),

		// token
		rest.Post("/token", GetToken),

		// ping
		rest.Get("/ping", Ping),
	)

	if err != nil {
		log.Fatal(err)
	}

	api.SetApp(router)
	log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
}
Beispiel #5
0
func main() {
	i := Impl{}
	i.InitDB()
	i.InitSchema()

	api := rest.NewApi()
	api.Use(rest.DefaultDevStack...)
	api.Use(&rest.CorsMiddleware{
		RejectNonCorsRequests: false,
		OriginValidator: func(origin string, request *rest.Request) bool {
			return true
		},
		AllowedMethods: []string{"GET", "POST", "PUT"},
		AllowedHeaders: []string{
			"Accept", "Content-Type", "X-Custom-Header", "Origin"},
		AccessControlAllowCredentials: true,
		AccessControlMaxAge:           3600,
	})
	router, err := rest.MakeRouter(
		rest.Get("/services", i.GetAllServices),
		rest.Post("/services", i.PostService),
		rest.Get("/services/:id", i.GetService),
		rest.Put("/services/:id", i.PutService),
		rest.Delete("/services/:id", i.DeleteService),
	)
	if err != nil {
		log.Fatal(err)
	}
	api.SetApp(router)
	log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
}
Beispiel #6
0
func (r *Controller) serveREST(conf *goconf.ConfigFile) {
	c, err := parseRESTConfig(conf)
	if err != nil {
		r.log.Err(fmt.Sprintf("Controller: parsing REST configurations: %v", err))
		return
	}

	api := rest.NewApi()
	router, err := rest.MakeRouter(
		rest.Get("/api/v1/switch", r.listSwitch),
		rest.Post("/api/v1/switch", r.addSwitch),
		rest.Delete("/api/v1/switch/:id", r.removeSwitch),
		rest.Options("/api/v1/switch/:id", r.allowOrigin),
		rest.Get("/api/v1/port/:switchID", r.listPort),
		rest.Get("/api/v1/network", r.listNetwork),
		rest.Post("/api/v1/network", r.addNetwork),
		rest.Delete("/api/v1/network/:id", r.removeNetwork),
		rest.Options("/api/v1/network/:id", r.allowOrigin),
		rest.Get("/api/v1/ip/:networkID", r.listIP),
		rest.Get("/api/v1/host", r.listHost),
		rest.Post("/api/v1/host", r.addHost),
		rest.Delete("/api/v1/host/:id", r.removeHost),
		rest.Options("/api/v1/host/:id", r.allowOrigin),
		rest.Get("/api/v1/vip", r.listVIP),
		rest.Post("/api/v1/vip", r.addVIP),
		rest.Delete("/api/v1/vip/:id", r.removeVIP),
		rest.Options("/api/v1/vip/:id", r.allowOrigin),
		rest.Put("/api/v1/vip/:id", r.toggleVIP),
	)
	if err != nil {
		r.log.Err(fmt.Sprintf("Controller: making a REST router: %v", err))
		return
	}
	api.SetApp(router)

	addr := fmt.Sprintf(":%v", c.port)
	if c.tls.enable {
		err = http.ListenAndServeTLS(addr, c.tls.certFile, c.tls.keyFile, api.MakeHandler())
	} else {
		err = http.ListenAndServe(addr, api.MakeHandler())
	}

	if err != nil {
		r.log.Err(fmt.Sprintf("Controller: listening on HTTP: %v", err))
		return
	}
}
Beispiel #7
0
func getRouter() (rest.App, error) {
	mcPlugins := routes.McPlugins{}

	router, err := rest.MakeRouter(
		rest.Get("/plugins", mcPlugins.GetAllPlugins),
		rest.Post("/plugins", mcPlugins.PostPlugin),
		rest.Get("/plugins/:id", mcPlugins.GetPlugin),
		rest.Put("/plugins/:id", mcPlugins.PutPlugin),
		rest.Delete("/plugins/:id", mcPlugins.DeletePlugin),
	)
	return router, err
}
Beispiel #8
0
func main() {

	// serve ng-admin angular app
	fs := http.FileServer(http.Dir("static"))
	http.Handle("/admin/", http.StripPrefix("/admin/", fs))

	db, err := sql.Open("sqlite3", "./blog.db")

	defer db.Close()

	if err != nil {
		panic(err)
	}

	api := rest.NewApi()
	api.Use(rest.DefaultProdStack...)

	api.Use(&rest.CorsMiddleware{
		RejectNonCorsRequests: false,
		OriginValidator: func(origin string, request *rest.Request) bool {
			return true
		},
		AllowedMethods: []string{"GET", "POST", "PUT", "DELETE"},
		AllowedHeaders: []string{
			"Accept", "Content-Type", "X-Total-Count", "Origin"},
		AccessControlAllowCredentials: true,
		AccessControlMaxAge:           3600,
	})

	// initialize Entity REST API
	entityManager := eram.NewEntityDbManager(db)
	entityRestApi := era.NewEntityRestAPI(entityManager)

	router, err := rest.MakeRouter(
		rest.Get("/api/:entity", entityRestApi.GetAllEntities),
		rest.Post("/api/:entity", entityRestApi.PostEntity),
		rest.Get("/api/:entity/:id", entityRestApi.GetEntity),
		rest.Put("/api/:entity/:id", entityRestApi.PutEntity),
		rest.Delete("/api/:entity/:id", entityRestApi.DeleteEntity),
	)

	if err != nil {
		log.Fatal(err)
	}

	api.SetApp(router)

	http.Handle("/api/", api.MakeHandler())
	log.Fatal(http.ListenAndServe(":8080", nil))
}
Beispiel #9
0
func NewApi() *ApiHander {
	handler := ApiHandler{
		Api: rest.NewApi(),
	}
	handler.Api.Use(rest.DefaultDevStack...)
	router, err := rest.MakeRouter(
		rest.Post("/jobs", handler.CreateJob),
		rest.Get("/jobs", handler.GetJobs),
		rest.Get("/jobs/:id", handler.GetJob),
		rest.Put("/jobs/:id", handler.UpdateJob),
		rest.Delete("/jobs/:id", handler.DeleteJob),
		rest.Post("/procs", handler.StartProc),
		rest.Get("/procs/:id", handler.GetProc),
		rest.Delete("/procs/:id", handler.StopProc),
		rest.Get("/jobs/:id/procs", handler.GetProcsByJob),
		rest.Get("/jobs/:id/log", handler.GetProcLogByJob),
	)
	if err != nil {
		log.Fatal(err)
	}
	handler.Api.SetApp(router)
	return &handler
}
Beispiel #10
0
func main() {

	users := Users{
		Store: map[string]*User{},
	}

	books := Books{
		Store: map[string]*Book{},
	}

	api := rest.NewApi()
	api.Use(rest.DefaultDevStack...)
	router, err := rest.MakeRouter(
		// users router
		rest.Get("/users", users.GetAllUsers),
		rest.Post("/users", users.PostUser),
		rest.Get("/users/:id", users.GetUser),
		rest.Put("/users/:id", users.PutUser),
		rest.Delete("/users/:id", users.DeleteUser),

		// user and book router
		rest.Get("/users/:id/books", users.GetUserAllBooks),

		// books router
		rest.Get("/books", books.GetAllBooks),
		rest.Post("/books", books.PostBook),
		rest.Get("/books/:id", books.GetBook),
		rest.Put("/books/:id", books.PutBook),
		rest.Delete("/books/:id", books.DeleteBook),
	)
	if err != nil {
		log.Fatal(err)
	}
	api.SetApp(router)
	log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
}
Beispiel #11
0
func main() {
	api := rest.NewApi()
	api.Use(rest.DefaultDevStack...)
	router, err := rest.MakeRouter(
		rest.Get("/countries", GetAllCountries),
		rest.Post("/countries", PostCountry),
		rest.Get("/countries/:code", GetCountry),
		rest.Delete("/countries/:code", DeleteCountry),
	)
	if err != nil {
		log.Fatal(err)
	}
	api.SetApp(router)
	log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
}
Beispiel #12
0
func main() {
	init_db()

	api := rest.NewApi()
	api.Use(rest.DefaultDevStack...)
	router, err := rest.MakeRouter(
		rest.Get("/os", GetAllOS),
		rest.Post("/os", PostOS),
		rest.Get("/os/:Distribution", GetOS),
		rest.Delete("/os/:Distribution", DeleteOS),
	)
	if err != nil {
		log.Fatal(err)
	}
	api.SetApp(router)
	log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
}
func main() {
	fmt.Println("****** Test for a product ******")
	api := rest.NewApi()
	api.Use(rest.DefaultDevStack...)
	router, err := rest.MakeRouter(
		rest.Get("/products", GetAllProducts),
		rest.Post("/products", PostProduct),
		rest.Get("/products/:id", GetProduct),
		rest.Delete("/products/:id", DeleteProduct),
	)
	if err != nil {
		log.Fatal(err)
	}
	api.SetApp(router)
	log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
	log.Println("Listening on port 8080 -> go to http://localhost:8080")
}
Beispiel #14
0
func main() {

	// Static Files
	fs := http.FileServer(http.Dir("app/dist"))
	http.Handle("/", fs)

	log.Println("Listening...")
	go http.ListenAndServe(":8080", nil)

	// Api
	api := rest.NewApi()
	api.Use(rest.DefaultDevStack...)

	api.Use(&rest.CorsMiddleware{
		RejectNonCorsRequests: false,
		OriginValidator: func(origin string, request *rest.Request) bool {
			return true // origin == "http://127.0.0.1"
		},
		AllowedMethods: []string{"GET", "POST", "PUT", "OPTIONS", "DELETE"},
		AllowedHeaders: []string{
			"Accept", "Content-Type", "Authorization", "Origin"},
		AccessControlAllowCredentials: true,
		AccessControlMaxAge:           3600,
	})
	api.Use(AuthMiddleware())

	router, err := rest.MakeRouter(
		rest.Post("/auth/login", restapi.Login),
		rest.Post("/auth/register", restapi.Register),
		rest.Post("/api/importurl", restapi.ImportUrl),
		rest.Get("/api/documents", restapi.GetAllDocuments),
		rest.Post("/api/documents", restapi.PostDocument),
		rest.Get("/api/documents/:id", restapi.GetDocument),
		rest.Put("/api/documents/:id", restapi.PutDocument),
		rest.Delete("/api/documents/:id", restapi.DeleteDocument),
	)

	if err != nil {
		log.Fatal(err)
	}
	api.SetApp(router)

	log.Printf("Port %s\n", conf.Port)
	log.Fatal(http.ListenAndServe(":"+conf.Port, api.MakeHandler()))
}
Beispiel #15
0
func main() {
	email := rest_email.Email{}

	api := rest.NewApi()
	api.Use(rest.DefaultDevStack...)
	router, err := rest.MakeRouter(
		rest.Get("/", email.GetServiceList),
		rest.Get("/email", email.GetEmailListAndContent),
		rest.Post("/email", email.SendEmailContent),
		rest.Delete("/email", email.DeleteEmail),
	)
	if err != nil {
		log.Fatal(err)
	}
	api.SetApp(router)
	log.Printf("email api server start...")
	log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
}
Beispiel #16
0
func main() {
	api := rest.NewApi()
	api.Use(rest.DefaultDevStack...)
	router, err := rest.MakeRouter(
		rest.Post("/api/v1/images", HandleImageCreate),
		rest.Get("/api/v1/images", HandleImageList),
		rest.Post("/api/v1/instances", HandleInstanceCreate),
		rest.Post("/api/v1/instances/:instanceid", HandleInstanceStart),
		rest.Put("/api/v1/instances/:instanceid", HandleInstanceStop),
		rest.Get("/api/v1/instances", HandleInstanceList),
		rest.Get("/api/v1/instances/:instanceid", HandleInstanceInfo),
		rest.Delete("/api/v1/instances/:instanceid", HandleInstanceDestroy),
	)
	if err != nil {
		log.Fatal(err)
	}
	api.SetApp(router)
	log.Fatal(http.ListenAndServe(listen, api.MakeHandler()))
}
Beispiel #17
0
func main() {

	i := Impl{}
	i.InitDB()
	i.InitSchema()

	api := rest.NewApi()
	api.Use(rest.DefaultDevStack...)
	router, err := rest.MakeRouter(
		rest.Get("/reminders", i.GetAllReminders),
		rest.Post("/reminders", i.PostReminder),
		rest.Get("/reminders/:id", i.GetReminder),
		rest.Put("/reminders/:id", i.PutReminder),
		rest.Delete("/reminders/:id", i.DeleteReminder),
	)
	if err != nil {
		log.Fatal(err)
	}
	api.SetApp(router)
	log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
}
Beispiel #18
0
// NewRouter return the configured routes for this API
func NewRouter(jwtmiddleware *jwt.JWTMiddleware, session *r.Session) rest.App {

	trips := models.Trips{
		Conn: session,
	}

	router, err := rest.MakeRouter(
		rest.Post("/login", jwtmiddleware.LoginHandler),
		rest.Get("/refresh_token", jwtmiddleware.RefreshHandler),
		rest.Get("/trips", trips.GetAllTrips),
		rest.Get("/trips/:id", trips.GetTrip),
		rest.Post("/trips", trips.PostTrip),
		rest.Patch("/trips/:id/updatePlaces", trips.UpdateTripPlaces),
		rest.Delete("/trips/:id/deletePlace/:place", trips.DeleteTripPlaces),
	)
	if err != nil {
		log.Fatal(err)
	}

	return router
}
Beispiel #19
0
func main() {
	api := rest.NewApi()
	api.Use(rest.DefaultDevStack...)
	router, err := rest.MakeRouter(

		// TODO http://docs.aws.amazon.com/AWSEC2/latest/APIReference/OperationList-query.html

		rest.Post("/api/v1/images", ImageCreate),
		rest.Get("/api/v1/images", ImageList),

		rest.Post("/api/v1/instances", InstanceCreate),
		rest.Post("/api/v1/instances/:instanceid", InstanceStart),
		rest.Put("/api/v1/instances/:instanceid", InstanceStop),
		rest.Get("/api/v1/instances", InstanceList),
		rest.Delete("/api/v1/instances/:instanceid", InstanceDestroy),
	)
	if err != nil {
		log.Fatal(err)
	}
	api.SetApp(router)
	log.Fatal(http.ListenAndServe(listen, api.MakeHandler()))
}
func init() {

	db, err := sql.Open("sqlite3", ":memory:")

	if err != nil {
		log.Fatal("An error '%s' was not expected when opening a stub database connection", err)
	} else {

		dat, err := ioutil.ReadFile("./../test.sql")
		if err != nil {
			log.Fatal("An error '%s' was not expected when opening sql file", err)
		} else {
			db.Exec(string(dat))
		}
	}

	api := rest.NewApi()
	api.Use(rest.DefaultDevStack...)

	entityManager := eram.NewEntityDbManager(db)
	entityRestApi := NewEntityRestAPI(entityManager)

	router, err := rest.MakeRouter(
		rest.Get("/api/:entity", entityRestApi.GetAllEntities),
		rest.Post("/api/:entity", entityRestApi.PostEntity),
		rest.Get("/api/:entity/:id", entityRestApi.GetEntity),
		rest.Put("/api/:entity/:id", entityRestApi.PutEntity),
		rest.Delete("/api/:entity/:id", entityRestApi.DeleteEntity),
	)

	if err != nil {
		log.Fatal("An error '%s' was not expected when creating the router", err)
	}

	api.SetApp(router)
	handler = api.MakeHandler()

	server = httptest.NewServer(handler)
}
Beispiel #21
0
func main() {
	// db, err := gorm.Open("postgres", "user=gorm dbname=gorm sslmode=disable")
	// db, err := gorm.Open("foundation", "dbname=gorm") // FoundationDB.
	// db, err := gorm.Open("mysql", "user:password@/dbname?charset=utf8&parseTime=True&loc=Local")
	db, err := gorm.Open("sqlite3", "../overlay.db")
	if err != nil {
		fmt.Println(err)
	}
	// You can also use an existing database connection handle
	// dbSql, _ := sql.Open("postgres", "user=gorm dbname=gorm sslmode=disable")
	// db, _ := gorm.Open("postgres", dbSql)

	// Get database connection handle [*sql.DB](http://golang.org/pkg/database/sql/#DB)
	db.DB()
	// Then you could invoke `*sql.DB`'s functions with it
	db.DB().Ping()
	db.DB().SetMaxIdleConns(10)
	db.DB().SetMaxOpenConns(100)
	// Disable table name's pluralization
	db.SingularTable(true)

	// Create table (won't recreate if it exists)
	db.CreateTable(&Overlay{})

	// Drop table
	//	db.DropTable(&User{})

	// Automating Migration
	db.AutoMigrate(&Overlay{})
	//	db.AutoMigrate(&User{}, &Product{}, &Order{})
	// Feel free to change your struct, AutoMigrate will keep your database up-to-date.
	// AutoMigrate will ONLY add *new columns* and *new indexes*,
	// WON'T update current column's type or delete unused columns, to protect your data.
	// If the table is not existing, AutoMigrate will create the table automatically.
	// o should be a pointer to an overlay struct
	//	o := Overlay{
	//		KeyId:        "lg_dev/PER01/00043",
	//		VendorMode:   "lg_dev",
	//		Type:         "p",
	//		Description:  "",
	//		Grp:          "PER01",
	//		EId:          "00041",
	//		AppID:        "NBC",
	//		AlertPicUrl:  "http://testurl.google.com",
	//		Freshness:    86400,
	//		NaggingEvent: 1,
	//		DateEntered:  time.Now(),
	//		ExpireDate:   time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC),
	//		CreateUser:   "******",
	//		ContentId:    "TEST-001-SE09-EP11",
	//		Series:       "Big Bang Theory",
	//		Season:       9,
	//		Episode:      11,
	//		Channel:      "WFOX",
	//		Vendor:       "LG",
	//	}

	i := Impl{}
	i.InitDB()
	i.InitSchema()

	api := rest.NewApi()
	api.Use(rest.DefaultDevStack...)
	router, err := rest.MakeRouter(
		rest.Get("/overlays", i.GetAllOverlays),
		rest.Post("/overlays", i.PostOverlay),
		rest.Get("/overlays/:id", i.GetOverlay),
		rest.Put("/overlays/:id", i.PutOverlay),
		rest.Delete("/overlays/:id", i.DeleteOverlay),
	)
	if err != nil {
		log.Fatal(err)
	}
	api.SetApp(router)
	log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
}
Beispiel #22
0
// New creates a new instance of the Rest API.
func New(s *store.Store, adminPassword string) (*rest.Api, error) {
	db := s.DB()
	models.NewBase(db).EnsureIndex()
	db.Session.Close()

	api := rest.NewApi()
	api.Use(rest.DefaultDevStack...)
	api.Use(&BaseMiddleware{
		Store: s,
	})
	api.Use(&rest.JsonpMiddleware{
		CallbackNameKey: "cb",
	})
	api.Use(&rest.CorsMiddleware{
		RejectNonCorsRequests: false,
		OriginValidator: func(origin string, request *rest.Request) bool {
			return true
		},
		AllowedMethods:                []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
		AllowedHeaders:                []string{"Accept", "Content-Type", "Origin", "Authorization"},
		AccessControlAllowCredentials: true,
		AccessControlMaxAge:           3600,
	})
	authBasic := &AuthBasicMiddleware{
		Realm:         "Hooky",
		Authenticator: authenticate(adminPassword),
		Authorizator:  authorize(adminPassword),
	}
	api.Use(&rest.IfMiddleware{
		Condition: func(r *rest.Request) bool {
			return r.URL.Path != "/status"
		},
		IfTrue: authBasic,
	})
	router, err := rest.MakeRouter(
		rest.Get("/authenticate", Authenticate),
		rest.Post("/accounts", PostAccount),
		rest.Get("/accounts", GetAccounts),
		rest.Get("/accounts/:account", GetAccount),
		rest.Patch("/accounts/:account", PatchAccount),
		rest.Delete("/accounts/:account", DeleteAccount),
		rest.Delete("/accounts/:account/applications", DeleteApplications),
		rest.Get("/accounts/:account/applications", GetApplications),
		rest.Get("/accounts/:account/applications/:application", GetApplication),
		rest.Put("/accounts/:account/applications/:application", PutApplication),
		rest.Delete("/accounts/:account/applications/:application", DeleteApplication),
		rest.Get("/accounts/:account/applications/:application/queues", GetQueues),
		rest.Put("/accounts/:account/applications/:application/queues/:queue", PutQueue),
		rest.Delete("/accounts/:account/applications/:application/queues/:queue", DeleteQueue),
		rest.Get("/accounts/:account/applications/:application/queues/:queue", GetQueue),
		rest.Delete("/accounts/:account/applications/:application/queues", DeleteQueues),
		rest.Post("/accounts/:account/applications/:application/tasks", PutTask),
		rest.Get("/accounts/:account/applications/:application/tasks", GetTasks),
		rest.Delete("/accounts/:account/applications/:application/tasks", DeleteTasks),
		rest.Put("/accounts/:account/applications/:application/tasks/:task", PutTask),
		rest.Get("/accounts/:account/applications/:application/tasks/:task", GetTask),
		rest.Delete("/accounts/:account/applications/:application/tasks/:task", DeleteTask),
		rest.Post("/accounts/:account/applications/:application/tasks/:task/attempts", PostAttempt),
		rest.Get("/accounts/:account/applications/:application/tasks/:task/attempts", GetAttempts),
		rest.Get("/status", GetStatus),
	)
	if err != nil {
		return nil, err
	}
	api.SetApp(router)

	return api, nil
}
Beispiel #23
0
func main() {
	var port string
	flag.StringVar(&port, "port", "9999", "port to listen")
	flag.Parse()

	log.Println("Starting server on localhost:" + port)

	countries := Countries{
		Store: map[string]*Country{},
	}

	// JSON Web Tokens middleware
	jwtMW := &jwt.JWTMiddleware{
		Key:        []byte("secret key"),
		Realm:      "jwt auth",
		Timeout:    time.Hour,
		MaxRefresh: time.Hour * 24,
		Authenticator: func(userid string, passwd string) bool {
			return userid == userID && passwd == password
		},
	}

	api := rest.NewApi()
	statusMW := &rest.StatusMiddleware{}
	// StatusMiddleware must be registered in api.Use() BEFORE rest.DefaultDevStack
	// because of an implicit dependency on RecorderMiddleware (request.ENV["STATUS_CODE"])
	// and reverse call order of Middleware#MiddlewareFunc().
	api.Use(statusMW)
	api.Use(rest.DefaultDevStack...)
	// we use the IfMiddleware to remove certain paths from needing authentication
	//api.Use(&rest.IfMiddleware{
	//	Condition: func(r *rest.Request) bool {
	//		return r.URL.Path != "/login"
	//	},
	//	IfTrue: jwtMW,
	//})

	router, err := rest.MakeRouter(
		rest.Get("/", func(w rest.ResponseWriter, r *rest.Request) {
			if e := w.WriteJson(map[string]string{"Body": "Hello, World!"}); e != nil {
				log.Println(e)
			}
		}),

		rest.Get("/lookup/#host", func(w rest.ResponseWriter, r *rest.Request) {
			ip, e := net.LookupIP(r.PathParam("host"))
			if e != nil {
				rest.Error(w, e.Error(), http.StatusInternalServerError)
				return
			}
			if e := w.WriteJson(&ip); e != nil {
				log.Println(e)
			}
		}),

		rest.Get("/countries", countries.GetAllCountries),
		rest.Post("/countries", countries.PostCountry),
		rest.Get("/countries/:code", countries.GetCountry),
		rest.Delete("/countries/:code", countries.DeleteCountry),

		rest.Get("/stats", func(w rest.ResponseWriter, r *rest.Request) {
			returnJSON(w, statusMW.GetStatus())
		}),

		rest.Post("/login", jwtMW.LoginHandler),
		rest.Get("/auth_test", handleAuth),
		rest.Get("/refresh_token", jwtMW.RefreshHandler),

		rest.Get("/stream", StreamThings),
	)
	if err != nil {
		log.Fatal(err)
	}

	http.Handle("/api/", http.StripPrefix("/api", api.MakeHandler()))
	http.Handle("/static/", http.StripPrefix("/static", http.FileServer(http.Dir("."))))

	api.SetApp(router)

	log.Fatal(http.ListenAndServe(":"+port, api.MakeHandler()))
}
Beispiel #24
0
func main() {

	flag.Parse()

	p, err := osext.ExecutableFolder()
	if err != nil {
		log.Fatal(err)
	}

	dbconf, err := load(path.Join(p, "db", "config.json"), *flagEnv)
	if err != nil {
		log.Fatal(err)
	}

	// db, err := sql.Open(dbconf.Driver, dbconf.Source)
	db, err := hood.Open(dbconf.Driver, dbconf.Source)
	if err != nil {
		log.Fatal(err)
	}

	// svmw := semVerMiddleware{
	// 	MinVersion: "1.0.0",
	// 	MaxVersion: "1.0.0",
	// }
	serviceApi := api.Api{Db: db}
	rapi := rest.NewApi()
	rapi.Use(rest.DefaultDevStack...)
	router, err := rest.MakeRouter(

		rest.Get("/tags", serviceApi.GetAllTags),
		rest.Post("/tags", serviceApi.PostTag),
		rest.Get("/tags/:name", serviceApi.GetTag),
		rest.Post("/tags/:name", serviceApi.UpdateTag),
		rest.Delete("/tags/:name", serviceApi.DeleteTag),

		rest.Get("/contacts", serviceApi.GetAllContacts),
		rest.Post("/contacts", serviceApi.PostContact),
		rest.Get("/contacts/:name", serviceApi.GetContact),
		rest.Post("/contacts/:name", serviceApi.UpdateContact),
		rest.Delete("/contacts/:name", serviceApi.DeleteContact),

		// rest.Get("/#version/message", svmw.MiddlewareFunc(
		// 	func(w rest.ResponseWriter, req *rest.Request) {
		// 		version := req.Env["VERSION"].(*semver.Version)
		// 		if version.Major == 2 {
		// 			// http://en.wikipedia.org/wiki/Second-system_effect
		// 			w.WriteJson(map[string]string{
		// 				"Body": "Hello broken World!",
		// 			})
		// 		} else {
		// 			w.WriteJson(map[string]string{
		// 				"Body": "Hello World!",
		// 			})
		// 		}
		// 	},
		// )),
	)
	if err != nil {
		log.Fatal(err)
	}
	rapi.SetApp(router)
	http.Handle("/api/", http.StripPrefix("/api", rapi.MakeHandler()))

	log.Println("Started")
	log.Fatal(http.ListenAndServe(":8080", nil))
}
Beispiel #25
0
// MakeHandler constructs and returns an HTTP handler for the API. Returns an
// error if unsuccessful.
func MakeHandler() (http.Handler, error) {
	api := rest.NewApi()
	api.Use(rest.DefaultDevStack...)
	router, err := rest.MakeRouter(
		// Auth
		rest.Get("/auth/#provider", BeginAuth),
		rest.Get("/auth/#provider/callback", CallbackAuth),
		rest.Post("/logout", Logout),

		// Channels
		rest.Get("/channels", GetChannels),
		rest.Get("/channels/#channelname", GetChannel),
		// rest.Put("/channels/#channelname", SetChannel),
		rest.Post("/channels", AddChannel),
		rest.Delete("/channels/#channelname", RemoveChannel),

		// Moderators
		rest.Get("/channels/#channelname/moderators", GetModerators),
		rest.Post("/channels/#channelname/moderators", AddModerator),
		rest.Delete("/channels/#channelname/moderators/#userID", RemoveModerator),

		// Viewers
		rest.Get("/channels/#channelname/viewers", GetViewers),
		rest.Post("/channels/#channelname/viewers", AddViewer),
		rest.Delete("/channels/#channelname/viewers/#userID", RemoveViewer),

		// Banned
		rest.Get("/channels/#channelname/bans", GetBans),
		rest.Post("/channels/#channelname/bans", AddBan),
		rest.Delete("/channels/#channelname/bans/#userID", RemoveBan),

		// Posts
		rest.Get("/posts", GetPosts),
		rest.Get("/posts/#pid", GetPost),
		// rest.Put("/posts/#pid", SetPost),
		rest.Post("/posts", AddPost),
		rest.Delete("/posts/#pid", RemovePost),

		// Comments
		rest.Get("/posts/#pid/comments", GetComments),
		// rest.Put("/posts/#pid/comments/#cid", SetComment),
		rest.Post("/posts/#pid/comments", AddComment),
		rest.Delete("/posts/#pid/comments/#cid", RemoveComment),

		// Users
		rest.Get("/users", GetUsers),
		rest.Get("/users/#userID", GetUser),
		rest.Post("/users/#userID", AddUser),
		rest.Delete("/users/#userID", RemoveUser),

		// Subscriptions
		rest.Get("/users/#userID/subscriptions", GetSubscriptions),
		rest.Post("/users/#userID/subscriptions", AddSubscription),
		rest.Delete("/users/#userID/subscriptions/#channelname", RemoveSubscription),

		// Favorites
		rest.Get("/users/#userID/favorites", GetFavorites),
		rest.Post("/users/#userID/favorites", AddFavorite),
		rest.Delete("/users/#userID/favorites/#postID", RemoveFavorite),
	)
	if err != nil {
		return nil, err
	}
	api.SetApp(router)
	return api.MakeHandler(), nil
}
Beispiel #26
0
func NewWebApi() http.Handler {
	Authenticator := func(userId, password string) bool {

		res, err := userRepository.GetUserById(userId)
		if err != nil || res == "" {
			return false
		}
		user := domain.NewUser()
		err = json.Unmarshal([]byte(res), user)

		return nil == err && user.Pass == domain.HashPassword(password)
	}

	var jwt_middleware = &jwt.JWTMiddleware{
		Key:           []byte("testKey"),
		Realm:         "Unitrans",
		Timeout:       time.Hour * 30,
		MaxRefresh:    time.Hour * 24,
		Authenticator: Authenticator,
	}

	var DevStack = []rest.Middleware{
		&rest.AccessLogApacheMiddleware{},
		&rest.TimerMiddleware{},
		&rest.RecorderMiddleware{},
		&rest.PoweredByMiddleware{
			XPoweredBy: "unitrans",
		},
		&rest.RecoverMiddleware{
			EnableResponseStackTrace: true,
		},
		&rest.JsonIndentMiddleware{},
	}
	api := rest.NewApi()

	api.Use(DevStack...)
	api.Use(&rest.CorsMiddleware{
		RejectNonCorsRequests: false,
		OriginValidator: func(origin string, request *rest.Request) bool {
			return true
		},
		AllowedMethods:                []string{"GET", "POST", "PUT", "DELETE"},
		AllowedHeaders:                []string{"Authorization", "Accept", "Content-Type", "X-Custom-Header", "Origin"},
		AccessControlAllowCredentials: true,
		AccessControlMaxAge:           3600,
	})
	api.Use(&rest.IfMiddleware{
		Condition: func(request *rest.Request) bool {
			return request.URL.Path != "/login" && request.URL.Path != "/refresh" && request.URL.Path != "/register" && request.URL.Path != "/checkExists" && request.URL.Path != "/tr"
		},
		IfTrue: jwt_middleware,
	})
	api.Use(&rest.IfMiddleware{
		Condition: func(r *rest.Request) bool {
			_, ok := r.Env["REMOTE_USER"]
			return ok
		},
		IfTrue: &UserMiddleware{},
	})
	api_router, _ := rest.MakeRouter(
		rest.Post("/login", jwt_middleware.LoginHandler),
		rest.Get("/test", handle_auth),
		rest.Get("/refresh", jwt_middleware.RefreshHandler),
		rest.Post("/register", Register),
		rest.Post("/checkExists", CheckExists),

		rest.Get("/keys", KeysList),
		rest.Post("/keys", KeyCreate),
		rest.Delete("/keys/*key", KeyDelete),

		rest.Post("/tr", Translate),
	)
	api.SetApp(api_router)
	return api.MakeHandler()
}
Beispiel #27
0
func TestContactApi(t *testing.T) {

	// db, err := sql.Open(dbconf.Driver, dbconf.Source)
	db, err := hood.Open("postgres", "user=postgres dbname=indata_test host=192.168.0.10 sslmode=disable")
	if err != nil {
		log.Fatal(err)
	}

	serviceApi := api.Api{Db: db}
	rapi := rest.NewApi()
	rapi.Use(rest.DefaultDevStack...)
	router, err := rest.MakeRouter(
		rest.Get("/contacts", serviceApi.GetAllContacts),
		rest.Post("/contacts", serviceApi.PostContact),
		rest.Get("/contacts/:name", serviceApi.GetContact),
		rest.Post("/contacts/:name", serviceApi.UpdateContact),
		rest.Delete("/contacts/:name", serviceApi.DeleteContact),
	)
	if err != nil {
		log.Fatal(err)
	}
	rapi.SetApp(router)

	// Start a transaction
	tx := db.Begin()

	tx.DropTableIfExists(api.Tag{})
	tx.DropTableIfExists(api.Contact{})
	tx.DropTableIfExists(api.TagContact{})

	tx.CreateTableIfNotExists(api.Tag{})
	tx.CreateTableIfNotExists(api.Contact{})
	tx.CreateTableIfNotExists(api.TagContact{})

	// Commit changes
	err = tx.Commit()
	if err != nil {
		log.Println(err)
	}

	handler := http.StripPrefix("/api", rapi.MakeHandler())

	recorded := test.RunRequest(t, handler, test.MakeSimpleRequest("GET", "http://localhost/api/contacts", nil))
	recorded.CodeIs(200)
	recorded.ContentTypeIsJson()
	// recorded.ContentEncodingIsGzip()
	recorded.BodyIs(`[]`)

	recorded = test.RunRequest(t, handler, test.MakeSimpleRequest("POST", "http://localhost/api/contacts",
		&map[string]string{
			"name":        "a",
			"title":       "a",
			"description": "a",
		}))
	recorded.CodeIs(200)
	recorded.ContentTypeIsJson()
	// recorded.ContentEncodingIsGzip()

	recorded = test.RunRequest(t, handler, test.MakeSimpleRequest("GET", "http://localhost/api/contacts", nil))
	recorded.CodeIs(200)
	recorded.ContentTypeIsJson()
	// recorded.ContentEncodingIsGzip()

	var contacts []api.Contact
	err = recorded.DecodeJsonPayload(&contacts)

	if len(contacts) != 1 {
		t.Errorf(`Expected one element and got %d`, len(contacts))
	}

	if contacts[0].Name != "a" {
		t.Error(`Expected contact name "a"`)
	}

	spew.Dump(contacts)
	recorded = test.RunRequest(t, handler, test.MakeSimpleRequest("DELETE", "http://localhost/api/contacts/"+contacts[0].Name, nil))
	recorded.CodeIs(200)
	recorded.ContentTypeIsJson()

	recorded = test.RunRequest(t, handler, test.MakeSimpleRequest("GET", "http://localhost/api/contacts", nil))
	recorded.CodeIs(200)
	recorded.ContentTypeIsJson()
	// recorded.ContentEncodingIsGzip()
	recorded.BodyIs(`[]`)
}
Beispiel #28
0
// New creates a new instance of the Rest API.
func New(s *store.Store, adminPassword string, logStyle string) (*rest.Api, error) {
	api := rest.NewApi()
	if logStyle == "json" {
		api.Use(&rest.AccessLogJsonMiddleware{})
	} else if strings.HasPrefix(logStyle, "apache-") {
		mw := &rest.AccessLogApacheMiddleware{}
		mw.Format = rest.DefaultLogFormat
		if logStyle == "apache-common" {
			mw.Format = rest.CommonLogFormat
		} else if logStyle == "apache-combined" {
			mw.Format = rest.CombinedLogFormat
		}
		api.Use(mw)
	}
	api.Use(rest.DefaultCommonStack...)
	api.Use(&BaseMiddleware{
		Store: s,
	})
	api.Use(&rest.JsonpMiddleware{
		CallbackNameKey: "cb",
	})
	api.Use(&rest.CorsMiddleware{
		RejectNonCorsRequests: false,
		OriginValidator: func(origin string, request *rest.Request) bool {
			return true
		},
		AllowedMethods:                []string{"GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"},
		AllowedHeaders:                []string{"Accept", "Content-Type", "Origin", "Authorization"},
		AccessControlAllowCredentials: true,
		AccessControlMaxAge:           3600,
	})
	authBasic := &AuthBasicMiddleware{
		Realm:         "Hooky",
		Authenticator: authenticate(adminPassword),
		Authorizator:  authorize(adminPassword),
	}
	api.Use(&rest.IfMiddleware{
		Condition: func(r *rest.Request) bool {
			return r.URL.Path != "/status"
		},
		IfTrue: authBasic,
	})
	router, err := rest.MakeRouter(
		rest.Get("/authenticate", Authenticate),
		rest.Post("/accounts", PostAccount),
		rest.Get("/accounts", GetAccounts),
		rest.Get("/accounts/:account", GetAccount),
		rest.Patch("/accounts/:account", PatchAccount),
		rest.Delete("/accounts/:account", DeleteAccount),
		rest.Delete("/accounts/:account/applications", DeleteApplications),
		rest.Get("/accounts/:account/applications", GetApplications),
		rest.Get("/accounts/:account/applications/:application", GetApplication),
		rest.Put("/accounts/:account/applications/:application", PutApplication),
		rest.Delete("/accounts/:account/applications/:application", DeleteApplication),
		rest.Get("/accounts/:account/applications/:application/queues", GetQueues),
		rest.Put("/accounts/:account/applications/:application/queues/:queue", PutQueue),
		rest.Delete("/accounts/:account/applications/:application/queues/:queue", DeleteQueue),
		rest.Get("/accounts/:account/applications/:application/queues/:queue", GetQueue),
		rest.Delete("/accounts/:account/applications/:application/queues", DeleteQueues),
		rest.Post("/accounts/:account/applications/:application/tasks", PutTask),
		rest.Get("/accounts/:account/applications/:application/tasks", GetTasks),
		rest.Delete("/accounts/:account/applications/:application/tasks", DeleteTasks),
		rest.Put("/accounts/:account/applications/:application/tasks/:task", PutTask),
		rest.Get("/accounts/:account/applications/:application/tasks/:task", GetTask),
		rest.Delete("/accounts/:account/applications/:application/tasks/:task", DeleteTask),
		rest.Post("/accounts/:account/applications/:application/tasks/:task/attempts", PostAttempt),
		rest.Get("/accounts/:account/applications/:application/tasks/:task/attempts", GetAttempts),
		rest.Get("/accounts/:account/applications/:application/tasks/:task/attempts/:attempt", GetAttempt),
		rest.Get("/status", GetStatus),
	)
	if err != nil {
		return nil, err
	}
	api.SetApp(router)

	return api, nil
}
Beispiel #29
0
func TestTagApi(t *testing.T) {

	tests := []TestTagStruct{
		{
			First: &TestTag{
				Request: "GET",
				Url:     "http://localhost/api/tags",
				Status:  200,
				Body:    `[]`,
			},
		},
		{
			First: &TestTag{
				Request: "POST",
				Url:     "http://localhost/api/tags",
				Input: &map[string]string{
					"name": "a",
				},
				Status: 200,
			},
			Last: &TestTag{
				Request: "GET",
				Url:     "http://localhost/api/tags",
				Input:   nil,
				Status:  200,
				Result: &api.Tag{
					Name:   "a",
					Weight: 20,
				},
			},
		},
	}

	// db, err := sql.Open(dbconf.Driver, dbconf.Source)
	db, err := hood.Open("postgres", "user=postgres dbname=indata_test host=192.168.0.10 sslmode=disable")
	if err != nil {
		log.Fatal(err)
	}

	serviceApi := api.Api{Db: db}
	rapi := rest.NewApi()
	rapi.Use(rest.DefaultCommonStack...)
	// rapi.Use(&rest.AccessLogApacheMiddleware{})
	// rapi.Use(&rest.GzipMiddleware{})
	rapi.Use(&rest.ContentTypeCheckerMiddleware{})

	router, err := rest.MakeRouter(
		rest.Get("/tags", serviceApi.GetAllTags),
		rest.Post("/tags", serviceApi.PostTag),
		rest.Get("/tags/:name", serviceApi.GetTag),
		rest.Post("/tags/:name", serviceApi.UpdateTag),
		rest.Delete("/tags/:name", serviceApi.DeleteTag),
	)
	if err != nil {
		log.Fatal(err)
	}
	rapi.SetApp(router)

	for _, testVars := range tests {
		// Start a transaction
		tx := db.Begin()

		tx.DropTableIfExists(api.Tag{})
		tx.DropTableIfExists(api.Contact{})
		tx.DropTableIfExists(api.TagContact{})

		tx.CreateTableIfNotExists(api.Tag{})
		tx.CreateTableIfNotExists(api.Contact{})
		tx.CreateTableIfNotExists(api.TagContact{})

		// Commit changes
		err = tx.Commit()
		if err != nil {
			log.Println(err)
		}
		hndl := rapi.MakeHandler()
		handler := http.StripPrefix("/api", hndl)

		// recorded := test.RunRequest(t, handler, test.MakeSimpleRequest("GET", "http://localhost/api/tags/notfound", nil))
		// recorded.CodeIs(404)
		// recorded.ContentTypeIsJson()
		// recorded.BodyIs("{\n  \"Error\": \"Resource not found\"\n}")

		// recorded = test.RunRequest(t, &handler, test.MakeSimpleRequest("GET", "http://1.2.3.4/user-notfound", nil))
		// recorded.CodeIs(404)
		// recorded.ContentTypeIsJson()
		// recorded.BodyIs(`{"Error":"Resource not found"}`)

		log.Printf("%s request to %s ", testVars.First.Request, testVars.First.Url)
		recorded := test.RunRequest(t, handler, test.MakeSimpleRequest(testVars.First.Request, testVars.First.Url, testVars.First.Input))
		recorded.CodeIs(testVars.First.Status)
		recorded.ContentTypeIsJson()
		// recorded.ContentEncodingIsGzip()
		log.Printf("body %#v", recorded.Recorder.Body.String())
		if testVars.First.Body != "" {
			recorded.BodyIs(testVars.First.Body)
		}

		if testVars.Last != nil {
			log.Printf("%s request to %s ", testVars.Last.Request, testVars.Last.Url)

			recorded := test.RunRequest(t, handler, test.MakeSimpleRequest(testVars.Last.Request, testVars.Last.Url, testVars.Last.Input))
			recorded.CodeIs(testVars.Last.Status)
			recorded.ContentTypeIsJson()
			// recorded.ContentEncodingIsGzip()

			if testVars.Last.Result != nil {
				var tags []api.Tag
				err = recorded.DecodeJsonPayload(&tags)

				log.Printf("tags %#v", tags)
				if len(tags) != 1 {
					t.Errorf(`Expected one element and got %d`, len(tags))
				}

				if testVars.Last.Result.Name != "" {
					if tags[0].Name != testVars.Last.Result.Name {
						t.Errorf(`Expected tag name "%s"`, testVars.Last.Result.Name)
					}
				}

				// if ok := testVars.Last.Result.Weight; ok {
				// if testVars.Last.Result.Weight {
				if tags[0].Weight != testVars.Last.Result.Weight {
					t.Errorf(`Expected tag weight "%s"`, testVars.Last.Result.Weight)
				}
				// }
				// }
			}
		}

	}
	//
	// recorded = test.RunRequest(t, handler, test.MakeSimpleRequest("GET", "http://localhost/api/tags", nil))
	// recorded.CodeIs(200)
	// recorded.ContentTypeIsJson()
	// // recorded.ContentEncodingIsGzip()
	//
	// var tags []api.Tag
	// err = recorded.DecodeJsonPayload(&tags)
	//
	// if len(tags) != 1 {
	// 	t.Errorf(`Expected one element and got %d`, len(tags))
	// }
	//
	// if tags[0].Name != "a" {
	// 	t.Error(`Expected tag name "a"`)
	// }
	//
	// recorded = test.RunRequest(t, handler, test.MakeSimpleRequest("DELETE", "http://localhost/api/tags/"+tags[0].Name, nil))
	// recorded.CodeIs(200)
	// recorded.ContentTypeIsJson()
	//
	// recorded = test.RunRequest(t, handler, test.MakeSimpleRequest("GET", "http://localhost/api/tags", nil))
	// recorded.CodeIs(200)
	// recorded.ContentTypeIsJson()
	// // recorded.ContentEncodingIsGzip()
	// recorded.BodyIs(`[]`)
}