// ErrBucketConflict for buckets that already exist
type ErrBucketConflict Error

func (e ErrBucketConflict) Error() string {
	return e.Bucket + " bucket conflict error: " + e.Err.Error()
}

// Store dns record store
type Store interface {
	Put(bucket string) error
	Get(bucket string) ([]SrvRecord, error)
	Delete(bucket string) error
	List() (map[string][]SrvRecord, error)
	DeleteRecord(record SrvRecord) error
	Close() error

	DelList(key []string) error
	Open() error
	Delete() error
	Extension() string
}

// Key denotes the key present in the store.
type Key struct {
	Name   string
	IsLast bool
}

// replayItems - Reads the items from the store and replays.
func replayItems[I any](store Store[I], doneCh <-chan struct{}, log logger, id string) <-chan Key {
	keyCh := make(chan Key)

	go func() {
		defer xioutil.SafeClose(keyCh)

Harshavardhana <******@****.***> 1618774873 -0700

func TestQueueStorePut(t *testing.T) {
	defer func() {
		if err := tearDownQueueStore(); err != nil {
			t.Fatal("Failed to tear down store ", err)
		}
	}()
	store, err := setUpQueueStore(queueDir, 100)
	if err != nil {
		t.Fatal("Failed to create a queue store ", err)
	}
	// Put 100 items.
	for i := 0; i < 100; i++ {
		if err := store.Put(testItem); err != nil {
			t.Fatal("Failed to put to queue store ", err)

// Name - returns the Name of the target.
func (target *RedisTarget) Name() string {
	return target.ID().String()
}

// Store returns any underlying store if set.
func (target *RedisTarget) Store() event.TargetStore {
	return target.store
}

// IsActive - Return true if target is up and active
func (target *RedisTarget) IsActive() (bool, error) {
	if err := target.init(); err != nil {
		return false, err
	}

	store.RLock()
	l := len(store.entries)
	defer store.RUnlock()
	return l
}

// lockless call
func (store *QueueStore[_]) del(key string) error {
	err := os.Remove(filepath.Join(store.directory, key+store.fileExt))

	// Delete as entry no matter the result
	delete(store.entries, key)

	return err
}

// List - lists all files registered in the store.

	"net/http"

	"github.com/minio/minio/internal/hash"
)

var errConfigNotFound = errors.New("config file not found")

func readConfigWithMetadata(ctx context.Context, store objectIO, configFile string, opts ObjectOptions) ([]byte, ObjectInfo, error) {
	r, err := store.GetObjectNInfo(ctx, minioMetaBucket, configFile, nil, http.Header{}, opts)
	if err != nil {
		if isErrObjectNotFound(err) {
			return nil, ObjectInfo{}, errConfigNotFound
		}

	}
	return target.isActive()
}

// Store returns any underlying store if set.
func (target *WebhookTarget) Store() event.TargetStore {
	return target.store
}

func (target *WebhookTarget) isActive() (bool, error) {
	conn, err := net.DialTimeout("tcp", target.addr, 5*time.Second)
	if err != nil {
		if xnet.IsNetworkOrHostDown(err, false) {
			return false, store.ErrNotConnected
		}
		return false, err
	}

			return nil, fmt.Errorf("unable to initialize the queue store of NSQ `%s`: %w", id, err)
		}
	}

	target := &NSQTarget{
		id:         event.TargetID{ID: id, Name: "nsq"},
		args:       args,
		loggerOnce: loggerOnce,
		store:      queueStore,
		quitCh:     make(chan struct{}),
	}

	if target.store != nil {
		store.StreamItems(target.store, target, target.quitCh, target.loggerOnce)
	}

         *
         * See [PropertiesUtils.store].
         */
        fun store(data: Map<String, Any>, file: File, comment: String? = null) {
            store(propertiesFrom(data), file, comment)
        }

        /**
         * Writes [Properties] to a file, but without including the timestamp comment.
         *
         * See [PropertiesUtils.store].
         */