Esempio n. 1
0
func main() {
	bind_addr := flag.String("bind_ip", "127.0.0.1", "bind ip address")
	http_port := flag.Int("http_port", 9999, "listen http port")
	rpc_port := flag.Int("rpc_port", 9998, "listen rpc port")
	flag.Parse()

	go func() {
		addr, _ := net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", *bind_addr, *rpc_port))
		listener, _ := net.ListenTCP("tcp", addr)
		rpcservice := new(RPCService)
		rpc.Register(rpcservice)
		rpc.HandleHTTP()
		for {
			conn, _ := listener.Accept()
			go rpc.ServeCodec(jsonrpc.NewServerCodec(conn))
		}
	}()

	web.Get("/api/topics/([a-zA-Z0-9_\\-]+)/subscribers/([a-zA-Z0-9_\\-]+)/messages", APIGetTopicMessages)
	web.Post("/api/topics/([a-zA-Z0-9_\\-]+)/subscribers/([a-zA-Z0-9_\\-]+)/messages", APIPostTopicMessage)
	web.Get("/api/topics/([a-zA-Z0-9_\\-]+)", APIGetTopic)
	web.Post("/api/topics/([a-zA-Z0-9_\\-]+)", APIUpdateTopic)
	//web.Get("/api/topics", APIGetTopics)
	web.Get("/api/subscribers/([a-zA-Z0-9_\\-]+)", APIGetSubscriber)
	web.Post("/api/subscribers/([a-zA-Z0-9_\\-]+)", APIUpdateSubscriber)
	//web.Get("/api/topics/(.+)/subscribers/(.+)", APIGetTopicSubscriber)
	//web.Get("/api/topics/(.+)/subscribers", APIGetTopicSubscribers)

	web.Run(fmt.Sprintf("%s:%d", *bind_addr, *http_port))

}
Esempio n. 2
0
func main() {
	viewInit()
	web.Config.CookieSecret = "UXVpZXJvIGEgbWkgcGVxdWXxbyBoaWpvIE1hcmNvcw=="

	// Init API library
	jailgo.EntryInit()
	jailgo.ArtInit()
	jailgo.LoginInit()

	// Principal, comment and search pages
	web.Get("/", showblog)
	web.Get("/comment(.*)", entry)
	web.Get("/search", search)

	// Editing articles and comments
	web.Post("/updateArt", updateArt)
	web.Post("/updateEntry", updateEntry)

	// Login and Administration
	web.Post("/login", login)
	web.Get("/admin", admin)

	// Web server
	web.Run("0.0.0.0:9085")
}
Esempio n. 3
0
File: main.go Progetto: vmx/showfast
func main() {
	pckg_dir = os.Getenv("GOPATH") + "/src/github.com/couchbaselabs/showfast/"
	web.Config.StaticDir = pckg_dir + "app"

	config_file, err := ioutil.ReadFile(pckg_dir + "config.json")
	if err != nil {
		log.Fatal(err)
	}

	var config Config
	err = json.Unmarshal(config_file, &config)
	if err != nil {
		log.Fatal(err)
	}

	data_source = DataSource{config.CouchbaseAddress, config.BucketPassword}

	web.Get("/", home)
	web.Get("/admin", admin)
	web.Get("/release", release)
	web.Get("/feed", feed)

	web.Get("/all_metrics", data_source.GetAllMetrics)
	web.Get("/all_clusters", data_source.GetAllClusters)
	web.Get("/all_timelines", data_source.GetAllTimelines)
	web.Get("/all_benchmarks", data_source.GetAllBenchmarks)
	web.Get("/all_runs", all_runs)
	web.Get("/all_releases", data_source.GetAllReleases)
	web.Get("/all_feed_records", data_source.GetAllFeedRecords)
	web.Get("/get_comparison", get_comparison)
	web.Post("/delete", delete)
	web.Post("/reverse_obsolete", reverse_obsolete)

	web.Run(config.ListenAddress)
}
Esempio n. 4
0
// Site is ie. "archlinux.no" and used for sending confirmation emails
func (ue *UserEngine) ServePages(site string) {
	state := ue.state
	web.Post("/register/(.*)", GenerateRegisterUser(state, site))
	web.Post("/register", GenerateNoJavascriptMessage())
	web.Post("/login/(.*)", GenerateLoginUser(state))
	web.Post("/login", GenerateNoJavascriptMessage())
	web.Get("/logout", GenerateLogoutCurrentUser(state))
	web.Get("/confirm/(.*)", GenerateConfirmUser(state))
}
Esempio n. 5
0
File: server.go Progetto: nfleet/via
func main() {
	parse_flags()

	var config ViaConfig
	var configFile string

	args := flag.Args()
	if len(args) < 1 {
		configFile = "production.json"
	} else {
		configFile = args[0]
	}

	log.Print("loading config from " + configFile + "... ")
	config, err := LoadConfig(configFile)
	if err != nil {
		log.Printf("failed: %s\n", configFile, err.Error())
		return
	}

	// Handle SIGINT and SIGKILL
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt, os.Kill, syscall.SIGABRT)
	go func() {
		for sig := range c {
			log.Printf("received %v, exiting...", sig)
			os.Exit(1)
		}
	}()

	procs := runtime.NumCPU()
	runtime.GOMAXPROCS(procs)

	log.Printf("starting server, running on %d cores...", procs)

	via := NewVia(Debug, expiry, config.DataDir)
	server := Server{Via: via, Host: config.Host, Port: config.Port, AllowedCountries: config.AllowedCountries}

	// Basic
	web.Get("/", Splash)
	web.Get("/status", server.GetServerStatus)

	// Dmatrix
	web.Post("/matrix/", server.PostMatrix)

	// Path
	web.Post("/paths", server.PostPaths)

	web.Match("OPTIONS", "/(.*)", Options)

	go func() {
		log.Println(http.ListenAndServe("localhost:6060", nil))
	}()

	web.Run(fmt.Sprintf("%s:%d", config.Host, config.Port))
}
Esempio n. 6
0
func (srv *Server) Serve() {
	web.Get("/job/list", jobList)
	web.Get("/task/list", taskList)
	web.Get("/job/(.*)", jobGet)
	web.Post("/job", jobNew)
	web.Post("/job/run/(.*)", jobRun)
	web.Delete("/job/(.*)", jobRemove)
	web.Put("/job/(.*)", jobUpdate)

	addr, _ := globalCfg.ReadString("http_addr", ":9090")
	web.Run(addr)
}
Esempio n. 7
0
func main() {
	web.Get("/", views.Index)
	web.Get("/manage", views.Manage)
	web.Get("/manage/create", views.Create)
	web.Post("/manage/create", views.Create)
	web.Get("/manage/existing", views.Existing)
	web.Get("/manage/existing/remove/(.*)", views.Remove)
	web.Post("/manage/existing/remove/(.*)", views.Remove)
	web.Get("/manage/existing/(.*)", views.ExistingEdit)
	web.Post("/manage/existing/(.*)", views.ExistingEdit)
	web.Run("0.0.0.0:9999")
}
Esempio n. 8
0
func AttachAdmin(url string) {
	web.Get(url+"unpublished/(\\d+)?", unpublishedList)
	web.Get(url+"posts/(\\d+)?", postList)
	app.GetPost(url+"posts/edit/(.*)", postEdit)
	web.Get(url+"posts/delete/(.*)", postDelete)
	app.GetPost(url+"posts/add/", postAdd)
	web.Post(url+"posts/preview/", postPreview)
	// pages
	app.GetPost(url+"pages/add/", pageAdd)
	app.GetPost(url+"pages/edit/(.*)", pageEdit)
	web.Post(url+"pages/preview/", pagePreview)
	web.Get(url+"pages/delete/(.*)", pageDelete)
	web.Get(url+"pages/(\\d+)?", pageList)
}
Esempio n. 9
0
// Initialize and run the web app.
func Reader() {
	readState()

	saveTicker := time.NewTicker(15 * time.Second)
	go saver(saveTicker)

	updateTicker := time.NewTicker(12 * time.Hour)
	go updater(updateTicker)

	web.Get("/", index)
	web.Post("/markAsRead", markAsRead)
	web.Post("/add", addNewFeed)
	web.Run("0.0.0.0:9090")
}
Esempio n. 10
0
func main() {
	initDummys()
	web.Get("/Home", renderPage)
	web.Get("/Splash", renderSplash)
	web.Get("/ProfileCard", renderProfile)
	web.Get("/CSS/(.*)", renderCSS)
	web.Get("/JS/(.*)", renderJS)
	web.Get("/Stream", renderStream)
	web.Get("/StreamItem", renderStreamItem)
	web.Post("/StreamItem", addStreamItem)
	web.Get("/Follows", renderFollow)
	web.Post("/Follow", addFollow)
	web.Run("0.0.0.0:9998")

}
Esempio n. 11
0
func (ce *ChatEngine) ServePages(basecp BaseCP, menuEntries MenuEntries) {
	chatCP := basecp(ce.state)
	chatCP.ContentTitle = "Chat"
	chatCP.ExtraCSSurls = append(chatCP.ExtraCSSurls, "/css/chat.css")

	tvgf := DynamicMenuFactoryGenerator(menuEntries)
	tvg := tvgf(ce.state)

	web.Get("/chat", chatCP.WrapSimpleContextHandle(ce.GenerateChatCurrentUser(), tvg))
	web.Post("/say", ce.GenerateSayCurrentUser())
	web.Get("/css/chat.css", ce.GenerateCSS(chatCP.ColorScheme))
	web.Post("/setchatlines", ce.GenerateSetChatLinesCurrentUser())
	// For debugging
	web.Get("/getchatlines", ce.GenerateGetChatLinesCurrentUser())
}
Esempio n. 12
0
func main() {
	web.Get("/", indexPage)
	web.Post("/upload/(.*)", uploader)
	web.Get("/download/(.*)", downloader)

	bindHost := flag.String("bind", "0.0.0.0:8000", "bind to this address:port")
	realHost := flag.String("real-host", "", "real hostname client use to connect")
	realScheme := flag.String("real-scheme", "", "real scheme client use to connect")
	useXForwardedFor := flag.Bool("use-x-forwarded-for", false, "use X-Forwarded-For header for logging")
	logfile := flag.String("logfile", "", "log file (defaulg: stderr)")

	flag.Parse()

	appConfig = AppConfig{
		*realScheme,
		*realHost,

		"http",
		*bindHost,

		*useXForwardedFor,
	}

	if *logfile != "" {
		web.SetLogger(NewRotateLog(*logfile, 1024*1024, 10, "", log.Ldate|log.Ltime))
	}

	web.Run(appConfig.BindHost)
}
Esempio n. 13
0
File: hooks.go Progetto: pepl/ircflu
func RegisterWebHook(hook Hook) {
	fmt.Println("Registering web-hook:", hook.Name(), "on", hook.Path())

	hook.SetMessageChan(msgsystem.MessagesOut)
	Hooks = append(Hooks, &hook)

	web.Post(hook.Path(), hook.Request)
}
Esempio n. 14
0
func (we *WikiEngine) ServePages(basecp BaseCP, menuEntries MenuEntries) {
	wikiCP := basecp(we.state)
	wikiCP.ContentTitle = "Wiki"
	wikiCP.ExtraCSSurls = append(wikiCP.ExtraCSSurls, "/css/wiki.css")

	tvgf := DynamicMenuFactoryGenerator(menuEntries)
	tvg := tvgf(we.state)

	web.Get("/wiki", we.GenerateWikiRedirect())                                         // Redirect to /wiki/main
	web.Get("/wikiedit/(.*)", wikiCP.WrapWebHandle(we.GenerateWikiEditForm(), tvg))     // Form for editing wiki pages
	web.Get("/wikisource/(.*)", wikiCP.WrapWebHandle(we.GenerateWikiViewSource(), tvg)) // Page for viewing the source
	web.Get("/wikidelete/(.*)", wikiCP.WrapWebHandle(we.GenerateWikiDeleteForm(), tvg)) // Form for deleting wiki pages
	web.Get("/wiki/(.*)", wikiCP.WrapWebHandle(we.GenerateShowWiki(), tvg))             // Displaying wiki pages
	web.Get("/wikipages", wikiCP.WrapSimpleContextHandle(we.GenerateListPages(), tvg))  // Listing wiki pages
	web.Post("/wiki", we.GenerateCreateOrUpdateWiki())                                  // Create or update pages
	web.Post("/wikideletenow", we.GenerateDeleteWikiNow())                              // Delete pages (admin only)
	web.Get("/css/wiki.css", we.GenerateCSS(wikiCP.ColorScheme))                        // CSS that is specific for wiki pages
}
Esempio n. 15
0
func Routes() {

	// "Brain" stuff
	web.Get("/scoreboard", getScoreboard)
	web.Get("/publicUsers", getPublicUsers)
	web.Put("/validateFlag", domainHandler(validateFlag))

	// To be implemented ?
	web.Post("/newuser", domainHandler(newUser))
}
func main() {
	conn, err = redis.Dial("tcp", ":6379")
	if err != nil {
		// handle error
	}
	defer conn.Close()

	web.Post("(.*)", handleFilter)
	web.Run("0.0.0.0:9999")
}
Esempio n. 17
0
func main() {
	DBConnect()
	defer DBDisconnect()

	web.Config.CookieSecret = "7C19QRmwf3mHZ9CPAaPQ0hsWeufKd"
	web.Get("/", index)
	web.Get("/month", month)
	web.Get("/post", post)

	web.Get("/rss.xml", rss)
	web.Get("/index.php/feed/", rss)
	web.Get("/index.php/feed/atom/", rss)

	web.Get("/admin/edit", editGet)
	web.Post("/admin/edit", editPost)

	web.Get("/admin", adminGet)
	web.Post("/admin", adminPost)

	web.Run("0.0.0.0:9876")

}
Esempio n. 18
0
// StartServer starts the Zilch Web Server.
func StartServer(resourceDir, port string) {
	start := time.Now()
	database, _ := NewDatabase(resourceDir)

	zcc := ZipCodeController{database}
	pc := PngController{database}
	sc := StaticController{}

	web.Get("/", sc.RenderRoot)
	web.Get("/query\\.?(.*)", zcc.Query)
	web.Post("/query\\.?(.*)", zcc.Query)
	web.Get("/distribution\\.?(.*)", zcc.GetDistribution)
	web.Post("/distribution\\.?(.*)", zcc.GetDistribution)
	web.Get("/countries\\.?(.*)", zcc.GetCountries)
	web.Post("/countries\\.?(.*)", zcc.GetCountries)
	web.Get("/map_(\\d*)\\.png", pc.RenderImage)
	web.Get("/distmap_(\\d*)\\.png", pc.RenderDistributionImage)
	web.Get("/images/(.*)", sc.RenderImages)
	web.Get("/js/(.*)", sc.RenderJS)
	web.Get("/(.*)", sc.RenderHTML)

	fmt.Printf("Server started on port %v in %v\n", port, time.Since(start))
	web.Run("0.0.0.0:" + port)
}
Esempio n. 19
0
func AttachAdmin(url string) {
	// auth
	web.Get(url+"login/", login)
	web.Post(url+"login/", login)
	web.Get(url+"logout/", logout)
	// users
	/*  too much unnecessary work?
	    web.Get(url + "users/", userList)
	    web.Get(url + "users/edit/(.*)", userEdit)
	    web.Get(url + "users/delete/(.*)", userDelete)
	    web.Get(url + "users/add/", userAdd)
	    web.Post(url + "users/add/", userAddPost)
	*/
	web.Get(url, adminIndex)
}
Esempio n. 20
0
func generateResourceRoutes(resource controllers.Controllers) {
	resourceString := controllers.FriendlyName(resource)

	models.SetupTable(resourceString)

	log.Printf(" - starting /%s routes generation\n", resourceString)
	web.Get("(?i)/"+resourceString+"/?", resource.Index)
	web.Get("(?i)/"+resourceString+"/(\\d*)", resource.Show)
	web.Get("(?i)/"+resourceString+"/new/?", resource.New)
	web.Get("(?i)/"+resourceString+"/(\\d*)", resource.Edit)

	web.Post("(?i)/"+resourceString+"/?", resource.Create)
	web.Put("(?i)/"+resourceString+"/(\\d*)", resource.Update)
	web.Delete("(?i)/"+resourceString+"/(\\d*)", resource.Delete)
	log.Printf(" - finished /%s routes generation\n", resourceString)
}
Esempio n. 21
0
func (mod *WebBee) Run(cin chan bees.Event) {
	mod.eventChan = cin

	web.Get(mod.path, mod.GetRequest)
	web.Post(mod.path, mod.PostRequest)

	web.Run(mod.addr)

	for {
		select {
		case <-mod.SigChan:
			web.Close()
			return

		default:
		}
	}
}
Esempio n. 22
0
func main() {
	rand.Seed(time.Now().UnixNano())
	web.Config.CookieSecret = "7C19QRmwf3mHZ9CPAaPQ0hsWeufKd"
	web.Get("/", func(ctx *web.Context) string {
		ctx.Redirect(302, "/said")
		return ""
	})
	web.Get("/said", func() string { return form })
	web.Post("/say", func(ctx *web.Context) string {
		uid := fmt.Sprintf("%d\n", rand.Int63())
		ctx.SetSecureCookie("user", uid, 3600)
		users[uid] = ctx.Params["said"]
		return `<a href="/final">Click Here</a>`
	})
	web.Get("/final", func(ctx *web.Context) string {
		uid, _ := ctx.GetSecureCookie("user")
		return "You said " + users[uid]
	})
	web.Run("0.0.0.0:9999")
}
Esempio n. 23
0
func startUp() {
	//Create DB if it doesn't exist
	if !exists("./sqlite.db") {
		success := createDB()
		if !success {
			panic("Fatal Error, DB could not be created")
		}
	}
	//Create Files/ if it doesn't exist
	if !exists("./files/") {
		os.Mkdir("files/", 0766)
	}

	updateURL := make(chan *urlUpdateMsg)
	go handleDB(updateURL)

	//Set route handlers
	web.Post("/api/upload", func(ctx *web.Context) string {
		return handleUpload(ctx, updateURL)
	})
	web.Get("/([a-z0-9]{6}.?[a-z0-9]*)", getFile)
}
Esempio n. 24
0
func (s HTTPServer) Run(proto string) {

	logger := initLogger(Settings.Log.File)
	redis := &redis.Client{Addr: Settings.Redis.Addr(),
		Db:       Settings.Redis.DB,
		Password: Settings.Redis.Password}

	var (
		indexHandler = &IndexHandler{}
		restHandler  = &RestQueueHandler{redis, logger}
		wsHandler    = &WSQueueHandler{redis, logger}
	)

	web.Get("/", indexHandler.Get)
	web.Get("/q", restHandler.List)
	web.Get("/q/(.+)", restHandler.Get)
	web.Post("/q/(.+)", restHandler.Put)
	web.Delete("/q/(.+)", restHandler.Clear)
	web.Get("/ws/(.+)", wsHandler.Consumer)
	web.SetLogger(logger)

	addr := Settings.HTTPServer.Addr()

	switch proto {
	case "http":
		web.Run(addr)
	case "fcgi":
		web.RunFcgi(addr)
	case "scgi":
		web.RunScgi(addr)
	default:
		flag.Usage()
		os.Exit(1)
	}

}
Esempio n. 25
0
func main() {
	web.Get("/", index)
	web.Post("/process", process)
	web.Run("0.0.0.0:9999")
}
Esempio n. 26
0
func main() {
	web.Get("/", index)
	web.Post("/multipart", multipart)
	web.Run("0.0.0.0:9999")
}
Esempio n. 27
0
func routes() {
	web.Put("/", paste)  //Defined in paste.go
	web.Post("/", paste) //Defined in paste.go
	web.Get("/([a-zA-Z0-9]+)", getPaste)
	web.Get("/", index)
}
Esempio n. 28
0
func main() {
	rootDir := filepath.Dir(os.Args[0])
	env := os.Getenv("ISUCON_ENV")
	if env == "" {
		env = "local"
	}

	configFile := filepath.Clean(rootDir +
		fmt.Sprintf("/../config/common.%s.json", env))
	f, err := ioutil.ReadFile(configFile)
	if err != nil {
		log.Fatal(err.Error())
	}
	var config Config
	json.Unmarshal(f, &config)

	templateFile := filepath.Join(rootDir, "templates", "*.t")
	tp, err := template.ParseGlob(templateFile)
	if err != nil {
		log.Fatal(err.Error())
	}
	db, err = sql.Open("mysql", fmt.Sprintf(
		"%v:%v@tcp(%v:%v)/%s?charset=utf8",
		config.Database.Username,
		config.Database.Password,
		config.Database.Host,
		config.Database.Port,
		config.Database.DBName))
	if err != nil {
		log.Fatal(err.Error())
	}

	web.Get("/", func(ctx *web.Context) {
		if err := tp.ExecuteTemplate(ctx, "index", &struct {
			RecentSolds []RecentSold
			Artists     []Artist
		}{recentSolds(), artists()}); err != nil {
			log.Print(err.Error())
			ctx.Abort(500, "Server Error")
		}
	})

	web.Get("/artist/(.*)", func(ctx *web.Context, id string) {
		a := artist(id)
		if err := tp.ExecuteTemplate(ctx, "artist", &struct {
			RecentSolds []RecentSold
			Name        string
			Tickets     []Ticket
		}{recentSolds(), a.Name, tickets(id)}); err != nil {
			log.Print(err.Error())
			ctx.Abort(500, "Server Error")
		}
	})

	web.Get("/ticket/(.*)", func(ctx *web.Context, id string) {
		t, v := ticket(id)
		if err := tp.ExecuteTemplate(ctx, "ticket", &struct {
			RecentSolds []RecentSold
			Ticket      Ticket
			Variations  []Variation
		}{recentSolds(), *t, v}); err != nil {
			log.Print(err.Error())
			ctx.Abort(500, "Server Error")
		}
	})

	web.Post("/buy", func(ctx *web.Context) {
		variationId, ok := ctx.Params["variation_id"]
		if !ok {
			variationId = ""
		}
		memberId, ok := ctx.Params["memberId"]
		if !ok {
			memberId = ""
		}

		tx, err := db.Begin()
		if err != nil {
			log.Print(err.Error())
			ctx.Abort(500, "Server Error")
		}

		res, err := tx.Exec(`INSERT INTO order_request (member_id) VALUES (?)`, memberId)
		if err != nil {
			log.Print(err.Error())
			ctx.Abort(500, "Server Error")
		}
		orderId, err := res.LastInsertId()
		if err != nil {
			log.Print(err.Error())
			ctx.Abort(500, "Server Error")
		}
		res, err = tx.Exec(`UPDATE stock SET order_id = ? WHERE variation_id = ? AND order_id IS NULL ORDER BY RAND() LIMIT 1`, orderId, variationId)
		if err != nil {
			log.Print(err.Error())
			ctx.Abort(500, "Server Error")
		}
		affected, err := res.RowsAffected()
		if err != nil {
			log.Print(err.Error())
			ctx.Abort(500, "Server Error")
		}

		if affected > 0 {
			rows, err := tx.Query(`SELECT seat_id FROM stock WHERE order_id = ? LIMIT 1`, orderId)
			if err != nil {
				tx.Rollback()
				log.Print(err.Error())
				ctx.Abort(500, "Server Error")
			}
			var seatId string
			if rows.Next() {
				rows.Scan(&seatId)
			}
			rows.Close()
			tx.Commit()
			err = tp.ExecuteTemplate(ctx, "complete", &struct {
				SeatId   string
				MemberId string
			}{
				seatId,
				memberId,
			})
		} else {
			tx.Rollback()
			err = tp.ExecuteTemplate(ctx, "soldout", nil)
		}
		if err != nil {
			log.Print(err.Error())
			ctx.Abort(500, "Server Error")
		}
	})

	web.Get("/admin", func(ctx *web.Context) {
		err := tp.ExecuteTemplate(ctx, "admin", nil)
		if err != nil {
			log.Print(err.Error())
			ctx.Abort(500, "Server Error")
		}
	})

	web.Post("/admin", func(ctx *web.Context) {
		sqlFile := filepath.Clean(filepath.Join(rootDir, "../config/database/initial_data.sql"))
		f, err := os.Open(sqlFile)
		if err != nil {
			log.Print(err.Error())
			ctx.Abort(500, "Server Error")
		}
		defer f.Close()
		buf := bufio.NewReader(f)
		for {
			b, err := buf.ReadString('\n')
			if err != nil {
				break
			} else if line := strings.TrimSpace(string(b)); line != "" {
				_, err = db.Exec(line)
				if err != nil {
					log.Print(err.Error())
					ctx.Abort(500, "Server Error")
				}
			}
		}
		ctx.Redirect(302, "/admin")
	})

	web.Get("/admin/order.csv", func(ctx *web.Context) {
		rows, err := db.Query(`
            SELECT order_request.*, stock.seat_id, stock.variation_id, stock.updated_at
            FROM order_request JOIN stock ON order_request.id = stock.order_id
            ORDER BY order_request.id ASC
		`)
		if err != nil {
			log.Print(err.Error())
			ctx.Abort(500, "Server Error")
		}
		defer rows.Close()

		for rows.Next() {
			var id, memberId, seatId, variationId, updatedAt string
			rows.Scan(&id, &memberId, &seatId, &variationId, &updatedAt)
			ctx.SetHeader("Content-Type", "text/csv; charset=utf-8", true)
			line := strings.Join([]string{id, memberId, seatId, variationId, updatedAt}, ",") + "\n"
			ctx.Write([]byte(line))
		}
	})

	web.Config.StaticDir = filepath.Clean(rootDir + "/../staticfiles")

	web.Run(":8081")
}
Esempio n. 29
0
func main() {
	web.Get("/(.*)", getItem)
	web.Post("/(.*)", upsertItem)
	web.Delete("/(.*)", deleteItem)
	web.Run(flagPort)
}
Esempio n. 30
0
File: main.go Progetto: jxe/gldb
func main() {
	log.Print("Starting GLDB server")
	var db, err = gldb.GLDBFromMongoURL(os.Getenv("GLDB_MONGO_URL"))
	if err != nil {
		panic(err)
	}
	log.Print("Connected to mongolab")

	// data collection

	web.Post("/did", func(c *web.Context) string {
		r := &gldb.Review{
			DoableURL:          c.Params["what"],
			Comment:            c.Params["comment"],
			QualitiesConfirmed: strings.Split(c.Params["qualities"], ","),
		}

		scrapeResults, err := scraper.Slurp(r.DoableURL)
		if err != nil {
			panic(err)
		}

		db.AddReviewAndRelatedData(r, c.Params["metro"], c.Params["sociographic"], c.Params["comment"], scrapeResults)
		return "thanks"
	})

	// querying

	web.Get("/subjects", func(c *web.Context) string {
		c.ContentType("json")
		interests := db.SubjectsInMetro(c.Params["metro"], c.Params["quality"])
		body, err := json.MarshalIndent(interests, "", "    ")
		if err != nil {
			panic(err)
		}
		return string(body)
	})

	web.Get("/subject", func(c *web.Context) string {
		c.ContentType("json")
		doables := db.DoablesForSubjectInMetro(c.Params["metro"], c.Params["subject"])
		body, err := json.MarshalIndent(doables, "", "    ")
		if err != nil {
			panic(err)
		}
		return string(body)
	})

	// debugging

	web.Get("/raw", func(c *web.Context) string {
		f := scraper.NewFetcherForURL(c.Params["url"])
		return string(*f.ResponseBodyBytes())
	})

	web.Get("/json", func(c *web.Context) string {
		c.ContentType("json")
		results, err := scraper.Slurp(c.Params["url"])
		if err != nil {
			panic(err)
		}
		body, err := json.MarshalIndent(results, "", "    ")
		if err != nil {
			panic(err)
		}
		return string(body)
	})

	web.Run("0.0.0.0:" + os.Getenv("PORT"))
}