//Fetch Bucket from the config service
func (this *HttpClient) GetBucket(name string, version int) (*Bucket, error) {
// fetch data
resp, err := this.get(name, version, false, INITIAL_VERSION)
if err != nil {
log.Println("Error fetching bucket ", err.Error())
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
errResp := &ErrorResp{}
err := ffjson.NewDecoder().DecodeReader(resp.Body, errResp)
if err != nil {
log.Println("Error reading the response Body")
}
log.Println("Error fetching bucket: ", errResp)
return nil, errors.New(errResp.Error())
}
// create and return bucket
bucket, err := this.newBucket(resp)
if err != nil {
log.Println("Error creating bucket ", err.Error())
return nil, err
}
return bucket, nil
}
func isBucketDeleted(resp *http.Response) bool {
errResp := &ErrorResp{}
if resp.StatusCode == 404 {
err := ffjson.NewDecoder().DecodeReader(resp.Body, errResp)
if err != nil {
log.Println("Error reading data", err)
}
log.Println("Error", errResp)
return true
}
return false
}
// newBucket creates a bucket from JSON data
func (this *HttpClient) newBucket(resp *http.Response) (*Bucket, error) {
log.Println("Extracting keys from the response body")
bucket := &Bucket{}
err := ffjson.NewDecoder().DecodeReader(resp.Body, bucket)
if err != nil {
return nil, errors.New("Error decoding JSON")
}
log.Println("Fetched bucket ", bucket)
// fetch and decode keys
return bucket, nil
}
func (this *WatchAsync) handleInvalidBucket(resp *http.Response) {
asyncResp := this.asyncResp
errResp := &ErrorResp{}
err := ffjson.NewDecoder().DecodeReader(resp.Body, errResp)
if err != nil {
asyncResp <- &BucketResponse{bucket: nil, err: errors.New("Error decoding to JSON"), statusCode: INTERNAL_ERROR}
} else {
log.Println("Error parsing bucket from watch", errResp)
if errResp.ErrorType == DELETED {
asyncResp <- &BucketResponse{bucket: nil, err: errResp, statusCode: BUCKET_NOT_FOUND}
} else {
asyncResp <- &BucketResponse{bucket: nil, err: errResp, statusCode: INTERNAL_ERROR}
}
}
}
EventPlayerLogin
EventPlayerLogout
)
// EventStream is an abstraction for the Planetside 2 streaming data API
// instead of using a raw websocket connection you can just use channels.
type EventStream struct {
parent *Census
conn *websocket.Conn
Err chan error
Events chan Event
Closed chan struct{}
}
// GlobalDecoder exists so we don't allocate a new decoder every response
var GlobalDecoder = ffjson.NewDecoder()
// Event is an event from the Planetside real time event streaming API.
// @TODO: Add the rest of the fields. They're all in the documentation
type Event struct {
Payload EventPayload
Service string `json:"service"`
Type string `json:"type"`
}
type EventPayload struct {
EventName string `json:"event_name"`
Time string `json:"timestamp"`
CharacterID string `json:"character_id"`
WorldID string `json:"world_id"`
}
