Golang Bucket.CreateBucketIfNotExists方法代码示例

func (store *BoltStore) Del(uri string) error {
	namespace, key := util.NamespaceKey(uri)
	bucketkeys := util.PathFolders(namespace)
	var bucket *bolt.Bucket = nil
	var err error
	e := store.db.Update(func(tx *bolt.Tx) error {
		for _, bucketkey := range bucketkeys {
			if bucket == nil {
				bucket, err = tx.CreateBucketIfNotExists([]byte(bucketkey))
				if err != nil {
					return err
				}
			} else {
				bucket, err = bucket.CreateBucketIfNotExists([]byte(bucketkey))
				if err != nil {
					return err
				}
			}
		}
		bucket.DeleteBucket([]byte(key))
		bucket.Delete([]byte(key))
		return nil
	})
	return e
}

func (self *TX) dig(keys [][]byte, create bool) (buckets []*bolt.Bucket, err error) {
	var bucket *bolt.Bucket
	if create {
		if bucket, err = self.tx.CreateBucketIfNotExists(keys[0]); err != nil {
			return
		}
	} else {
		if bucket = self.tx.Bucket(keys[0]); bucket == nil {
			err = ErrNotFound
			return
		}
	}
	buckets = append(buckets, bucket)
	for keys = keys[1:]; len(keys) > 0; keys = keys[1:] {
		if create {
			if bucket, err = bucket.CreateBucketIfNotExists(keys[0]); err != nil {
				return
			}
		} else {
			if bucket = bucket.Bucket(keys[0]); bucket == nil {
				err = ErrNotFound
				return
			}
		}
		buckets = append(buckets, bucket)
	}
	return
}

// Init initializes this component. It requires an amount and an interval in
// seconds to be present.
func (RateLimitFilter) Init(h Hook, params map[string]string, b *bolt.Bucket) error {
	amount, ok := params["amount"]
	if !ok {
		return errors.New("amount is required")
	}

	if i, err := strconv.Atoi(amount); err != nil || i <= 0 {
		return fmt.Errorf("amount must be a positive number > 0: %s", err)
	}

	interval, ok := params["interval"]
	if !ok {
		return errors.New("interval is required")
	}

	if i, err := strconv.Atoi(interval); err != nil || i <= 0 {
		return fmt.Errorf("interval must be a positive number: %s", err)
	}

	if err := b.Put([]byte(fmt.Sprintf("%s-amount", h.ID)), []byte(amount)); err != nil {
		return err
	}
	if err := b.Put([]byte(fmt.Sprintf("%s-interval", h.ID)), []byte(interval)); err != nil {
		return err
	}
	_, err := b.CreateBucketIfNotExists([]byte("requests"))
	return err
}

func (store *BoltStore) put(bucket *bolt.Bucket, key string, value interface{}) error {
	var err error
	if is_value_basic(value) {
		if key == "" {
			return fmt.Errorf("key is absent")
		}
		byts, err := store.coder.Encode(value)
		if err != nil {
			return err
		}
		return bucket.Put([]byte(key), byts)
	}

	if key != "" {
		bucket, err = bucket.CreateBucketIfNotExists([]byte(key))
		if err != nil {
			return err
		}
	}

	switch value_type_kind(value) {
	case reflect.Slice:
		vs := reflect.ValueOf(value)
		for i := 0; i < vs.Len(); i++ {
			if err := store.put(bucket, strconv.Itoa(i), vs.Index(i).Interface()); err != nil {
				return err
			}
		}
		return nil
	case reflect.Map:
		vs, err := cast.ToStringMapE(value)
		if err != nil {
			return err
		}
		for k, v := range vs {
			if err := store.put(bucket, k, v); err != nil {
				return err
			}
		}
		return nil
	case reflect.Struct:
		vt := reflect.TypeOf(value)
		vv := reflect.ValueOf(value)
		for i := 0; i < vt.NumField(); i++ {
			vfield := vt.Field(i)
			if tag := vfield.Tag.Get("object"); tag != "" {
				if err := store.put(bucket, tag, vv.Field(i).Interface()); err != nil {
					return err
				}
			}
		}
		return nil
	}
	return fmt.Errorf("unsupport store value type")
}

// Init initializes this component. It requires a secret to be present.
func (GithubValidator) Init(h Hook, params map[string]string, b *bolt.Bucket) error {
	secret, ok := params["secret"]
	if !ok {
		return errors.New("secret is required")
	}
	if err := b.Put([]byte(fmt.Sprintf("%s-secret", h.ID)), []byte(secret)); err != nil {
		return err
	}
	_, err := b.CreateBucketIfNotExists([]byte("deliveries"))
	return err
}

// Init initializes this component. It requires a Mailgun API key to be
// present.
func (MailgunValidator) Init(h Hook, params map[string]string, b *bolt.Bucket) error {
	apikey, ok := params["apikey"]
	if !ok {
		return errors.New("apikey is required")
	}
	if err := b.Put([]byte(fmt.Sprintf("%s-apikey", h.ID)), []byte(apikey)); err != nil {
		return err
	}
	_, err := b.CreateBucketIfNotExists([]byte("tokens"))
	return err
}

// CreateBucketIfNotExists creates the bucket below the current node if it doesn't
// already exist.
func (n *node) CreateBucketIfNotExists(tx *bolt.Tx, bucket string) (*bolt.Bucket, error) {
	var b *bolt.Bucket
	var err error

	bucketNames := append(n.rootBucket, bucket)

	for _, bucketName := range bucketNames {
		if b != nil {
			if b, err = b.CreateBucketIfNotExists([]byte(bucketName)); err != nil {
				return nil, err
			}

		} else {
			if b, err = tx.CreateBucketIfNotExists([]byte(bucketName)); err != nil {
				return nil, err
			}
		}
	}

	return b, nil
}

func (store *BoltStore) Put(uri string, value interface{}) error {
	namespace, key := util.NamespaceKey(uri)
	bucketkeys := util.PathFolders(namespace)
	var bucket *bolt.Bucket = nil
	var err error
	e := store.db.Update(func(tx *bolt.Tx) error {
		for _, bucketkey := range bucketkeys {
			if bucket == nil {
				bucket, err = tx.CreateBucketIfNotExists([]byte(bucketkey))
				if err != nil {
					return err
				}
			} else {
				bucket, err = bucket.CreateBucketIfNotExists([]byte(bucketkey))
				if err != nil {
					return err
				}
			}
		}
		return store.put(bucket, key, value)
	})
	return e
}

func importBucket(b *bolt.Bucket, children []*rawMessage) error {
	// Decode each message into a key/value pair.
	for _, child := range children {
		// Bucket messages are handled recursively.
		if child.Type == "bucket" {
			// Create the bucket if it doesn't exist.
			subbucket, err := b.CreateBucketIfNotExists(child.Key)
			if err != nil {
				return fmt.Errorf("create bucket: %s", err)
			}

			// Decode child messages.
			var subchildren []*rawMessage
			if err := json.Unmarshal(child.Value, &subchildren); err != nil {
				return fmt.Errorf("decode children: %s", err)
			}

			// Import subbucket.
			if err := importBucket(subbucket, subchildren); err != nil {
				return fmt.Errorf("import bucket: %s", err)
			}
			continue
		}

		// Non-bucket values are decoded from base64.
		var value []byte
		if err := json.Unmarshal(child.Value, &value); err != nil {
			return fmt.Errorf("decode value: %s", err)
		}

		// Insert key/value into bucket.
		if err := b.Put(child.Key, value); err != nil {
			return fmt.Errorf("put: %s", err)
		}
	}
	return nil
}