func (self *CoordinatorImpl) WriteSeriesData(user common.User, db string, series []*protocol.Series) error {
// make sure that the db exist
if !self.clusterConfiguration.DatabasesExists(db) {
return fmt.Errorf("Database %s doesn't exist", db)
}
for _, s := range series {
seriesName := s.GetName()
if user.HasWriteAccess(seriesName) {
continue
}
return common.NewAuthorizationError("User %s doesn't have write permissions for %s", user.GetName(), seriesName)
}
err := self.CommitSeriesData(db, series, false)
if err != nil {
return err
}
for _, s := range series {
self.ProcessContinuousQueries(db, s)
}
return err
}
func (self *Permissions) AuthorizeDropSeries(user common.User, db string, seriesName string) (ok bool, err common.AuthorizationError) {
if !user.IsDbAdmin(db) && !user.HasWriteAccess(seriesName) {
return false, common.NewAuthorizationError("Insufficient permissions to drop series")
}
return true, ""
}
func (self *CoordinatorImpl) WriteSeriesData(user common.User, db string, series *protocol.Series) error {
if !user.HasWriteAccess(db) {
return common.NewAuthorizationError("Insufficient permission to write to %s", db)
}
if len(series.Points) == 0 {
return fmt.Errorf("Can't write series with zero points.")
}
err := self.CommitSeriesData(db, series)
self.ProcessContinuousQueries(db, series)
return err
}
func (self *CoordinatorImpl) WriteSeriesData(user common.User, db string, series []*protocol.Series) error {
if !user.HasWriteAccess(db) {
return common.NewAuthorizationError("Insufficient permissions to write to %s", db)
}
err := self.CommitSeriesData(db, series, false)
if err != nil {
return err
}
for _, s := range series {
self.ProcessContinuousQueries(db, s)
}
return err
}
func (self *CoordinatorImpl) DropSeries(user common.User, db, series string) error {
if !user.IsClusterAdmin() && !user.IsDbAdmin(db) && !user.HasWriteAccess(series) {
return common.NewAuthorizationError("Insufficient permission to drop series")
}
if self.clusterConfiguration.IsSingleServer() {
return self.datastore.DropSeries(db, series)
}
servers, _ := self.clusterConfiguration.GetServersToMakeQueryTo(&db)
for _, server := range servers {
if err := self.handleDropSeries(server.server, db, series); err != nil {
return err
}
}
return nil
}
func (self *LevelDbDatastore) DeleteRangeOfRegex(user common.User, database string, regex *regexp.Regexp, startTime, endTime time.Time) error {
series := self.getSeriesForDbAndRegex(database, regex)
hasAccess := true
for _, name := range series {
if !user.HasWriteAccess(name) {
hasAccess = false
continue
}
err := self.DeleteRangeOfSeries(database, name, startTime, endTime)
if err != nil {
return err
}
}
if !hasAccess {
return fmt.Errorf("You don't have access to delete from one or more time series")
}
return nil
}
func (self *CoordinatorImpl) WriteSeriesData(user common.User, db string, series []*protocol.Series) error {
for _, s := range series {
seriesName := s.GetName()
if user.HasWriteAccess(seriesName) {
continue
}
return common.NewAuthorizationError("User %s doesn't have write permissions for %s", user.GetName(), seriesName)
}
err := self.CommitSeriesData(db, series, false)
if err != nil {
return err
}
for _, s := range series {
self.ProcessContinuousQueries(db, s)
}
return err
}
func (self *CoordinatorImpl) WriteSeriesData(user common.User, db string, series *protocol.Series) error {
if !user.HasWriteAccess(db) {
return fmt.Errorf("Insufficient permission to write to %s", db)
}
now := common.CurrentTime()
for _, p := range series.Points {
if p.Timestamp == nil {
p.Timestamp = &now
self.sequenceNumberLock.Lock()
self.currentSequenceNumber += 1
n := self.currentSequenceNumber
self.sequenceNumberLock.Unlock()
p.SequenceNumber = &n
} else if p.SequenceNumber == nil {
self.sequenceNumberLock.Lock()
self.currentSequenceNumber += 1
n := self.currentSequenceNumber
self.sequenceNumberLock.Unlock()
p.SequenceNumber = &n
}
}
return self.datastore.WriteSeriesData(db, series)
}
func (self *CoordinatorImpl) WriteSeriesData(user common.User, db string, series *protocol.Series) error {
if !user.HasWriteAccess(db) {
return common.NewAuthorizationError("Insufficient permission to write to %s", db)
}
if len(series.Points) == 0 {
return fmt.Errorf("Can't write series with zero points.")
}
// break the series object into separate ones based on their ring location
// if times server assigned, all the points will go to the same place
serverAssignedTime := true
now := common.CurrentTime()
// assign sequence numbers
lastNumber, err := self.datastore.AtomicIncrement(POINT_SEQUENCE_NUMBER_KEY, len(series.Points))
if err != nil {
return err
}
lastNumber = lastNumber - uint64(len(series.Points)-1)
for _, p := range series.Points {
if p.Timestamp == nil {
p.Timestamp = &now
} else {
serverAssignedTime = false
}
if p.SequenceNumber == nil {
n := self.sequenceNumberWithServerId(lastNumber)
lastNumber++
p.SequenceNumber = &n
}
}
// if it's a single server setup, we don't need to bother with getting ring
// locations or logging requests or any of that, so just write to the local db and be done.
if self.clusterConfiguration.IsSingleServer() {
err := self.writeSeriesToLocalStore(&db, series)
return err
}
if serverAssignedTime {
location := common.RingLocation(&db, series.Name, series.Points[0].Timestamp)
i := self.clusterConfiguration.GetServerIndexByLocation(&location)
return self.handleClusterWrite(&i, &db, series)
}
// TODO: make this more efficient and not suck so much
// not all the same, so break things up
seriesToServerIndex := make(map[int]*protocol.Series)
for _, p := range series.Points {
location := common.RingLocation(&db, series.Name, p.Timestamp)
i := self.clusterConfiguration.GetServerIndexByLocation(&location)
s := seriesToServerIndex[i]
if s == nil {
s = &protocol.Series{Name: series.Name, Fields: series.Fields, Points: make([]*protocol.Point, 0)}
seriesToServerIndex[i] = s
}
s.Points = append(s.Points, p)
}
for serverIndex, s := range seriesToServerIndex {
err := self.handleClusterWrite(&serverIndex, &db, s)
if err != nil {
return err
}
}
return nil
}