Upload config for this index to the given store

@param SolrConfigStore $store
493724
public function uploadConfig($store)
    {
        parent::uploadConfig($store);

        // Upload configured synonyms {@see SynonymsKnowlegebaseSiteConfig}
        // Getting the Main site Configuration. because Synonyms text field only
        // enabled in main site( subsite 0)
        $siteConfig = SiteConfig::get()->filter([
            "SubsiteID" => 0,
        ])->First();

        if ($siteConfig->SearchSynonyms) {
            $store->uploadString(
                $this->getIndexName(),
                'synonyms.txt',
                $siteConfig->SearchSynonyms
            );
        }
    }
983009
private function _store_user( $store = true ) {
            $this->_logger->entrance();

            if ( empty( $this->_user->id ) ) {
                $this->_logger->error( "Empty user ID, can't store user." );

                return;
            }

            $users                     = self::get_all_users();
            $users[ $this->_user->id ] = $this->_user;
            self::$_accounts->set_option( 'users', $users, $store );
        }
791464
protected function getSolrConfigStore()
    {
        $options = Solr::solr_options();

        if (!isset($options['indexstore']) || !($indexstore = $options['indexstore'])) {
            throw new Exception('No index configuration for Solr provided', E_USER_ERROR);
        }

        // Find the IndexStore handler, which will handle uploading config files to Solr
        $mode = $indexstore['mode'];

        if ($mode === 'file') {
            return new SolrConfigStore_File($indexstore);
        }
        if ($mode === 'webdav') {
            return new SolrConfigStore_WebDAV($indexstore);
        }
        if ($mode === 'post') {
            return new SolrConfigStore_Post($indexstore);
        }
        if (ClassInfo::exists($mode) && ClassInfo::classImplements($mode, SolrConfigStore::class)) {
            return new $mode($indexstore);
        }
        user_error('Unknown Solr index mode ' . $indexstore['mode'], E_USER_ERROR);
    }
532651
protected function configure()
    {
        parent::configure();
        $this
            ->addOption(
                'oldstore',
                null,
                InputOption::VALUE_OPTIONAL,
                'Environment Location Storage to Migrate',
                self::BASH_VAGRANT_TRANSIENT_STORE
            );
    }
588439
@Override
    public IndexedDataStore create(StoreConfig config) throws IOException {
        try {
            return StoreFactory.createIndexedDataStore(config);
        } catch (Exception e) {
            if(e instanceof IOException) {
                throw (IOException)e;
            } else {
                throw new IOException(e);
            }
        }
    }
1271860
private function store(array $config)
    {
        foreach (array_intersect($this->factory->getAvailableComponentKeys(), array_keys($config)) as $key) {
            foreach ($config[$key] as $componentId => $componentConfig) {
                $id = $this->resolveStorageId($key, $componentId);
                $this->storage[$id] = array_merge(['arguments' => [], 'calls' => [], '_key' => $key], $componentConfig);
                $this->storeComponentDependencies($key, $componentConfig, $id);
            }
        }
    }
684265
public static function store(EntriesRepository $storage)
    {
        if (empty(static::$entriesQueue) && empty(static::$updatesQueue)) {
            return;
        }

        if (! collect(static::$filterBatchUsing)->every->__invoke(collect(static::$entriesQueue))) {
            static::flushEntries();
        }

        try {
            $batchId = Str::orderedUuid()->toString();

            $storage->store(static::collectEntries($batchId));
            $storage->update(static::collectUpdates($batchId));

            if ($storage instanceof TerminableRepository) {
                $storage->terminate();
            }
        } catch (Exception $e) {
            app(ExceptionHandler::class)->report($e);
        }

        static::$entriesQueue = [];
        static::$updatesQueue = [];
    }
494659
public function getConfigFlag($configKey, $store = null)
    {
        // if a value is given store, use it, even if it is null/false/empty string/whatever
        $store = count(func_get_args()) > 1 ? $store : $this->getStore();
        return $this->_getStoreConfigValue($configKey, $store, true);
    }
750086
@Override
    public void registerStore(IStore store) {
        _store = store;
        _store.setStoreCallback(_storeCallback);
        if (store instanceof ISessionObserver) {
            this.registerSessionObserver((ISessionObserver) store);
        }
        if (store instanceof ISessionStateObserver) {
            this.registerSessionStateObserver((ISessionStateObserver) store);
        }
    }
692636
protected function seTitleEditStore()
    {
        if (isset($this->data_store['store_id'])) {
            $title = $this->text('Edit %name', array('%name' => $this->data_store['name']));
        } else {
            $title = $this->text('Add store');
        }

        $this->setTitle($title);
    }
231214
private function setConfig($config)
    {
        $allowedConfigKeys = [
            'host',
            'port',
            'sasl_user',
            'sasl_password',
        ];

        foreach ($config as $key => $server) {
            (false === is_array($server)) ? $this->checkSimpleConfigArray($key, $allowedConfigKeys) : $this->checkMultidimensionalConfigArray($server, $allowedConfigKeys);
        }

        $this->config = $config;
    }
716610
function (cfg) {
            this.log("addRecordStore");
            var lrs;
            if (cfg instanceof TinCan.LRS) {
                lrs = cfg;
            }
            else {
                lrs = new TinCan.LRS (cfg);
            }
            this.recordStores.push(lrs);
        }
921749
public synchronized MetaStore storeConfiguration(Configuration configuration) {
    LOGGER.trace("Store configuration {}", configuration);
    serializer.writeObject(configuration.members(), configurationBuffer.position(0)
      .writeByte(1)
      .writeLong(configuration.index())
      .writeLong(configuration.term())
      .writeLong(configuration.time()));
    configurationBuffer.flush();
    return this;
  }
104127
public function useCache($store)
    {
        if ($this->eventMutex instanceof CacheEventMutex) {
            $this->eventMutex->useStore($store);
        }

        if ($this->schedulingMutex instanceof CacheSchedulingMutex) {
            $this->schedulingMutex->useStore($store);
        }

        return $this;
    }
397006
public static function purge_store($storename, cache_config $config = null) {
        if ($config === null) {
            $config = cache_config::instance();
        }

        $stores = $config->get_all_stores();
        if (!array_key_exists($storename, $stores)) {
            // The store does not exist.
            return false;
        }

        $store = $stores[$storename];
        $class = $store['class'];


        // We check are_requirements_met although we expect is_ready is going to check as well.
        if (!$class::are_requirements_met()) {
            return false;
        }
        // Found the store: is it ready?
        /* @var cache_store $instance */
        $instance = new $class($store['name'], $store['configuration']);
        if (!$instance->is_ready()) {
            unset($instance);
            return false;
        }
        foreach ($config->get_definitions_by_store($storename) as $id => $definition) {
            $definition = cache_definition::load($id, $definition);
            $definitioninstance = clone($instance);
            $definitioninstance->initialise($definition);
            $definitioninstance->purge();
            unset($definitioninstance);
        }

        return true;
    }
685850
public function addStoreFilter($store, bool $withAdmin = true)
    {
        if (!$this->getFlag('store_filter_added')) {
            if ($store instanceof Store) {
                $store = [$store->getId()];
            }

            if (!is_array($store)) {
                $store = [$store];
            }

            if ($withAdmin) {
                $store[] = Store::DEFAULT_STORE_ID;
            }

            $filterParams = [];

            foreach ($store as $storeId) {
                $filterParams[]['finset'] = $storeId;
            }

            $this->addFilter('store_id', $filterParams, 'public');
        }
        return $this;
    }
1167544
def appendDatastore(self, store):
    ''''''
    if not isinstance(store, Datastore):
      raise TypeError("stores must be of type %s" % Datastore)

    self._stores.append(store)