// CreateSession creates a connection pool for use
func CreateSession(sessionId string, mode string, sessionName string, hosts []string, databaseName string, username string, password string) (err error) {
defer helper.CatchPanic(nil, sessionId, "CreateSession")
tracelog.STARTEDf(sessionId, "CreateSession", "Mode[%s] SessionName[%s] Hosts[%s] DatabaseName[%s] Username[%s]", mode, sessionName, hosts, databaseName, username)
// Create the database object
mongoSession := &mongoSession{
mongoDBDialInfo: &mgo.DialInfo{
Addrs: hosts,
Timeout: 60 * time.Second,
Database: databaseName,
Username: username,
Password: password,
},
}
// Establish the master session
mongoSession.mongoSession, err = mgo.DialWithInfo(mongoSession.mongoDBDialInfo)
if err != nil {
tracelog.COMPLETED_ERROR(err, sessionId, "CreateSession")
return err
}
switch mode {
case "strong":
// Reads and writes will always be made to the master server using a
// unique connection so that reads and writes are fully consistent,
// ordered, and observing the most up-to-date data.
// http://godoc.org/labix.org/v2/mgo#Session.SetMode
mongoSession.mongoSession.SetMode(mgo.Strong, true)
break
case "monotonic":
// Reads may not be entirely up-to-date, but they will always see the
// history of changes moving forward, the data read will be consistent
// across sequential queries in the same session, and modifications made
// within the session will be observed in following queries (read-your-writes).
// http://godoc.org/labix.org/v2/mgo#Session.SetMode
mongoSession.mongoSession.SetMode(mgo.Monotonic, true)
}
// Have the session check for errors
// http://godoc.org/labix.org/v2/mgo#Session.SetSafe
mongoSession.mongoSession.SetSafe(&mgo.Safe{})
// Add the database to the map
_This.sessions[sessionName] = mongoSession
tracelog.COMPLETED(sessionId, "CreateSession")
return err
}
// Region handles the higher level business processing for this API Call
func Region(controller *bc.BaseController, region string) {
defer bc.CatchPanic(controller, "Region")
tracelog.STARTEDf(controller.UserId, "Region", "Region[%s]", region)
buoyStations, err := buoyService.FindRegion(&controller.Service, region)
if err != nil {
tracelog.COMPLETED_ERRORf(err, controller.UserId, "Region", "Region[%s]", region)
controller.ServeError(err)
return
}
controller.Data["json"] = &buoyStations
controller.ServeJson()
tracelog.COMPLETED(controller.UserId, "Region")
}
// Station handles the higher level business processing for this API Call
func Station(controller *bc.BaseController, stationId string) {
defer bc.CatchPanic(controller, "Station")
tracelog.STARTEDf(controller.UserId, "Station", "StationId[%s]", stationId)
buoyStation, err := buoyService.FindStation(&controller.Service, stationId)
if err != nil {
tracelog.COMPLETED_ERRORf(err, controller.UserId, "Station", "StationId[%s]", stationId)
controller.ServeError(err)
return
}
controller.Data["json"] = &buoyStation
controller.ServeJson()
tracelog.COMPLETED(controller.UserId, "Station")
}
// Init initializes the local environment
func Init(defaultLocale string) error {
tracelog.STARTEDf("localize", "Init", "DefaultLocal[%s]", defaultLocale)
switch defaultLocale {
default:
LoadJSON(defaultLocale, loc.En_US)
}
// Obtain the default translation function for use
var err error
T, err = NewTranslation(defaultLocale)
if err != nil {
return err
}
tracelog.COMPLETED("localize", "Init")
return nil
}
// Index is the initial view for the buoy system
func (controller *BuoyController) Index() {
region := "Gulf Of Mexico"
tracelog.STARTEDf(controller.UserId, "BuoyController.Index", "Region[%s]", region)
buoyStations, err := buoyService.FindRegion(&controller.Service, region)
if err != nil {
tracelog.COMPLETED_ERRORf(err, controller.UserId, "BuoyController.Index", "Region[%s]", region)
controller.ServeError(err)
return
}
controller.Data["Stations"] = buoyStations
controller.Layout = "shared/basic-layout.html"
controller.TplNames = "buoy/content.html"
controller.LayoutSections = map[string]string{}
controller.LayoutSections["PageHead"] = "buoy/page-head.html"
controller.LayoutSections["Header"] = "shared/header.html"
controller.LayoutSections["Modal"] = "shared/modal.html"
}
// Init initializes the local environment
func Init(defaultLocale string) error {
tracelog.STARTEDf("localize", "Init", "DefaultLocal[%s]", defaultLocale)
switch defaultLocale {
case "en-US":
LoadJSON(defaultLocale, En_US)
default:
return fmt.Errorf("Unsupported Locale: %s", defaultLocale)
}
// Obtain the default translation function for use
var err error
T, err = NewTranslation(defaultLocale, defaultLocale)
if err != nil {
return err
}
tracelog.COMPLETED("localize", "Init")
return nil
}
// CopySession makes a clone of the specified session for client use
func CloneSession(sessionId string, useSession string) (mongoSession *mgo.Session, err error) {
defer helper.CatchPanic(nil, sessionId, "CopySession")
tracelog.STARTEDf(sessionId, "CloneSession", "UseSession[%s]", useSession)
// Find the session object
session := _This.sessions[useSession]
if session == nil {
err = fmt.Errorf("Unable To Locate Session %s", useSession)
tracelog.COMPLETED_ERROR(err, sessionId, "CloneSession")
return mongoSession, err
}
// Clone the master session
mongoSession = session.mongoSession.Clone()
tracelog.COMPLETED(sessionId, "CloneSession")
return mongoSession, err
}
// Execute the MongoDB literal function
func Execute(sessionId string, mongoSession *mgo.Session, databaseName string, collectionName string, mongoCall MongoCall) (err error) {
tracelog.STARTEDf(sessionId, "Execute", "Database[%s] Collection[%s]", databaseName, collectionName)
// Capture the specified collection
collection, err := GetCollection(mongoSession, databaseName, collectionName)
if err != nil {
tracelog.COMPLETED_ERROR(err, sessionId, "Execute")
return err
}
// Execute the mongo call
err = mongoCall(collection)
if err != nil {
tracelog.COMPLETED_ERROR(err, sessionId, "Execute")
return err
}
tracelog.COMPLETED(sessionId, "Execute")
return err
}
// LoadJSON takes a json document of translations and manually
// loads them into the system
func LoadJSON(userLocale string, translationDocument string) error {
tracelog.STARTEDf("localize", "LoadJSON", "UserLocale[%s] Length[%d]", userLocale, len(translationDocument))
tranDocuments := []map[string]interface{}{}
err := json.Unmarshal([]byte(translationDocument), &tranDocuments)
if err != nil {
tracelog.COMPLETED_ERRORf(err, "localize", "LoadJSON", "**************>")
return err
}
for _, tranDocument := range tranDocuments {
tran, err := translation.NewTranslation(tranDocument)
if err != nil {
tracelog.COMPLETED_ERROR(err, "localize", "LoadJSON")
return err
}
i18n.AddTranslation(locale.MustNew(userLocale), tran)
}
tracelog.COMPLETED("localize", "LoadJSON")
return nil
}