Пример #1
0
// FindStation retrieves the specified station
func FindStation(service *services.Service, stationId string) (buoyStation *buoyModels.BuoyStation, err error) {
	defer helper.CatchPanic(&err, service.UserId, "FindStation")

	tracelog.STARTED(service.UserId, "FindStation")

	queryMap := bson.M{"station_id": stationId}

	buoyStation = &buoyModels.BuoyStation{}
	err = service.DBAction(Config.Database, "buoy_stations",
		func(collection *mgo.Collection) error {
			tracelog.TRACE(service.UserId, "FindStation", "Query : %s", mongo.ToString(queryMap))
			return collection.Find(queryMap).One(buoyStation)
		})

	if err != nil {
		if strings.Contains(err.Error(), "not found") == false {
			tracelog.COMPLETED_ERROR(err, service.UserId, "FindStation")
			return buoyStation, err
		}

		err = nil
	}

	tracelog.COMPLETED(service.UserId, "FindStation")
	return buoyStation, err
}
Пример #2
0
// TestInvalidStation is a sample to run an endpoint test that returns
// an empty result set
func TestInvalidStation(t *testing.T) {
	r, _ := http.NewRequest("GET", "/buoy/station/000000", nil)
	w := httptest.NewRecorder()
	beego.BeeApp.Handlers.ServeHTTP(w, r)

	tracelog.TRACE("testing", "TestStation", "Code[%d]\n%s", w.Code, w.Body.String())

	response := struct {
		StationId string `json:"station_id"`
		Name      string `json:"name"`
		LocDesc   string `json:"location_desc"`
		Condition struct {
			Type        string    `json:"type"`
			Coordinates []float64 `json:"coordinates"`
		} `json:"condition"`
		Location struct {
			WindSpeed     float64 `json:"wind_speed_milehour"`
			WindDirection int     `json:"wind_direction_degnorth"`
			WindGust      float64 `json:"gust_wind_speed_milehour"`
		} `json:"location"`
	}{}
	json.Unmarshal(w.Body.Bytes(), &response)

	Convey("Subject: Test Station Endpoint\n", t, func() {
		Convey("Status Code Should Be 200", func() {
			So(w.Code, ShouldEqual, 200)
		})
		Convey("The Result Should Not Be Empty", func() {
			So(w.Body.Len(), ShouldBeGreaterThan, 0)
		})
		Convey("The Result Should Be Empty For Station 00000", func() {
			So(response.StationId, ShouldBeBlank)
		})
	})
}
Пример #3
0
// LogModel writes a specified model object into the logs
// as a formatted JSON document
func LogModel(obj interface{}, useTrace bool) {
	bArray, _ := json.MarshalIndent(obj, "", "    ")

	if useTrace {
		tracelog.TRACE("utils", "LogModel", "Obj => \n\n%s\n\n", string(bArray))
	} else {
		tracelog.INFO("utils", "LogModel", "Obj => \n\n%s\n\n", string(bArray))
	}
}
Пример #4
0
// SignedHash generates a Signed SHA256 Hash
func SignedHash(message string, keyToSign string) []byte {
	if keyToSign == "" {
		tracelog.TRACE("go-common/crypto", "SignedHash", "KeyString is Blank")
		keyToSign = key
	}

	h := hmac.New(sha256.New, []byte(keyToSign))
	h.Write([]byte(message))
	return h.Sum(nil)
}
Пример #5
0
// Startup brings the manager to a running state
func Startup(sessionId string) (err error) {
	defer helper.CatchPanic(&err, sessionId, "Startup")

	// If the system has already been started ignore the call
	if _This != nil {
		return err
	}

	tracelog.STARTED(sessionId, "Startup")

	// Pull in the configuration
	config := mongoConfiguration{}
	err = envconfig.Process("mgo", &config)
	if err != nil {
		tracelog.COMPLETED_ERROR(err, sessionId, "Startup")
		return err
	}

	// Create the Mongo Manager
	_This = &mongoManager{
		sessions: map[string]*mongoSession{},
	}

	// Log the mongodb connection straps
	tracelog.TRACE(sessionId, "Startup", "MongoDB : Hosts[%s]", config.Hosts)
	tracelog.TRACE(sessionId, "Startup", "MongoDB : Database[%s]", config.Database)
	tracelog.TRACE(sessionId, "Startup", "MongoDB : Username[%s]", config.UserName)

	hosts := strings.Split(config.Hosts, ",")

	// Create the strong and monotonic sessions
	err = CreateSession(sessionId, "strong", MASTER_SESSION, hosts, config.Database, config.UserName, config.Password)
	err = CreateSession(sessionId, "monotonic", MONOTONIC_SESSION, hosts, config.Database, config.UserName, config.Password)

	tracelog.COMPLETED(sessionId, "Startup")
	return err
}
Пример #6
0
func Prepare() *services.Service {
	service := &services.Service{}

	// TODO: Add Test User To Environment
	service.UserId = "testing"

	err := service.Prepare()
	if err != nil {
		tracelog.ERROR(err, service.UserId, "Prepare")
		return nil
	}

	tracelog.TRACE(service.UserId, "Before", "UserId[%s]", service.UserId)
	return service
}
Пример #7
0
// Prepare is called create a service object
func Prepare() *services.Service {
	service := &services.Service{}

	service.UserId = "testing" // TODO: Deal With This Later
	tracelog.TRACE(service.UserId, "Before", "UserId[%s]", service.UserId)

	var err error
	service.MongoSession, err = mongo.CopyMonotonicSession(service.UserId)
	if err != nil {
		tracelog.ERROR(err, service.UserId, "Before")
		return nil
	}

	return service
}
Пример #8
0
// Prepare is called prior to the baseController method
func (baseController *BaseController) Prepare() {
	baseController.UserId = baseController.GetString("userId")
	if baseController.UserId == "" {
		baseController.UserId = baseController.GetString(":userId")
	}
	if baseController.UserId == "" {
		baseController.UserId = "Unknown"
	}

	err := baseController.Service.Prepare()
	if err != nil {
		tracelog.ERRORf(err, baseController.UserId, "BaseController.Prepare", baseController.Ctx.Request.URL.Path)
		baseController.ServeError(err)
		return
	}

	tracelog.TRACE(baseController.UserId, "BaseController.Prepare", "UserId[%s] Path[%s]", baseController.UserId, baseController.Ctx.Request.URL.Path)
}
Пример #9
0
// Prepare is called prior to the controller method
func (this *BaseController) Prepare() {
	this.UserId = this.GetString("userId")
	if this.UserId == "" {
		this.UserId = this.GetString(":userId")
	}
	if this.UserId == "" {
		this.UserId = "Unknown"
	}

	err := this.Service.Prepare()
	if err != nil {
		tracelog.ERRORf(err, this.UserId, "BaseController.Prepare", this.Ctx.Request.URL.Path)
		this.ServeError(err)
		return
	}

	tracelog.TRACE(this.UserId, "BaseController.Prepare", "UserId[%s] Path[%s]", this.UserId, this.Ctx.Request.URL.Path)
}
Пример #10
0
// FindRegion retrieves the stations for the specified region
func FindRegion(service *services.Service, region string) (buoyStations []*buoyModels.BuoyStation, err error) {
	defer helper.CatchPanic(&err, service.UserId, "FindRegion")

	tracelog.STARTED(service.UserId, "FindRegion")

	queryMap := bson.M{"region": region}
	tracelog.TRACE(service.UserId, "FindRegion", "Query : %s", mongo.ToString(queryMap))

	buoyStations = []*buoyModels.BuoyStation{}
	err = service.DBAction(Config.Database, "buoy_stations",
		func(collection *mgo.Collection) error {
			return collection.Find(queryMap).All(&buoyStations)
		})

	if err != nil {
		tracelog.COMPLETED_ERROR(err, service.UserId, "FindRegion")
		return buoyStations, err
	}

	tracelog.COMPLETED(service.UserId, "FindRegion")
	return buoyStations, err
}
Пример #11
0
// TestRegion is a sample to run an endpoint test
func TestRegion(t *testing.T) {
	r, _ := http.NewRequest("GET", "/region/Gulf%20Of%20Mexico", nil)
	w := httptest.NewRecorder()
	beego.BeeApp.Handlers.ServeHTTP(w, r)

	tracelog.TRACE("testing", "TestRegion", "Code[%d]\n%s", w.Code, w.Body.String())

	err := struct {
		Error string
	}{}
	json.Unmarshal(w.Body.Bytes(), &err)

	Convey("Subject: Test Region Endpoint\n", t, func() {
		Convey("Status Code Should Be 200", func() {
			So(w.Code, ShouldEqual, 200)
		})
		Convey("The Result Should Not Be Empty", func() {
			So(w.Body.Len(), ShouldBeGreaterThan, 0)
		})
		Convey("The Should Be No Error In The Result", func() {
			So(len(err.Error), ShouldEqual, 0)
		})
	})
}
Пример #12
0
// FindStation retrieves the specified station
func FindStation(service *services.Service, stationId string) (buoyStation *buoyModels.BuoyStation, err error) {
	defer helper.CatchPanic(&err, service.UserId, "FindStation")

	tracelog.STARTED(service.UserId, "FindStation")

	// Find the specified station id
	queryMap := bson.M{"station_id": stationId}
	tracelog.TRACE(service.UserId, "FindStation", "Query : %s", mongo.ToString(queryMap))

	// Execute the query
	buoyStation = &buoyModels.BuoyStation{}
	err = service.DBAction(Config.Database, "buoy_stations",
		func(collection *mgo.Collection) error {
			return collection.Find(queryMap).One(buoyStation)
		})

	if err != nil {
		tracelog.COMPLETED_ERROR(err, service.UserId, "FindStation")
		return buoyStation, err
	}

	tracelog.COMPLETED(service.UserId, "FindStation")
	return buoyStation, err
}
Пример #13
0
// TestInvalidStation is a sample to run an endpoint test that returns
// an empty result set
func TestMissingStation(t *testing.T) {
	r, _ := http.NewRequest("GET", "/buoy/station/420", nil)
	w := httptest.NewRecorder()
	beego.BeeApp.Handlers.ServeHTTP(w, r)

	tracelog.TRACE("testing", "TestStation", "Code[%d]\n%s", w.Code, w.Body.String())

	err := struct {
		Errors []string `json:"errors"`
	}{}
	json.Unmarshal(w.Body.Bytes(), &err)

	Convey("Subject: Test Station Endpoint\n", t, func() {
		Convey("Status Code Should Be 409", func() {
			So(w.Code, ShouldEqual, 409)
		})
		Convey("The Result Should Not Be Empty", func() {
			So(w.Body.Len(), ShouldBeGreaterThan, 0)
		})
		Convey("The Should Be An Error In The Result", func() {
			So(len(err.Errors), ShouldEqual, 1)
		})
	})
}