func (self *dispatcherimpl) Perform(context *ares.Context, operation ares.Operation) (ret ares.Return) { if context == nil { context = new(ares.Context) } if context.Level > contextLevelMaximum { return &operations.GenericReturn{retcode.NewStatusError(retcode.ErrorClient, errors.New(fmt.Sprintf("Maximum level is %v - reconfigure buckets", contextLevelMaximum)))} } switch operation := operation.(type) { case *operations.Forwarded: // Is forwarded return self.perform_BucketOperation(context, operation.Original, operation.BucketId) case operations.HasTargetBucketId: // If it has a target bucket id, send it to that bucket. return self.perform_BucketOperation(context, operation, operation.TargetBucketId()) case *operations.CreateBucket: return self.perform_OpCreateBucket(context, operation) default: return &operations.GenericReturn{retcode.NewStatusError(retcode.ErrorClient, errors.New(fmt.Sprintf("Unknown operation: %T, %v", operation, operation)))} } }
func (self *notifier) createInstance(state *minos.OperationState) ( instance *notifierInstance, ret retcode.Status) { var err error keysBucketId, exists, err := state.MetadataGetterSetter.Forwarder( true, metadataKey_keys) if err != nil || !exists { return nil, retcode.NewStatusError( retcode.ErrorServer, errors.New("Could not get forwarder metadata (keys)")) } registrationsBucketId, exists, err := state.MetadataGetterSetter.Forwarder( true, metadataKey_registrations) if err != nil || !exists { return nil, retcode.NewStatusError( retcode.ErrorServer, errors.New("Could not get forwarder metadata (keys)")) } ni := new(notifierInstance) ni.base = self ni.keysBucketId = keysBucketId ni.registrationsBucketId = registrationsBucketId return ni, retcode.NewStatusOk() }
func (self *blobstorePrototype) createInstance(state *minos.OperationState) ( instance *blobstoreStruct, ret retcode.Status) { var err error backendId, exists, err := state.MetadataGetterSetter.Forwarder( true, metadataKey_backend) if err != nil { return nil, retcode.NewStatusError( retcode.ErrorServer, errors.New("Could not get forwarder metadata (backend)")) } if !exists { return nil, retcode.NewStatusError( retcode.ErrorServer, errors.New("Backend bucket id not found in metadata")) } ni := new(blobstoreStruct) ni.incubator = new(incubator) ni.incubator.bucketId = backendId ni.public = new(public) ni.public.bucketId = backendId ni.public.incubator = ni.incubator return ni, retcode.NewStatusOk() }
func (self *Store) Op_put(operation *operations.Put) (ret bucket.BucketReturn) { leveldb, err := self.Database() if err != nil { return &bucket.ReturnGeneric{retcode.NewStatusError(retcode.ErrorServer, err)} } keyBytes := self.KeyToBytesAndPrefix(operation.Key) // Success, now forward that thing (forwarding never fails) if self.State.PutForwarder != nil && !self.DoNotPutForward { self.State.PutForwarder.ForwardIfOk(operation) } var returnValue *operations.PutReturn if operation.Value != nil { valueBytes := operation.Value.Serialize() //fmt.Printf("PUT: %v\n", keyBytes) err = leveldb.Put(keyBytes, valueBytes, nil /*TODO*/) if err != nil { return &bucket.ReturnGeneric{retcode.NewStatusError(retcode.ErrorServer, err)} } returnValue = &operations.PutReturn{retcode.NewStatusOk()} } else { // Remove operation err = leveldb.Delete(keyBytes, nil) if err != nil { return &bucket.ReturnGeneric{retcode.NewStatusError(retcode.ErrorServer, err)} } returnValue = &operations.PutReturn{retcode.NewStatus(retcode.OkRemove)} } return returnValue }
func (self *directoryBucket) createInstance(state *minos.OperationState) ( instance *directoryBucketInstance, ret retcode.Status) { var err error backendId, exists, err := state.MetadataGetterSetter.Forwarder( true, forwarder_name) if err != nil { return nil, retcode.NewStatusError( retcode.ErrorServer, errors.New("Could not get forwarder metadata (backend)")) } if !exists { return nil, retcode.NewStatusError( retcode.ErrorServer, errors.New("Backend bucket id not found in metadata")) } cstore := &commonstore.Store{ DbTypeName: levelDbTypeName, DatabaseProvider: self.database, State: state, DoNotPutForward: true, } ni := new(directoryBucketInstance) ni.base = self ni.cstore = cstore ni.backendId = backendId return ni, retcode.NewStatusOk() }
func (self *dispatcherimpl) perform_BucketOperation(context *ares.Context, operation ares.Operation, targetBucketId bucket.Id) ( ret ares.Return) { bucketId := targetBucketId if bucketId == nil || len(bucketId) == 0 { return &operations.GenericReturn{retcode.NewStatusError(retcode.ErrorClient, errors.New("Bucket ID is missing or invalid"))} } bucketType := self.typesRegistry.BucketType(bucketId.TypeId()) if bucketType == nil { return &operations.GenericReturn{retcode.NewStatusError(retcode.ErrorClient, errors.New(fmt.Sprintf("BucketType %v not found", bucketId.TypeId())))} } var err error // Special case for metadata if bucketId.IsMetadata() { // Extract and supply the original bucket ID to the metadata bucketId = bucketId.ExtractOriginalId() } metadataReader, err := self.metadata.TypedGetterSetter(bucketId) if err != nil { return &operations.GenericReturn{ retcode.NewStatusError(retcode.ErrorBucketIdNotFound, err)} } state := new(minos.OperationState) state.Operation = operation state.BucketId = bucketId putfowarderVar := new(putfowarder) putfowarderVar.metadataReader = metadataReader putfowarderVar.putReceiversIds, err = metadataReader.PutReceivers() putfowarderVar.context = *context putfowarderVar.forwardFunction = self.Perform state.PutForwarder = putfowarderVar state.MetadataGetterSetter = metadataReader state.NotificationReceiver = self.receiveNotification state.Context = context state.Dispatcher = self state.Locker = self.lock state.Files = self.files state.BucketType = self.typesRegistry.BucketType bucketReturn := bucketType.Perform(state) putfowarderVar.maybeDoPutForward(bucketReturn) return bucketReturn }
func (self *Store) Op_iterate(operation *operations.Iterate) ( ret bucket.BucketReturn) { database, err := self.Database() if err != nil { ret = &bucket.ReturnGeneric{retcode.NewStatusError(retcode.ErrorServer, err)} return } r, err := self.createScanRangeForIterate(operation, self.State.BucketId) if err != nil { ret = &bucket.ReturnGeneric{retcode.NewStatusError(retcode.ErrorClient, err)} return } iterator := database.NewIterator(r, nil) defer iterator.Release() var exhausted bool exhausted = !iterator.First() resultNumber := 0 var numberOfErrors uint32 numberOfErrors = 0 for !exhausted { key, err := typescommon.PrefixedKeyBytesToKey( self.State.BucketId, iterator.Key()) if err != nil { numberOfErrors++ } else { value, err := types.NewArrayFromBytes(iterator.Value()) if err != nil { numberOfErrors++ } else { // Ok iterateState := new(operations.IterateState) iterateState.ResultNumber = uint32(resultNumber) iterateState.Key = key iterateState.Value = value end := operation.Function(iterateState) if end { break } } } resultNumber++ exhausted = iterator.Next() exhausted = !iterator.Valid() //TODO: Why do we need this too? } return &operations.IterateReturn{ Status: retcode.NewStatusOk(), NumberOfErrors: numberOfErrors, } }
func (self *dispatcherimpl) perform_OpCreateBucket(context *ares.Context, operation *operations.CreateBucket) ( ret ares.Return) { if context.UserId.IsPublicUser() { return &operations.GenericReturn{retcode.NewStatusError( retcode.ErrorNotAllowedForPublicUser, errors.New("Need to be authenticated"))} } /* Validate and create */ bucketType := self.typesRegistry.BucketType(operation.TypeId) if bucketType == nil { return &operations.GenericReturn{retcode.NewStatusError(retcode.ErrorClient, errors.New(fmt.Sprintf("BucketType %v not found", operation.TypeId)))} } if operation.TypeId.IsMetadata() { return &operations.GenericReturn{retcode.NewStatusError(retcode.ErrorClient, errors.New("You tried to create a metadata bucket (bucket type). That's "+ "not possible, since metadata buckets are only 'virtual' and cannot "+ "be created (convert a bucket ID to a metadata bucket ID to access its "+ "metadata)."))} } createdMetadata := operation.Metadata if createdMetadata == nil { createdMetadata = make(map[string]([]byte)) } createState := new(minos.CreateState) createState.TypeId = operation.TypeId createState.Metadata = self.metadata.NewMemoryTypedReaderWriter(createdMetadata) createState.Context = context createState.Dispatcher = self createState.Files = self.files status := bucketType.Create(createState) if !status.GetCode().IsOk() { return &operations.GenericReturn{status} } /* Now create the bucket */ bucketId, err := self.metadata.Create(operation.TypeId, createdMetadata, context.UserId) if err != nil { // TODO: Rollback what 'bucketType.Create' did return &operations.GenericReturn{retcode.NewStatusError(retcode.ErrorServer, err)} } // Done return &operations.CreateBucketReturn{bucketId, retcode.NewStatusOk()} }
func (self *incubator) appendDataWithoutCleanup(state *minos.OperationState, id string, data []byte) (ret retcode.Status) { // Make sure it exists (but do not remove existing) self.new(state, id, false) currentIncubationState, ret := self.information(state, id) if !ret.IsOk() { return } // Initialize the hash how we left it the last time hash := currentIncubationState.restoreHash() // Update the hash _, err := hash.Write(data) if err != nil { err = errors.New(fmt.Sprintf("Unable to write to hash: %v", err)) ret = retcode.NewStatusError(retcode.ErrorServer, err) return } // Update the file filePath, ret := self.incubationFilePath(state, id) if !ret.IsOk() { return } file, err := os.OpenFile(filePath, os.O_RDWR|os.O_APPEND, 0660) if err != nil { err = errors.New(fmt.Sprintf("Unable to open incubation file: %v", err)) ret = retcode.NewStatusError(retcode.ErrorServer, err) return } defer file.Close() _, err = file.Write(data) if err != nil { err = errors.New(fmt.Sprintf("Unable write to incubation file: %v", err)) ret = retcode.NewStatusError(retcode.ErrorServer, err) return } // Ok, now update the information currentIncubationState.length += uint64(len(data)) currentIncubationState.hashState = hash.Serialize() ret = self.writeInformation(state, id, ¤tIncubationState) return }
func (self *incubator) new(state *minos.OperationState, id string, removeIfAlreadyExisting bool) (ret retcode.Status) { // See if it already exists (and maybe remove it) _, ret = self.information(state, id) if !ret.IsOk() { return } alreadyFound := ret.Code != retcode.OkNotFound if alreadyFound && removeIfAlreadyExisting { // Ok, remove current ret = self.cleanIncubation(state, id) if !ret.IsOk() { return } } if !alreadyFound { // Create it hash := serializablehash.NewSha256() newState := new(incubationState) newState.length = 0 newState.hashState = hash.Serialize() self.writeInformation(state, id, newState) // Create empty file filePath, retLocal := self.incubationFilePath(state, id) if !retLocal.IsOk() { ret = retLocal return } file, err := os.Create(filePath) if err != nil { err = errors.New(fmt.Sprintf("Unable to create incubation file: %v", err)) ret = retcode.NewStatusError(retcode.ErrorServer, err) return } err = file.Close() if err != nil { err = errors.New(fmt.Sprintf("To close incubation file: %v", err)) ret = retcode.NewStatusError(retcode.ErrorServer, err) return } } ret = retcode.NewStatusOk() return }
func (self *incubator) information(state *minos.OperationState, id string) (incState incubationState, ret retcode.Status) { key := self.createInformationKey(state, id) apiOperation := &operations.Get{ BucketId: self.bucketId, Key: key, } opRet := state.Dispatcher.Perform(state.Context, apiOperation) if opRet.GetCode() != retcode.Ok { // Not found or a different error ret = opRet.GetStatus() return } // Ok, found it, deserialize retCast := opRet.(*operations.GetReturn) value := retCast.Value incState = incubationState{} incState.hashState = value[0] err := encoding.Cbor().Decode(value[1], &incState.length) if err != nil { ret = retcode.NewStatusError(retcode.ErrorServer, err) return } return }
func (self *public) information(state *minos.OperationState, hash []byte) (pubState publicState, ret retcode.Status) { key := self.clreatePublicKey(state, hash) apiOperation := &operations.Get{ BucketId: self.bucketId, Key: key, } opRet := state.Dispatcher.Perform(state.Context, apiOperation) if opRet.GetCode() != retcode.Ok { // Not found or a different error ret = opRet.GetStatus() return } // Ok, found it, deserialize retCast := opRet.(*operations.GetReturn) value := retCast.Value pubState = publicState{} pubState.data = value[0] err := encoding.Cbor().Decode(value[1], &pubState.length) if err != nil { ret = retcode.NewStatusError(retcode.ErrorServer, err) return } return }
func (self *incubator) writeInformation(state *minos.OperationState, id string, incState *incubationState) (ret retcode.Status) { key := self.createInformationKey(state, id) encodedLength, err := encoding.Cbor().Encode(incState.length) if err != nil { ret = retcode.NewStatusError(retcode.ErrorServer, err) return } value := types.Array{incState.hashState, encodedLength} apiOperation := &operations.Put{ BucketId: self.bucketId, Key: key, Value: value, } opRet := state.Dispatcher.Perform(state.Context, apiOperation) if !opRet.GetCode().IsOk() { // Unable to put ret = opRet.GetStatus() return } return opRet.GetStatus() }
func (self *directoryBucket) Perform(state *minos.OperationState) ( bucketReturn ares.Return) { operation := state.Operation instance, ret := self.createInstance(state) if !ret.IsOk() { return &bucket.ReturnGeneric{ret.GetStatus()} } switch operation := operation.(type) { case *operations.Put: // Handle internally return instance.opPut(operation, state) case *operations.Exists: // Forward to backing store return instance.cstore.Perform(state) case *operations.Get: // Forward to backing store return instance.cstore.Perform(state) case *operations.Hash: // Forward to backing store return instance.cstore.Perform(state) case *operations.Scan: // Scan is supported but has some limits return instance.opScan(operation, state) default: return &bucket.ReturnGeneric{retcode.NewStatusError( retcode.ErrorOperationNotSupported, errors.New(fmt.Sprintf( "Bucket operation not supported (directory): %v\n", reflect.TypeOf(operation))))} } }
func (self *public) writeInformation(state *minos.OperationState, hash []byte, pubState *publicState) (ret retcode.Status) { key := self.clreatePublicKey(state, hash) encodedLength, err := encoding.Cbor().Encode(pubState.length) if err != nil { ret = retcode.NewStatusError(retcode.ErrorServer, err) return } if pubState.data == nil { pubState.data = []byte{} } value := types.Array{pubState.data, encodedLength} apiOperation := &operations.Put{ BucketId: self.bucketId, Key: key, Value: value, } opRet := state.Dispatcher.Perform(state.Context, apiOperation) if !opRet.GetCode().IsOk() { // Unable to put ret = opRet.GetStatus() return } return opRet.GetStatus() }
func (self *Store) Op_exists(operation *operations.Exists) (ret bucket.BucketReturn) { database, err := self.Database() if err != nil { return &bucket.ReturnGeneric{retcode.NewStatusError(retcode.ErrorServer, err)} } keyBytes := self.KeyToBytesAndPrefix(operation.Key) _, err = database.Get(keyBytes, nil) if err == leveldb.ErrNotFound { return &operations.ExistsReturn{retcode.NewStatus(retcode.OkNotFound)} } if err != nil { return &bucket.ReturnGeneric{retcode.NewStatusError(retcode.ErrorServer, err)} } return &operations.ExistsReturn{ Status: retcode.NewStatusOk(), } }
func (self *directoryBucket) Create(state *minos.CreateState) (status retcode.Status) { suppliedForwarder, suppliedForwarderExists, err := state.Metadata.Forwarder(true, forwarder_name) if err != nil { return retcode.NewStatusError( retcode.ErrorClient, errors.New(fmt.Sprintf( "Error getting the supplied forwarder: %v\n", err))) } if suppliedForwarderExists { // No need to create one, already have one. Is the type correct? if suppliedForwarder.TypeId() != bucket.TypeId_BlobStore { return retcode.NewStatusError( retcode.ErrorClient, errors.New(fmt.Sprintf( "The supplied forwarder has to be of type blobstore, but it's: %v\n", suppliedForwarder.TypeId()))) } } else { // We have to create the backend bucket createBucket := operations.CreateBucket{ TypeId: bucket.TypeId_BlobStore, } retBackendBucket := state.Dispatcher.Perform(state.Context, &createBucket) if !retBackendBucket.GetCode().IsOk() { return retBackendBucket.GetStatus() } backendBucket := retBackendBucket.(*operations.CreateBucketReturn) var err error err = state.Metadata.SetForwarder(true, forwarder_name, backendBucket.Id) if err != nil { return retcode.NewStatusError( retcode.ErrorServer, errors.New(fmt.Sprintf( "Could not modify metadata: %v\n", err))) } } // Nothing to do here return retcode.NewStatusOk() }
func (self *incubator) incubationFilePath(state *minos.OperationState, id string) (fname string, ret retcode.Status) { clientIdAsBase32 := encoding.Base32Encode([]byte(state.Context.ClientId)) fname, err := state.Files.Filename(self.bucketId, "_"+clientIdAsBase32, id) if err != nil { ret = retcode.NewStatusError(retcode.ErrorServer, err) return } ret = retcode.NewStatusOk() return }
func (self *hasherStruct) createInstance(state *minos.OperationState) ( instance *hasherInstance, ret retcode.Status) { var err error backendId, exists, err := state.MetadataGetterSetter.Forwarder( true, metadataKey_backend) if err != nil { return nil, retcode.NewStatusError( retcode.ErrorServer, errors.New("Could not get forwarder metadata (backend)")) } if !exists { return nil, retcode.NewStatusError( retcode.ErrorServer, errors.New("Backend bucket id not found in metadata")) } ni := new(hasherInstance) ni.base = self ni.backendId = backendId return ni, retcode.NewStatusOk() }
func (self *public) publicFilePath(state *minos.OperationState, hash []byte) (fname string, ret retcode.Status) { hashAsBase32 := encoding.Base32Encode(hash) firstBytesAsDirectory := hashAsBase32[:6] fname, err := state.Files.Filename(self.bucketId, firstBytesAsDirectory, hashAsBase32) if err != nil { ret = retcode.NewStatusError(retcode.ErrorServer, err) return } ret = retcode.NewStatusOk() return }
func (self *Store) Op_get(operation *operations.Get) (ret bucket.BucketReturn) { database, err := self.Database() if err != nil { return &bucket.ReturnGeneric{retcode.NewStatusError(retcode.ErrorServer, err)} } keyBytes := self.KeyToBytesAndPrefix(operation.Key) value, err := database.Get(keyBytes, nil) if err == leveldb.ErrNotFound { return &bucket.ReturnGeneric{retcode.NewStatus(retcode.OkNotFound)} } if err != nil { return &bucket.ReturnGeneric{retcode.NewStatusError(retcode.ErrorServer, err)} } keyConstructed, err := types.NewArrayFromBytes(value) if err != nil { return &bucket.ReturnGeneric{retcode.NewStatusError(retcode.ErrorServer, err)} } return &operations.GetReturn{ Status: retcode.NewStatusOk(), Value: keyConstructed, } }
func (self *notifier) Create(state *minos.CreateState) ( status retcode.Status) { // We have to create two buckets here createBucket := operations.CreateBucket{ TypeId: bucket.TypeId_Store, } retRegistrationsBucket := state.Dispatcher.Perform(state.Context, &createBucket) if !retRegistrationsBucket.GetCode().IsOk() { return retRegistrationsBucket.GetStatus() } retKeysBucket := state.Dispatcher.Perform(state.Context, &createBucket) if !retKeysBucket.GetCode().IsOk() { return retKeysBucket.GetStatus() } registrationsBucket := retRegistrationsBucket.(*operations.CreateBucketReturn) keysBucket := retKeysBucket.(*operations.CreateBucketReturn) var err error err = state.Metadata.SetForwarder(true, metadataKey_registrations, registrationsBucket.Id) if err != nil { return retcode.NewStatusError( retcode.ErrorServer, errors.New(fmt.Sprintf( "Could not modify metadata: %v\n", err))) } err = state.Metadata.SetForwarder(true, metadataKey_keys, keysBucket.Id) if err != nil { return retcode.NewStatusError( retcode.ErrorServer, errors.New(fmt.Sprintf( "Could not modify metadata: %v\n", err))) } // Nothing to do here return retcode.NewStatusOk() }
func (self *notifierInstance) op_put(operation *operations.Put, state *minos.OperationState) (ret bucket.BucketReturn) { numberOfKeyElements := len(operation.Key) if numberOfKeyElements > 255 { retStatus := retcode.NewStatusError( retcode.ErrorClient, errors.New("Have too many elements in key")) return &bucket.ReturnGeneric{retStatus} } // Trigger also parent key elements for numberOfKeyElementsForTrigger := numberOfKeyElements; numberOfKeyElementsForTrigger >= 0; numberOfKeyElementsForTrigger-- { isOriginalLength := numberOfKeyElementsForTrigger == numberOfKeyElements keysToMatch := operation.Key[:numberOfKeyElementsForTrigger] if isOriginalLength { // Is executed first // First match those that have 'matchChildKeys' to false ret = self.triggerSubscribers(operation, keysToMatch, false, state) if !ret.GetCode().IsOk() { // Error return } // Now match those that have 'matchChildKeys' to true ret = self.triggerSubscribers(operation, keysToMatch, true, state) if !ret.GetCode().IsOk() { // Error return } } else { // We left the original key length, we now trigger the subscriptions // that have less key elements ret = self.triggerSubscribers(operation, keysToMatch, true, state) if !ret.GetCode().IsOk() { // Error return } } } return }
func (self *notifierInstance) putToRegistrationBucket(state *minos.OperationState, operation *operations.Subscribe) (subscriptionId operations.SubscriptionId, status retcode.Status) { // Locks, so we do not generate duplicate IDs state.Locker.BucketIdWriteLock(self.registrationsBucketId) defer state.Locker.BucketIdWriteUnlock(self.registrationsBucketId) var err error for index := 0; index < numberOfSubscriptionIdGenRetries; index++ { subscriptionId, err = createSubscriptionIdCandidate() if err == nil { key := types.Key{[]byte(state.Context.ClientId), []byte(subscriptionId)} opGet := operations.Get{ BucketId: self.registrationsBucketId, Key: key, } opGetApiRet := state.Dispatcher.Perform(state.Context, &opGet) if opGetApiRet.GetCode() == retcode.OkNotFound { // Great, entry not found, so add it keyInOperationAsArray := operation.Key.ToArray() value := make([][]byte, len(keyInOperationAsArray)+1) value[0] = []byte{serializeMatchChildKey(operation.MatchChildKeys)} copy(value[1:], keyInOperationAsArray) opPut := operations.Put{ BucketId: self.registrationsBucketId, Key: key, Value: value, } opPutApiRet := state.Dispatcher.Perform(state.Context, &opPut) if opPutApiRet.GetCode().IsOk() { // Great, registration is OK status = retcode.NewStatusOk() return } } } } return nil, retcode.NewStatusError(retcode.ErrorServer, errors.New("No free subscription ID found")) }
func (self *notifier) Perform(state *minos.OperationState) ( bucketReturn ares.Return) { operation := state.Operation ni, ret := self.createInstance(state) if !ret.GetCode().IsOk() { return &bucket.ReturnGeneric{ret.GetStatus()} } switch operation := operation.(type) { case *operations.Put: return ni.op_put(operation, state) case *operations.Subscribe: return ni.op_subscribe(operation, state) case *operations.Unsubscribe: return ni.op_unsubscribe(operation, state) default: return &bucket.ReturnGeneric{retcode.NewStatusError( retcode.ErrorOperationNotSupported, errors.New(fmt.Sprintf( "Bucket operation not supported (notifier): %v\n", reflect.TypeOf(operation))))} } }
func (self *Store) Perform(state *minos.OperationState) ( bucketReturn ares.Return) { operation := state.Operation switch operation.(type) { case *operations.Put: return self.Op_put(operation.(*operations.Put)) case *operations.Get: return self.Op_get(operation.(*operations.Get)) case *operations.Hash: return self.Op_hash(operation.(*operations.Hash)) case *operations.Scan: return self.Op_scan(operation.(*operations.Scan)) case *operations.Iterate: return self.Op_iterate(operation.(*operations.Iterate)) case *operations.Exists: return self.Op_exists(operation.(*operations.Exists)) default: return &bucket.ReturnGeneric{retcode.NewStatusError( retcode.ErrorClient, errors.New(fmt.Sprintf( "Unknown bucket operatiion (store): %v\n", reflect.TypeOf(operation))))} } }
func createKeyForLookupBucket( matchChildKeys bool, subscriptionId operations.SubscriptionId, subscriptionKey types.Key, state *minos.OperationState) (key types.Key, ret retcode.Status) { numberOfKeyElements := len(subscriptionKey) if numberOfKeyElements > 255 { ret = retcode.NewStatusError(retcode.ErrorClient, errors.New("Too many key elements")) return } matchChildKeysByte := serializeMatchChildKey(matchChildKeys) newKey := make(types.Key, numberOfKeyElements+4) newKey[0] = []byte{matchChildKeysByte} newKey[1] = []byte{byte(numberOfKeyElements)} copy(newKey[2:], subscriptionKey) newKey[2+numberOfKeyElements] = []byte(state.Context.ClientId) newKey[3+numberOfKeyElements] = []byte(subscriptionId) return newKey, retcode.NewStatusOk() }
func (self *blobstoreStruct) op_put(operation *operations.Put, state *minos.OperationState) (ret bucket.BucketReturn) { commonOp := new(commonOperation) retStatus := commonOp.fill(operation.Key, operation.Value) if !retStatus.IsOk() { return &bucket.ReturnGeneric{retStatus} } var status retcode.Status switch commonOp.operation { case operation_incubation_append: if len(commonOp.value) != 1 { panic("When calling append, need exactly one value (data to append)") } status = self.incubator.appendData(state, commonOp.incubationId, commonOp.value[0]) case operation_incubation_cancel: status = self.incubator.cleanIncubation(state, commonOp.incubationId) case operation_incubation_finish: status = self.public.publish(state, commonOp.incubationId) case operation_incubation_new: status = self.incubator.new(state, commonOp.incubationId, true) default: err := errors.New(fmt.Sprintf("Unknown operation: operation-code: "+ "%v (this usually means you called PUT instead of GET). Key: %v\n", commonOp.operation, operation.Key)) status = retcode.NewStatusError(retcode.ErrorClient, err) } // Done, return if status.IsOk() { return &operations.PutReturn{status} } else { return &bucket.ReturnGeneric{status} } }
func (self *counterInstance) op_get(operation *operations.Get) ( ret bucket.BucketReturn) { get_return := self.cstore.Op_get(operation) if get_return.GetCode() == retcode.OkNotFound { // This is a special case, if non existent, return 0 zeroValue := 0 valueBytes, err := encoding.Cbor().Encode(zeroValue) if err != nil { return &bucket.ReturnGeneric{retcode.NewStatusError(retcode.ErrorServer, errors.New(fmt.Sprintf("Could not encode cbor", err)))} } value := types.Array{valueBytes} get_return := operations.GetReturn{ Status: retcode.NewStatusOk(), Value: value, } return &get_return } else { // Everything else is returned 1:1 return get_return } }
func (self *blobstorePrototype) Create(state *minos.CreateState) (status retcode.Status) { // We have to create the backend bucket createBucket := operations.CreateBucket{ TypeId: bucket.TypeId_Store, } retBackendBucket := state.Dispatcher.Perform(state.Context, &createBucket) if !retBackendBucket.GetCode().IsOk() { return retBackendBucket.GetStatus() } backendBucket := retBackendBucket.(*operations.CreateBucketReturn) var err error err = state.Metadata.SetForwarder(true, metadataKey_backend, backendBucket.Id) if err != nil { return retcode.NewStatusError( retcode.ErrorServer, errors.New(fmt.Sprintf( "Could not modify metadata: %v\n", err))) } // Nothing to do here return retcode.NewStatusOk() }