Example #1
0
// Opens a connection to the datasource. See Session().
func (self *Source) Open() error {
	var err error

	connURL := &url.URL{Scheme: "mongodb"}

	if self.config.Port == 0 {
		self.config.Port = 27017
	}

	if self.config.Host == "" {
		self.config.Host = "127.0.0.1"
	}

	connURL.Host = fmt.Sprintf("%s:%d", self.config.Host, self.config.Port)

	if self.config.User != "" {
		connURL.User = url.UserPassword(self.config.User, self.config.Password)
	}

	if self.config.Database != "" {
		connURL.Path = "/" + self.config.Database
	}

	self.session, err = mgo.DialWithTimeout(connURL.String(), 5*time.Second)

	if err != nil {
		return err
	}

	if self.config.Database != "" {
		self.Use(self.config.Database)
	}

	return nil
}
Example #2
0
// Connects to the previously specified datasource. See Session().
func (m *MongoDataSource) Open() error {
	var err error

	connURL := &url.URL{Scheme: "mongodb"}

	if m.config.Port == 0 {
		m.config.Port = 27017
	}

	if m.config.Host == "" {
		m.config.Host = "127.0.0.1"
	}

	connURL.Host = fmt.Sprintf("%s:%d", m.config.Host, m.config.Port)

	if m.config.User != "" {
		connURL.User = url.UserPassword(m.config.User, m.config.Password)
	}

	m.session, err = mgo.DialWithTimeout(connURL.String(), 5*time.Second)

	if err != nil {
		return fmt.Errorf("Could not connect to %v.", m.config.Host)
	}

	if m.config.Database != "" {
		m.Use(m.config.Database)
	}

	return nil
}
Example #3
0
// Attempts to connect to a database using the stored settings.
func (self *Source) Open() error {
	var err error

	connURL := &url.URL{Scheme: `mongodb`}

	if self.config.Port == 0 {
		self.config.Port = 27017
	}

	if self.config.Host == "" {
		self.config.Host = `127.0.0.1`
	}

	connURL.Host = fmt.Sprintf(`%s:%d`, self.config.Host, self.config.Port)

	if self.config.User != "" {
		connURL.User = url.UserPassword(self.config.User, self.config.Password)
	}

	if self.config.Database != "" {
		connURL.Path = "/" + self.config.Database
	}

	if self.config.Database == "" {
		return db.ErrMissingDatabaseName
	}

	if self.session, err = mgo.DialWithTimeout(connURL.String(), connTimeout); err != nil {
		return err
	}

	self.Use(self.config.Database)

	return nil
}
//private to this file
func _createSession() (*mgo.Session, error) {

	if _cfg == nil {
		_cfg = &mongoConfig{}
		framework.Config.ReadInto("mongo", &_cfg)
	}

	var timeout = 10 * time.Second

	if _cfg.ConnectionString != "" {

		return mgo.DialWithTimeout(_cfg.ConnectionString, timeout)
	} else {

		dialInfo := mgo.DialInfo{}
		dialInfo.Database = _cfg.Database
		dialInfo.Username = _cfg.User
		dialInfo.Password = _cfg.Password
		dialInfo.Addrs = []string{fmt.Sprintf("%s:%s", _cfg.Host, _cfg.Port)}
		dialInfo.Timeout = timeout

		fmt.Println("Logging to", dialInfo.Addrs[0])

		return mgo.DialWithInfo(&dialInfo)
	}
}
Example #5
0
func DBConnect() (d *db, err error) {
	session, err := mgo.DialWithTimeout(conf.MONGODB, DbTimeout)
	if err != nil {
		return
	}
	d = &db{User: session.DB("ShockDB").C("Users"), Session: session}
	return
}
Example #6
0
func DBConnect() (d *db, err error) {
	session, err := mgo.DialWithTimeout(conf.MONGODB, DbTimeout)
	if err != nil {
		return
	}
	d = &db{Jobs: session.DB("AWEDB").C("Jobs"), Session: session}
	return
}
Example #7
0
File: db.go Project: eberroca/Shock
func DBConnect() (d *db, err error) {
	session, err := mgo.DialWithTimeout(conf.MONGODB, DbTimeout)
	if err != nil {
		return
	}
	d = &db{Nodes: session.DB("ShockDB").C("Nodes"), PreAuth: session.DB("ShockDB").C("PreAuth"), Session: session}
	return
}
Example #8
0
func connectMongo(c *C) *mgo.Session {
	session, err := mgo.DialWithTimeout(testMongoHost, 500*time.Millisecond)
	if err != nil {
		c.Fatalf(err.Error())
	}
	session.SetMode(mgo.Monotonic, true)
	session.SetSyncTimeout(200 * time.Millisecond)
	session.SetSocketTimeout(200 * time.Millisecond)
	return session
}
Example #9
0
func main() {
	host := flag.String("host", "nair.local", "mongodb host name") // "nair.local"
	dbname := flag.String("db", "enron", "database name")          //"enron"
	colname := flag.String("col", "messages", "collection name")   //"messages"
	keyword := flag.String("kw", "Sunday", "keyword to search")    //"Sunday"
	flag.Parse()
	timeout := time.Duration(1) * time.Second
	session, _ := mgo.DialWithTimeout(*host, timeout)
	operator := NewOperator(session.DB(*dbname).C(*colname))
	operator.FindKeyword(*keyword)
}
func getMgoSession() *mgo.Session {
	if mgoSession == nil {
		var err error
		mgoSession, err = mgo.DialWithTimeout(mgoURL, 5*time.Second)
		if err != nil {
			panic(err)
		}
		// Set timeout to suitably small value by default.
		mgoSession.SetSyncTimeout(5 * time.Second)
	}
	return mgoSession.Copy()
}
Example #11
0
func (b *Backend) connectDB() error {

	var err error

	b.session, err = mgo.DialWithTimeout(fmt.Sprintf("%s:%d/%s", b.dbConfig.IP, b.dbConfig.Port, b.dbConfig.Name), time.Second*3)
	if err != nil {
		return err
	}
	b.session.SetMode(mgo.Monotonic, true)

	return b.session.Ping()
}
Example #12
0
func getSession() *mgo.Session {
	if mgoSession == nil {
		var err error
		mgoSession, err = mgo.DialWithTimeout(databaseServer, 60*time.Second)
		mgoSession.SetMode(mgo.Monotonic, true)
		mgoSession.SetMode(mgo.Strong, true)
		if err != nil {
			panic(err) // no, not really
		}
	}
	return mgoSession.Clone()
}
Example #13
0
// ping won't work with old (1.2) mongo servers.
func (ins *instance) ping(timeout time.Duration) bool {
	session, err := mgo.DialWithTimeout(ins.url(), timeout)
	if err != nil {
		return false
	}
	defer session.Close()
	session.SetSyncTimeout(timeout)
	if err = session.Ping(); err != nil {
		return false
	}
	return true
}
Example #14
0
func Initialize() (err error) {
	c := connection{}
	s, err := mgo.DialWithTimeout(conf.MONGODB_HOST, DbTimeout)
	if err != nil {
		e := errors.New(fmt.Sprintf("no reachable mongodb server(s) at %s", conf.MONGODB_HOST))
		return e
	}
	c.Session = s
	c.DB = c.Session.DB(conf.MONGODB_DATABASE)
	if conf.MONGODB_USER != "" && conf.MONGODB_PASSWD != "" {
		c.DB.Login(conf.MONGODB_USER, conf.MONGODB_PASSWD)
	}
	Connection = c
	return
}
Example #15
0
func open(addr, dbname string) (*Storage, error) {
	sess, err := mgo.DialWithTimeout(addr, 1e9)
	if err != nil {
		return nil, err
	}
	copy := sess.Copy()
	go func(t time.Duration) {
		time.Sleep(t)
		copy.Close()
	}(maxIdleTime)
	storage := &Storage{session: copy, dbname: dbname}
	mut.Lock()
	conn[addr] = &session{s: sess, used: time.Now()}
	mut.Unlock()
	return storage, nil
}
Example #16
0
File: db.go Project: wtangiit/Shock
func Initialize() (err error) {
	c := connection{}
	s, err := mgo.DialWithTimeout(conf.Conf["mongodb-hosts"], DbTimeout)
	if err != nil {
		e := errors.New(fmt.Sprintf("no reachable mongodb server(s) at %s", conf.Conf["mongodb-hosts"]))
		fmt.Fprintln(os.Stderr, "Error: "+e.Error())
		return e
	}
	c.Session = s
	c.DB = c.Session.DB(conf.Conf["mongodb-database"])
	if conf.Conf["mongodb-user"] != "" && conf.Conf["mongodb-password"] != "" {
		c.DB.Login(conf.Conf["mongodb-user"], conf.Conf["mongodb-password"])
	}
	Connection = c
	return
}
Example #17
0
func (this *Client) getConn(url string) (*mgo.Session, error) {
	sess, ok := this.getFreeConn(url)
	if ok {
		return sess, nil
	}

	// create session on demand
	sess, err := mgo.DialWithTimeout(url, this.connectTimeout)
	if err != nil {
		return nil, err
	}

	sess.SetSocketTimeout(this.ioTimeout)

	return sess, nil
}
Example #18
0
func (self *SessionFactory) GetSession() (*mgo.Session, *mgo.Database, error) {

	// init the master session if necessary
	if self.masterSession == nil {
		var err error
		self.masterSession, err = mgo.DialWithTimeout(self.Url,
			self.DialTimeout)
		if err != nil {
			return nil, nil, err
		}
	}

	// copy the master session
	sessionCopy := self.masterSession.Copy()
	return sessionCopy, sessionCopy.DB(self.DBName), nil

}
Example #19
0
// GetDB returns a database connection.
func GetDB() (*mgo.Database, error) {
	if db == nil && session == nil {
		goserv.Logger.Info("Creating new session: ", conf.Config.MongoURI)
		ses, err := mgo.DialWithTimeout(conf.Config.MongoURI, 3*time.Second)
		if err != nil {
			goserv.Logger.Error("Could not connect to MongoDB: ", err)
			return nil, err
		}
		session := *ses
		newdb := session.DB(conf.Config.MongoDatabase)
		goserv.Logger.Infof("Connection made %s", newdb.Name)
		if err != nil {
			goserv.Logger.Fatal(err)
		}
		db = newdb
	}
	return db, nil
}
Example #20
0
func (s *S) TestDialWithTimeout(c *C) {
	if *fast {
		c.Skip("-fast")
	}

	timeout := 2 * time.Second
	started := time.Now()

	// 40009 isn't used by the test servers.
	session, err := mgo.DialWithTimeout("localhost:40009", timeout)
	if session != nil {
		session.Close()
	}
	c.Assert(err, ErrorMatches, "no reachable servers")
	c.Assert(session, IsNil)
	c.Assert(started.Before(time.Now().Add(-timeout)), Equals, true)
	c.Assert(started.After(time.Now().Add(-timeout*2)), Equals, true)
}
Example #21
0
func (MongoPlugin) Perform(req *api.StatusRequest, ch chan bool) {
	url := req.Address + ":" + req.Port

	if req.Verbose {
		log.Printf("Connecting to MongoDB (%s) \n", url)
	}
	session, err := mgo.DialWithTimeout(url, api.Timeout)
	if err != nil {
		ch <- false
		return
	}
	session.SetMode(mgo.Monotonic, true)
	defer session.Close()

	// Use 'test' database by default. If you want to specify another
	// database, then pass it as an argument to the 'status' command
	//
	database := "test"
	if len(req.Args) > 1 {
		database = req.Args[1]
	}

	// Execute 'db.stats' command on selected database
	//
	retval := &bson.M{}
	if err := session.DB(database).Run("dbStats", &retval); err != nil {
		if req.Verbose {
			log.Printf("Failed to query MongoDB: %s\n", err)
		}
		ch <- false
		return
	}

	if (*retval)["ok"] != 1 {
		ch <- true
	} else {
		if req.Verbose {
			log.Printf("The database is not ready yet: %q", *retval)
		}
		ch <- false
	}
}
Example #22
0
func (s *S) TestSocketTimeoutOnDial(c *C) {
	if *fast {
		c.Skip("-fast")
	}

	timeout := 1 * time.Second

	defer mgo.HackSyncSocketTimeout(timeout)()

	s.Freeze("localhost:40001")

	started := time.Now()

	session, err := mgo.DialWithTimeout("localhost:40001", timeout)
	c.Assert(err, ErrorMatches, "no reachable servers")
	c.Assert(session, IsNil)

	c.Assert(started.Before(time.Now().Add(-timeout)), Equals, true)
	c.Assert(started.After(time.Now().Add(-20*time.Second)), Equals, true)
}
Example #23
0
File: mongo.go Project: pkar/pfftdb
// Connect establishes a database connection.
func (m *Mongo) Connect(hosts string) {
	log.Infof("connecting session to hosts:%s", hosts)

	for {
		session, err := mgo.DialWithTimeout(m.Hosts, 10*time.Second)
		if err != nil {
			log.Error(err)
			time.Sleep(time.Second)
			continue
		}
		session.SetMode(mgo.Strong, true)
		//mgo.SetDebug(true)
		//mgo.SetLogger(lg.New(os.Stderr, "", lg.LstdFlags))
		session.SetSocketTimeout(120 * time.Second)

		m.Session = session

		go m.Pinger()
		return
	}
}
Example #24
0
func main() {
	flag.Parse()
	config, err := ConfigOpen(*configPath)
	if err != nil {
		log.Fatalln(err)
	}

	mgoDatabase = config.Mongo.DB

	// Set session timeout to fail early and avoid long response times.
	mgoSession, err = mgo.DialWithTimeout(config.Mongo.URL, 5*time.Second)
	if err != nil {
		log.Fatalln("[MongoDB]", err)
	}
	defer mgoSession.Close()

	addr := fmt.Sprintf("%s:%d", config.Http.Host, config.Http.Port)
	log.Printf("serving at %s\n", addr)
	err = http.ListenAndServe(addr, APIHandler())
	if err != nil {
		log.Fatal(err)
	}
}
Example #25
0
func (this *Client) dial(uri string) (*mgo.Session, error) {
	if this.breakers[uri].Open() {
		return nil, ErrCircuitOpen
	}

	this.throttleConns[uri] <- true
	defer func() {
		// release throttle
		<-this.throttleConns[uri]
	}()

	sess, err := mgo.DialWithTimeout(uri, this.conf.ConnectTimeout)
	if err != nil {
		this.breakers[uri].Fail()
		return nil, err
	}

	this.breakers[uri].Succeed()
	sess.SetSocketTimeout(this.conf.IoTimeout)
	sess.SetMode(mgo.Monotonic, true)

	return sess, nil
}
Example #26
0
func (s *Server) Run() {
	//initialize mongoclient
	timeout := time.Duration(s.cfg.Db.ConnTimeout) * time.Second
	s.mclient, _ = mgo.DialWithTimeout(s.cfg.Db.Connstr, timeout)
	//TODO add logger
}
Example #27
0
func main() {
	if *numCpu > 0 {
		runtime.GOMAXPROCS(*numCpu)
	} else {
		runtime.GOMAXPROCS(runtime.NumCPU())
	}
	flag.Parse()
	log.SetFlags(log.Lshortfile | log.LstdFlags)

	// Enable http server for debug endpoint
	go func() {
		if *debugAddr != "" {
			log.Println(http.ListenAndServe(*debugAddr, nil))
		}
	}()

	interrupt := make(chan os.Signal)
	signal.Notify(interrupt, os.Interrupt, syscall.SIGTERM)

	mgoSession, err := mgo.DialWithTimeout(*mongoServer+"?connect=direct", time.Duration(*mongoTimeout)*time.Minute)
	if err != nil {
		log.Fatal(err)
	}
	defer mgoSession.Close()
	mongoc := make(chan *mongodb.Operation)
	mongoErr := make(chan error)
	exit := make(chan bool)
	go func() {
		mongoErr <- mongodb.Tail(mgoSession, *ns, *mongoInitial, lastEsSeen, mongoc, exit)
	}()

	esc := make(chan elasticsearch.Transaction)
	esDone := make(chan bool)
	go func() {
		// Boot up our slurpers.
		// The client will have the transport configured to allow the same amount of connections
		// as go routines towards ES, each connection may be re-used between slurpers.
		client := elasticsearch.NewClient(fmt.Sprintf("%s/_bulk", *esServer), *esConcurrency)
		var slurpers sync.WaitGroup
		slurpers.Add(*esConcurrency)
		for n := 0; n < *esConcurrency; n++ {
			go func() {
				elasticsearch.Slurp(client, esc)
				slurpers.Done()
			}()
		}
		slurpers.Wait()
		close(esDone)
	}()

	tailDone := make(chan bool)
	go func() {
		// Map mongo collections to es index
		indexes := map[string]string{
			strings.Split(*ns, ".")[0]: *esIndex,
		}
		for op := range mongoc {
			// Wrap all mongo operations to comply with ES interface, then send them off to the slurper.
			esOp := mongodb.NewEsOperation(indexes, nil, op)
			select {
			case esc <- esOp:
				lastEsSeenC <- &op.Timestamp
			// Abort delivering any pending EsOperations we might block for
			case <-exit:
				break
			}
		}
		// If mongoc closed, tailer has stopped
		close(tailDone)
	}()

	select {
	//  Get more operations from mongo tail
	case <-tailDone:
		log.Println("MongoDB tailer returned")
	// ES client closed
	case <-esDone:
		log.Println("ES slurper returned")
	// An interrupt signal was catched
	case <-interrupt:
		log.Println("Closing down...")
	}
	close(exit)

	// MongoDB tailer shutdown
	if err := <-mongoErr; err != nil {
		log.Println(err)
	} else {
		log.Println("No errors occured in mongo tail")
	}

	// Elasticsearch indexer shutdown
	log.Println("Waiting for EsOperation tail to stop")
	<-tailDone

	log.Println("Waiting for ES to return")
	// We are the producer for this channel, close it down and wait for ES slurpers to return
	close(esc)
	<-esDone
	log.Println("Bye!")
}