Examples with ZkSolrResourceLoader org.apache.solr.cloud.ZkSolrResourceLoader used on opensource projects

Example 6 with ZkSolrResourceLoader

use of org.apache.solr.cloud.ZkSolrResourceLoader in project lucene-solr by apache.

the class ManagedIndexSchemaFactory method upgradeToManagedSchema.

/**
   * Persist the managed schema and rename the non-managed schema 
   * by appending {@link #UPGRADED_SCHEMA_EXTENSION}.
   *
   * Failure to rename the non-managed schema will be logged as a warning,
   * and no exception will be thrown.
   */
private void upgradeToManagedSchema() {
    SolrResourceLoader loader = config.getResourceLoader();
    if (loader instanceof ZkSolrResourceLoader) {
        zkUgradeToManagedSchema();
    } else {
        // Configs are not on ZooKeeper
        // Only create it - don't update it if it already exists
        schema.persistManagedSchema(true);
        if (resourceName.equals(managedSchemaResourceName)) {
            log.info("On upgrading to managed schema, did not rename non-managed schema '" + resourceName + "' because it's the same as the managed schema's name.");
        } else {
            final File nonManagedSchemaFile = locateConfigFile(resourceName);
            if (null == nonManagedSchemaFile) {
                // Don't throw an exception for failure to rename the non-managed schema
                log.warn("On upgrading to managed schema, did not rename non-managed schema " + resourceName + " because it's neither an absolute file " + "nor under SolrConfig.getConfigDir() or the current directory." + "  PLEASE REMOVE THIS FILE.");
            } else {
                File upgradedSchemaFile = new File(nonManagedSchemaFile + UPGRADED_SCHEMA_EXTENSION);
                if (nonManagedSchemaFile.renameTo(upgradedSchemaFile)) {
                    // Set the resource name to the managed schema so that the CoreAdminHandler returns a findable filename 
                    schema.setResourceName(managedSchemaResourceName);
                    log.info("After upgrading to managed schema, renamed the non-managed schema " + nonManagedSchemaFile + " to " + upgradedSchemaFile);
                } else {
                    // Don't throw an exception for failure to rename the non-managed schema
                    log.warn("Can't rename " + nonManagedSchemaFile.toString() + " to " + upgradedSchemaFile.toString() + " - PLEASE REMOVE THIS FILE.");
                }
            }
        }
    }
}

Example 7 with ZkSolrResourceLoader

use of org.apache.solr.cloud.ZkSolrResourceLoader in project lucene-solr by apache.

the class ManagedIndexSchemaFactory method zkUgradeToManagedSchema.

/**
   * Persist the managed schema to ZooKeeper and rename the non-managed schema 
   * by appending {@link #UPGRADED_SCHEMA_EXTENSION}.
   *
   * Failure to rename the non-managed schema will be logged as a warning,
   * and no exception will be thrown.
   */
private void zkUgradeToManagedSchema() {
    // Only create, don't update it if it already exists
    schema.persistManagedSchemaToZooKeeper(true);
    if (resourceName.equals(managedSchemaResourceName)) {
        log.info("On upgrading to managed schema, did not rename non-managed schema " + resourceName + " because it's the same as the managed schema's name.");
    } else {
        // Rename the non-managed schema znode in ZooKeeper
        ZkSolrResourceLoader zkLoader = (ZkSolrResourceLoader) loader;
        final String nonManagedSchemaPath = zkLoader.getConfigSetZkPath() + "/" + resourceName;
        try {
            ZkController zkController = zkLoader.getZkController();
            ZkCmdExecutor zkCmdExecutor = new ZkCmdExecutor(zkController.getClientTimeout());
            if (zkController.pathExists(nonManagedSchemaPath)) {
                // First, copy the non-managed schema znode content to the upgraded schema znode
                byte[] bytes = zkController.getZkClient().getData(nonManagedSchemaPath, null, null, true);
                final String upgradedSchemaPath = nonManagedSchemaPath + UPGRADED_SCHEMA_EXTENSION;
                zkCmdExecutor.ensureExists(upgradedSchemaPath, zkController.getZkClient());
                zkController.getZkClient().setData(upgradedSchemaPath, bytes, true);
                // Then delete the non-managed schema znode
                zkController.getZkClient().delete(nonManagedSchemaPath, -1, true);
                // Set the resource name to the managed schema so that the CoreAdminHandler returns a findable filename 
                schema.setResourceName(managedSchemaResourceName);
                log.info("After upgrading to managed schema in ZooKeeper, renamed the non-managed schema " + nonManagedSchemaPath + " to " + upgradedSchemaPath);
            } else {
                log.info("After upgrading to managed schema in ZooKeeper, the non-managed schema " + nonManagedSchemaPath + " no longer exists.");
            }
        } catch (Exception e) {
            if (e instanceof InterruptedException) {
                // Restore the interrupted status
                Thread.currentThread().interrupt();
            }
            final String msg = "Error persisting managed schema resource " + managedSchemaResourceName;
            // Log as warning and suppress the exception
            log.warn(msg, e);
        }
    }
}

Example 8 with ZkSolrResourceLoader

use of org.apache.solr.cloud.ZkSolrResourceLoader in project lucene-solr by apache.

the class ManagedIndexSchemaFactory method inform.

@Override
public void inform(SolrCore core) {
    this.core = core;
    if (loader instanceof ZkSolrResourceLoader) {
        this.zkIndexSchemaReader = new ZkIndexSchemaReader(this, core);
        ZkSolrResourceLoader zkLoader = (ZkSolrResourceLoader) loader;
        zkLoader.setZkIndexSchemaReader(this.zkIndexSchemaReader);
        try {
            // update immediately if newer is available
            zkIndexSchemaReader.refreshSchemaFromZk(-1);
            core.setLatestSchema(getSchema());
        } catch (KeeperException e) {
            String msg = "Error attempting to access " + zkLoader.getConfigSetZkPath() + "/" + managedSchemaResourceName;
            log.error(msg, e);
            throw new SolrException(ErrorCode.SERVER_ERROR, msg, e);
        } catch (InterruptedException e) {
            // Restore the interrupted status
            Thread.currentThread().interrupt();
            log.warn("", e);
        }
    } else {
        this.zkIndexSchemaReader = null;
    }
}

Example 9 with ZkSolrResourceLoader

use of org.apache.solr.cloud.ZkSolrResourceLoader in project lucene-solr by apache.

the class SchemaManager method waitForOtherReplicasToUpdate.

private void waitForOtherReplicasToUpdate(TimeOut timeOut, int latestVersion) {
    CoreDescriptor cd = req.getCore().getCoreDescriptor();
    String collection = cd.getCollectionName();
    if (collection != null) {
        ZkSolrResourceLoader zkLoader = (ZkSolrResourceLoader) managedIndexSchema.getResourceLoader();
        if (timeOut.hasTimedOut()) {
            throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Not enough time left to update replicas. However, the schema is updated already.");
        }
        ManagedIndexSchema.waitForSchemaZkVersionAgreement(collection, cd.getCloudDescriptor().getCoreNodeName(), latestVersion, zkLoader.getZkController(), (int) timeOut.timeLeft(TimeUnit.SECONDS));
    }
}

Example 10 with ZkSolrResourceLoader

use of org.apache.solr.cloud.ZkSolrResourceLoader in project lucene-solr by apache.

the class SchemaManager method doOperations.

private List doOperations(List<CommandOperation> operations) throws InterruptedException, IOException, KeeperException {
    //The default timeout is 10 minutes when no BaseSolrResource.UPDATE_TIMEOUT_SECS is specified
    int timeout = req.getParams().getInt(BaseSolrResource.UPDATE_TIMEOUT_SECS, 600);
    //If BaseSolrResource.UPDATE_TIMEOUT_SECS=0 or -1 then end time then we'll try for 10 mins ( default timeout )
    if (timeout < 1) {
        timeout = 600;
    }
    TimeOut timeOut = new TimeOut(timeout, TimeUnit.SECONDS);
    SolrCore core = req.getCore();
    String errorMsg = "Unable to persist managed schema. ";
    List errors = Collections.emptyList();
    int latestVersion = -1;
    synchronized (req.getSchema().getSchemaUpdateLock()) {
        while (!timeOut.hasTimedOut()) {
            managedIndexSchema = getFreshManagedSchema(req.getCore());
            for (CommandOperation op : operations) {
                OpType opType = OpType.get(op.name);
                if (opType != null) {
                    opType.perform(op, this);
                } else {
                    op.addError("No such operation : " + op.name);
                }
            }
            errors = CommandOperation.captureErrors(operations);
            if (!errors.isEmpty())
                break;
            SolrResourceLoader loader = req.getCore().getResourceLoader();
            if (loader instanceof ZkSolrResourceLoader) {
                ZkSolrResourceLoader zkLoader = (ZkSolrResourceLoader) loader;
                StringWriter sw = new StringWriter();
                try {
                    managedIndexSchema.persist(sw);
                } catch (IOException e) {
                    throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "unable to serialize schema");
                //unlikely
                }
                try {
                    latestVersion = ZkController.persistConfigResourceToZooKeeper(zkLoader, managedIndexSchema.getSchemaZkVersion(), managedIndexSchema.getResourceName(), sw.toString().getBytes(StandardCharsets.UTF_8), true);
                    req.getCore().getCoreContainer().reload(req.getCore().getName());
                    break;
                } catch (ZkController.ResourceModifiedInZkException e) {
                    log.info("Schema was modified by another node. Retrying..");
                }
            } else {
                try {
                    //only for non cloud stuff
                    managedIndexSchema.persistManagedSchema(false);
                    core.setLatestSchema(managedIndexSchema);
                } catch (SolrException e) {
                    log.warn(errorMsg);
                    errors = singletonList(errorMsg + e.getMessage());
                }
                break;
            }
        }
    }
    if (req.getCore().getResourceLoader() instanceof ZkSolrResourceLoader) {
        // Don't block further schema updates while waiting for a pending update to propagate to other replicas.
        // This reduces the likelihood of a (time-limited) distributed deadlock during concurrent schema updates.
        waitForOtherReplicasToUpdate(timeOut, latestVersion);
    }
    if (errors.isEmpty() && timeOut.hasTimedOut()) {
        log.warn(errorMsg + "Timed out.");
        errors = singletonList(errorMsg + "Timed out.");
    }
    return errors;
}