func main() {
// Gather configuration from environment
port := env.StringDefault("PORT", "8080")
pwd := env.String("PWD")
dbDir := env.StringDefault("DB_DIR", pwd+"/db")
// Start the service
setupDb(dbDir)
fmt.Printf("Starting server on localhost:%v\n", port)
log.Fatal(http.ListenAndServe(":"+port, muxer()))
}
func init() {
flag.StringVar(&url, "url", "", "the url to send")
flag.StringVar(&email, "email", "", "the email to send to")
path, _ := exec.LookPath("kindlegen")
flag.StringVar(&kindlegen, "kindlegen", path, "the path to the kindlegen binary")
flag.StringVar(&rdbToken, "readability", env.StringDefault("READABILITY_TOKEN", ""), "the readability token")
flag.StringVar(&pmToken, "postmark", env.StringDefault("POSTMARK_TOKEN", ""), "the postmark token")
flag.StringVar(&from, "from", env.StringDefault("FROM", ""), "the from address")
flag.Parse()
}
func main() {
port := env.StringDefault("PORT", "9000")
pwd := env.StringDefault("PWD", "/app")
//
// File Server
//
http.Handle("/", http.FileServer(http.Dir(pwd+"/public")))
//
// Start Webserver
//
log.Println("Starting webserver on port " + port + "...")
log.Fatal(http.ListenAndServe(":"+port, nil))
}
func main() {
log.SetFlags(log.Ltime | log.Lshortfile)
//
// Connect to MongoDB
//
mongoUrl := env.StringDefault("MONGOLAB_URI", "localhost")
log.Println("Connecting to MongoDB on " + mongoUrl + "...")
session, err := mgo.Dial(mongoUrl)
if err != nil {
log.Fatal(err)
}
defer session.Close()
db := session.DB("")
_, err = db.CollectionNames()
if err != nil || db.Name == "test" {
log.Println("Setting db name to 'o2pro'.")
db = session.DB("o2pro")
}
a := o2pro.Authorizer(fakeAuth)
srv, err := o2pro.NewMongoServer(db, "8h", a)
if err != nil {
log.Fatal(err)
}
hf := srv.PasswordHandler()
http.HandleFunc("/auth", hf)
log.Println("Listening on ", addr)
log.Fatal(http.ListenAndServe(addr, nil))
}
func init() {
redis := env.StringDefault("REDISCLOUD_URL", env.StringDefault("REDIS_PORT", ""))
if redis != "" {
cache.SetupRedis(redis, env.StringDefault("REDIS_OPTIONS", "timeout=15s&maxidle=1"))
}
rdbToken := env.String("READABILITY_TOKEN")
pmToken := env.String("POSTMARK_TOKEN")
from := env.String("FROM")
binary, _ := exec.LookPath(fmt.Sprintf("kindlegen-%s", runtime.GOOS))
tlogger := log.New(os.Stdout, "[tinderizer] ", env.IntDefault("LOG_FLAGS", log.LstdFlags|log.Lmicroseconds))
app = tinderizer.New(rdbToken, pmToken, from, binary, tlogger)
app.Run(QueueSize)
// TODO: handle SIGINT
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
go shutdown(c)
}
func SetupPostgres() error {
dbUrl := env.StringDefault("DATABASE_URL", "postgres://")
dsn, err := pq.ParseURL(dbUrl)
if err != nil {
return err
}
db, err := sql.Open("postgres", dsn)
if err != nil {
return err
}
dbmap.Db = db
dbmap.Dialect = gorp.PostgresDialect{}
return nil
}
func (s *S) TestStrings(c *C) {
c.Assert(func() { env.String("DOESNT_EXIST") }, Panics, errors.New("env: Environment variable DOESNT_EXIST doesn't exist"))
os.Setenv("test", "gocheck")
test := map[string]string{
env.String("test"): "gocheck",
env.StringDefault("foobar", "fizzbin"): "fizzbin",
env.StringDefaultF("foobar", func() string { return "fizzbot" }): "fizzbot",
}
for obtained, expected := range test {
c.Assert(obtained, Equals, expected)
}
}
func main() {
port := env.StringDefault("PORT", "8000")
log.SetPrefix("[lgtts] ")
log.SetFlags(log.Ltime | log.Ldate | log.Lshortfile)
err := lgtts.SetupPostgres()
if err != nil {
log.Fatal(err)
}
ws := lgtts.NewWebService()
restful.Add(ws)
log.Printf("Listening on localhost:" + port)
log.Fatal(http.ListenAndServe(":"+port, nil))
}
func main() {
port := env.StringDefault("PORT", "8080")
baseUrl := ":" + port
var ws restful.WebService
ws.Path("/api").
Consumes(restful.MIME_JSON).
Produces(restful.MIME_JSON)
ws.Route(ws.GET("/bar").To(getBar).
Writes(Bar{}))
ws.Route(ws.GET("/foo").To(getFoo).
Writes(Foo{}))
restful.Add(&ws)
log.Printf("Starting webserver on %v...", baseUrl)
log.Fatal(http.ListenAndServe(baseUrl, nil))
}
func main() {
log.SetFlags(log.Ltime | log.Lshortfile)
//
// Configuration
//
port := env.StringDefault("PORT", "9000")
pwd := env.StringDefault("PWD", "/app")
mongoUrl := env.StringDefault("MONGOLAB_URI", "localhost")
neoUrl := env.StringDefault("NEO4J_URL", "http://localhost:7474/db/data")
statPrefix = env.StringDefault("STATHAT_PREFIX", "")
ezkey = env.StringDefault("STATHAT_EZKEY", "")
//
// Connect to MongoDB
//
log.Println("Connecting to MongoDB on " + mongoUrl + "...")
session, err := mgo.Dial(mongoUrl)
if err != nil {
log.Panicln(err)
}
defer session.Close()
mongo = session.DB("")
_, err = mongo.CollectionNames()
if err != nil {
log.Println("Setting db name to 'decisions'.")
mongo = session.DB("decisions")
}
//
// Connect to Neo4j
//
log.Println("Connecting to Neo4j on " + neoUrl + "...")
neo, err = neo4j.Connect(neoUrl)
if err != nil {
log.Println("Cannot connect to Neo4j:")
log.Println(err)
}
//
// Routing
//
mux := pat.New()
mux.Post("/decide", track(http.HandlerFunc(Decide), "/v1/decide"))
http.Handle("/v1/", http.StripPrefix("/v1", mux))
http.Handle("/", http.FileServer(http.Dir(pwd+"/app")))
//
// Start Webserver
//
log.Println("Starting webserver on port " + port + "...")
err = http.ListenAndServe(":"+port, nil)
if err != nil {
log.Panicln(err)
}
}
func setupMongoStorage() *srom.MongoStorage {
//
// Setup MongoDB
//
mongoUrl := env.StringDefault("MONGOLAB_URI", "localhost")
log.Println("Connecting to MongoDB on " + mongoUrl + "...")
session, err := mgo.Dial(mongoUrl)
if err != nil {
log.Panic(err)
}
defer session.Close()
db := session.DB("")
_, err = db.CollectionNames()
if err != nil {
log.Println("Setting db name to 'SROM'.")
db = session.DB("SROM")
}
collection := db.C("terms")
termIdx := mgo.Index{
Key: []string{"Term", "Timestamp"},
Unique: false,
Background: true,
}
log.Println("Ensuring Term, Timestamp index")
err = collection.EnsureIndex(termIdx)
if err != nil {
log.Panic(err)
}
ratioIdx := mgo.Index{
Key: []string{"Ratio", "Timestamp"},
Unique: false,
Background: true,
}
log.Println("Ensuring Ratio, Timestamp index")
err = collection.EnsureIndex(ratioIdx)
if err != nil {
log.Panic(err)
}
mongo := srom.MongoStorage{
Col: collection,
}
return &mongo
}
"io/ioutil"
"log"
"os"
"os/signal"
"syscall"
"text/template"
)
const (
CoffeeScriptPath = "bookmarklet/bookmarklet.coffee"
LessPath = "bookmarklet/bookmarklet.less"
)
var (
script = make(chan []byte, 1)
protocol = env.StringDefault("PROTOCOL", "http")
port = env.IntDefault("PORT", 8080)
host = env.StringDefaultF("CANONICAL_HOST", func() string { return fmt.Sprintf("tinderizer.dev:%d", port) })
compress = env.StringDefault("BOOKMARKLET_PRECOMPILE", "") == "ugly"
logger = log.New(os.Stdout, "[bookmarklet] ", env.IntDefault("LOG_FLAGS", log.LstdFlags|log.Lmicroseconds))
)
func init() {
script <- compileCoffeeScript(compress)
update := make(chan os.Signal, 1)
signal.Notify(update, syscall.SIGUSR1)
go handleSignals(update)
}
func handleSignals(c <-chan os.Signal) {
for _ = range c {