Example #1
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")
}
Example #2
0
// TODO: One database per site
func main() {

	// UserState with a Redis Connection Pool
	userState := permissions.NewUserState(0, true, ":6379")

	defer userState.Close()

	// The archlinux.no webpage,
	mainMenuEntries := ServeArchlinuxNo(userState, "/js/jquery-"+JQUERY_VERSION+".min.js")

	ServeEngines(userState, mainMenuEntries)

	// Compilation errors, vim-compatible filename
	web.Get("/error", webhandle.GenerateErrorHandle("errors.err"))
	web.Get("/errors", webhandle.GenerateErrorHandle("errors.err"))

	// Various .php and .asp urls that showed up in the log
	genericsite.ServeForFun()

	// TODO: Incorporate this check into web.go, to only return
	// stuff in the header when the HEAD method is requested:
	// if ctx.Request.Method == "HEAD" { return }
	// See also: curl -I

	// Serve on port 3009 for the Nginx instance to use
	web.Run("0.0.0.0:3009")
}
Example #3
0
func main() {
	flag.Parse()
	web.Get("/", func() string {
		return "Hello World"
	})
	web.Run(":8080")
}
Example #4
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))

}
Example #5
0
func main() {
	web.Get("/vnstat/(.*)/(.*)", vnstat)
	web.Get("/dashboard/(.*)", dashboard)
	web.Get("/list", ifacelist)
	web.Get("/", home)
	web.Run(port)
}
Example #6
0
File: main.go Project: 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)
}
Example #7
0
func main() {
	web.Get("/getuserinfo", getlist)
	web.Get("/add/(.*)", addDrink)
	web.Get("/del/(.*)", delDrink)
	web.Run("127.0.0.1:9999")

}
Example #8
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)
}
Example #9
0
func main() {
	pckgDir = os.Getenv("GOPATH") + "/src/github.com/tahmmee/greenboard/"
	web.Config.StaticDir = pckgDir + "app"

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

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

	// start web api
	api = new(Api)
	api.CouchbaseAddress = config.CouchbaseAddress
	api.DataSources = make(map[string]*DataSource)
	api.AddDataSource("server")
	api.AddDataSource("mobile")
	api.AddDataSource("sdk")

	web.Get("/", api.GetIndex)
	web.Get("/timeline", api.GetTimeline)
	web.Get("/breakdown", api.GetBreakdown)
	web.Get("/jobs", api.GetJobs)
	web.Get("/versions", api.GetVersions)
	web.Get("/categories", api.GetCategories)
	web.Get("/jobs_missing", api.GetMissingJobs)
	web.Run(config.ListenAddress)
}
Example #10
0
func main() {

	// Set the static directory for webgo
	path := os.Getenv("GOPATH")
	if path == "" {
		fmt.Println("GOPATH NOT SET")
		return
	}
	filepath := fmt.Sprintf("%s/../frontend/src/", path)
	web.Config.StaticDir = filepath

	// Setup logging
	log := make(l4g.Logger)
	// Create a default logger that is logging messages of FINE or higher
	l4g.AddFilter("file", l4g.FINE, l4g.NewFileLogWriter("error_log.log", false))
	log.Close()

	// Setup the DB
	db.Init(path)

	// Parse command line arguments
	port := flag.Int("port", 80, "port number to start the server on")
	flag.Parse()
	url := fmt.Sprintf("0.0.0.0:%d", *port)

	// Start the server!
	serve.Routes()
	web.Run(url)
}
func main() {
	go mainHub.Run()
	document_hubs = setupDocuments()
	chat_hubs = setupChats()
	// Get hostname if specified
	args := os.Args
	host := "0.0.0.0:8080"
	if len(args) == 2 {
		host = args[1]
	}
	parts := strings.Split(host, ":")
	fmt.Println(parts)
	web.Config.Addr = parts[0]
	web.Config.Port, _ = strconv.Atoi(parts[1])
	web.Config.StaticDir = filepath.Join(os.Getenv("GOPATH"), "src/server/client/public")
	web.Get("/", home)
	web.Get("/ws", serveWs)
	web.Get("/rest/documents", getDocuments)
	web.Put("/rest/documents/(.*)", setDocumentTitle)
	web.Delete("/rest/documents/(.*)", deleteDocument)
	web.Get("/documents/(.*)", documentStream)
	web.Get("/chat/(.*)", chatStream)
	web.Run(host)

}
Example #12
0
func main() {
	fmt.Printf("Using config %s\n", conf.Path)
	fmt.Printf("Using models:\n")
	for _, m := range db.Models {
		t := reflect.TypeOf(m)
		fmt.Printf("    %s\n", fmt.Sprintf("%s", t)[1:])
	}

	template.Init(conf.Config.TemplatePaths)
	fmt.Printf(conf.Config.String())
	web.Config.StaticDir = conf.Config.StaticPath

	db.Connect(conf.Config.DbHostString(), conf.Config.DbName)
	db.RegisterAllIndexes()

	blog.AttachAdmin("/admin/")
	blog.Attach("/")

	app.AttachAdmin("/admin/")
	app.Attach("/")

	gallery.AttachAdmin("/admin/")
	gallery.Attach("/")

	web.Get("/$", blog.Index)
	web.Get("/(.*)", blog.Flatpage)

	app.AddPanel(&blog.PostPanel{})
	app.AddPanel(&blog.UnpublishedPanel{})
	app.AddPanel(&blog.PagesPanel{})
	app.AddPanel(&gallery.GalleryPanel{})

	web.Run(conf.Config.HostString())
}
Example #13
0
func main() {
	fmt.Printf("Starting server ... ")
	web.Get("/iching/hexagrams/(.*)", hexagram)
	web.Get("/iching/hexagrams", allHexagrams)
	web.Get("/iching/reading", reading)
	web.Run("0.0.0.0:9999")
}
Example #14
0
func main() {
	logger := log.New(ioutil.Discard, "", 0)
	runtime.GOMAXPROCS(runtime.NumCPU())
	web.Get("/(.*)", hello)
	web.SetLogger(logger)
	web.Run("0.0.0.0:8080")
}
Example #15
0
// Loop Func Register web interface
func Loop() {

	// 注册web接口
	web.Get("/ping", PingHandler)
	web.Get("/d", ResolveHandler)
	addr := fmt.Sprintf("%s:%s", appConfig.Listen, appConfig.Port)
	web.Run(addr)
}
func main() {
	f, _ := os.Create("server.log")
	logger := log.New(f, "", log.Ldate|log.Ltime)
	runtime.GOMAXPROCS(runtime.NumCPU())
	web.Get("/(.*)", hello)
	web.SetLogger(logger)
	web.Run("0.0.0.0:8080")
}
Example #17
0
func startServer(port string) {
	models.SetDatabase(&globalConfiguration.Database)

	web.Get("/?", index)
	generateRoutes()

	web.Run("0.0.0.0:" + port)
}
Example #18
0
func main() {
	web.Get("/()", IndexLoad)
	web.Get("/match/()", CompareNames)
	//web.Get("/test/(.*)", TestLoadHome)
	web.Get("/static/(.*)", Sendstatic)
	//STARTING PROCEDURE
	web.Run("0.0.0.0:8830")
}
Example #19
0
func main() {
	rand.Seed(time.Now().UnixNano())
	port := os.Getenv("PORT")
	if port == "" {
		port = "9999"
	}
	web.Get("/(.*)", hello)
	web.Run(":" + port)
}
Example #20
0
func main() {

	// parse command line arguments
	flag.Parse()
	web.Get("/(list)", list)
	//web.Get("/(.*)", list)
	//    web.SetLogger(glog)
	web.Run("0.0.0.0:9999")
}
Example #21
0
File: server.go Project: 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))
}
Example #22
0
func main() {
	config, err := getConfig()
	if err != nil {
		panic(err.Error())
	}
	web.Get("/([a-zA-Z0-9-]*)", handleSection)
	web.Get("/([a-zA-Z0-9-]+)/([0-9]+)", handlePaginatedSection)
	web.Get("/([a-zA-Z0-9-]+)/([a-zA-Z]{1}[a-zA-Z0-9-]*)", handlePage)
	web.Run(config.ServerIp)
}
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")
}
Example #24
0
func main() {
	web.Get("/eject", func(ctx *web.Context) {
		ctx.ContentType("application/json")
		if err := eject.Eject(); err != nil {
			json.NewEncoder(ctx).Encode(&result{err.Error()})
		} else {
			json.NewEncoder(ctx).Encode(&result{nil})
		}
	})
	web.Run(":8080")
}
Example #25
0
func main() {
	f, err := os.Create("server.log")
	if err != nil {
		println(err.Error())
		return
	}
	logger := log.New(f, "", log.Ldate|log.Ltime)
	web.Get("/(.*)", hello)
	web.SetLogger(logger)
	web.Run("0.0.0.0:9999")
}
Example #26
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)
}
Example #27
0
func main() {
	fmt.Println("onthefly ", onthefly.Version)

	// Connect the url for the HTML and CSS with the HTML and CSS generated from indexPage
	webhandle.PublishPage("/", "/style.css", indexPage)

	// Connect /circles.svg with the generated handle
	web.Get("/circles.svg", svgHandlerGenerator())

	// Listen for requests at port 3000
	web.Run(":3000")
}
Example #28
0
File: demo8.go Project: lcbyz/Go
func main() {
	web.Get("/(.*)", welcome)
	web.Run("0.0.0.0:9999")
LABEL1:
	for {
		for i := 0; i < 10; i++ {
			if i > 5 {
				break LABEL1
			}
		}
	}
	fmt.Println("OK")

	// 冒泡排序
	a := [...]int{2, 33, 11, 99, 55, 88}

	fmt.Println(a)

	for i, num := 0, len(a); i < num; i++ {
		for j := 0; j < i+1; j++ {
			if a[i] > a[j] {
				temp := a[i]
				a[i] = a[j]
				a[j] = temp
			}
		}
	}

	fmt.Println(a)

	a1 := [...]int{1, 2, 3, 4, 5}
	fmt.Println(a1)

	s := a1[:]
	fmt.Println(s)

	s1 := make([]map[int]string, 10)

	for k := range s1 {
		s1[k] = make(map[int]string, 1)
		s1[k][1] = "OK"
	}

	fmt.Println(s1)

	m1 := map[int]string{1: "a", 2: "b", 3: "c", 4: "d", 5: "e"}
	fmt.Println(m1)
	m2 := make(map[string]int)
	for k, v := range m1 {
		m2[v] = k
	}
	fmt.Println(m2)
}
Example #29
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")
}
Example #30
0
func main() {
	port := flag.String("port", "8080", "The port that Sto should listen on. By default it is 8080.")
	procs := flag.Int("procs", 1, "The maximum number of processes that can be used by Go. The default value is one, but at least two are recommended in order to maximize performance.")
	flag.Parse()

	if *procs > runtime.NumCPU() {
		panic("Fatal error: You tried to use more processes than there are CPUs available")
	}
	runtime.GOMAXPROCS(*procs)
	startUp()

	web.Run("0.0.0.0:" + *port)
}