Examples with Node org.apache.solr.update.SolrCmdDistributor.Node used on opensource projects

Example 11 with Node

use of org.apache.solr.update.SolrCmdDistributor.Node in project lucene-solr by apache.

the class DistributedUpdateProcessor method processAdd.

@Override
public void processAdd(AddUpdateCommand cmd) throws IOException {
    assert TestInjection.injectFailUpdateRequests();
    updateCommand = cmd;
    if (zkEnabled) {
        zkCheck();
        nodes = setupRequest(cmd.getHashableId(), cmd.getSolrInputDocument());
    } else {
        isLeader = getNonZkLeaderAssumption(req);
    }
    // check if client has requested minimum replication factor information
    // disabled by default
    int minRf = -1;
    if (replicationTracker != null) {
        // for subsequent requests in the same batch
        minRf = replicationTracker.minRf;
    } else {
        SolrParams rp = cmd.getReq().getParams();
        String distribUpdate = rp.get(DISTRIB_UPDATE_PARAM);
        // a leader or this is the top-level request processor
        if (distribUpdate == null || distribUpdate.equals(DistribPhase.TOLEADER.toString())) {
            String minRepFact = rp.get(UpdateRequest.MIN_REPFACT);
            if (minRepFact != null) {
                try {
                    minRf = Integer.parseInt(minRepFact);
                } catch (NumberFormatException nfe) {
                    minRf = -1;
                }
                if (minRf <= 0)
                    throw new SolrException(ErrorCode.BAD_REQUEST, "Invalid value " + minRepFact + " for " + UpdateRequest.MIN_REPFACT + "; must be >0 and less than or equal to the collection replication factor.");
            }
            if (minRf > 1) {
                String myShardId = forwardToLeader ? null : cloudDesc.getShardId();
                replicationTracker = new RequestReplicationTracker(myShardId, minRf);
            }
        }
    }
    // If we were sent a previous version, set this to the AddUpdateCommand (if not already set)
    if (!cmd.isInPlaceUpdate()) {
        cmd.prevVersion = cmd.getReq().getParams().getLong(DistributedUpdateProcessor.DISTRIB_INPLACE_PREVVERSION, -1);
    }
    // TODO: if minRf > 1 and we know the leader is the only active replica, we could fail
    // the request right here but for now I think it is better to just return the status
    // to the client that the minRf wasn't reached and let them handle it    
    boolean dropCmd = false;
    if (!forwardToLeader) {
        dropCmd = versionAdd(cmd);
    }
    if (dropCmd) {
        // TODO: do we need to add anything to the response?
        return;
    }
    if (zkEnabled && isLeader && !isSubShardLeader) {
        DocCollection coll = zkController.getClusterState().getCollection(collection);
        List<Node> subShardLeaders = getSubShardLeaders(coll, cloudDesc.getShardId(), cmd.getHashableId(), cmd.getSolrInputDocument());
        // the list<node> will actually have only one element for an add request
        if (subShardLeaders != null && !subShardLeaders.isEmpty()) {
            ModifiableSolrParams params = new ModifiableSolrParams(filterParams(req.getParams()));
            params.set(DISTRIB_UPDATE_PARAM, DistribPhase.FROMLEADER.toString());
            params.set(DISTRIB_FROM, ZkCoreNodeProps.getCoreUrl(zkController.getBaseUrl(), req.getCore().getName()));
            params.set(DISTRIB_FROM_PARENT, req.getCore().getCoreDescriptor().getCloudDescriptor().getShardId());
            for (Node subShardLeader : subShardLeaders) {
                cmdDistrib.distribAdd(cmd, Collections.singletonList(subShardLeader), params, true);
            }
        }
        final List<Node> nodesByRoutingRules = getNodesByRoutingRules(zkController.getClusterState(), coll, cmd.getHashableId(), cmd.getSolrInputDocument());
        if (nodesByRoutingRules != null && !nodesByRoutingRules.isEmpty()) {
            ModifiableSolrParams params = new ModifiableSolrParams(filterParams(req.getParams()));
            params.set(DISTRIB_UPDATE_PARAM, DistribPhase.FROMLEADER.toString());
            params.set(DISTRIB_FROM, ZkCoreNodeProps.getCoreUrl(zkController.getBaseUrl(), req.getCore().getName()));
            params.set(DISTRIB_FROM_COLLECTION, req.getCore().getCoreDescriptor().getCloudDescriptor().getCollectionName());
            params.set(DISTRIB_FROM_SHARD, req.getCore().getCoreDescriptor().getCloudDescriptor().getShardId());
            for (Node nodesByRoutingRule : nodesByRoutingRules) {
                cmdDistrib.distribAdd(cmd, Collections.singletonList(nodesByRoutingRule), params, true);
            }
        }
    }
    ModifiableSolrParams params = null;
    if (nodes != null) {
        params = new ModifiableSolrParams(filterParams(req.getParams()));
        params.set(DISTRIB_UPDATE_PARAM, (isLeader || isSubShardLeader ? DistribPhase.FROMLEADER.toString() : DistribPhase.TOLEADER.toString()));
        params.set(DISTRIB_FROM, ZkCoreNodeProps.getCoreUrl(zkController.getBaseUrl(), req.getCore().getName()));
        if (replicationTracker != null && minRf > 1)
            params.set(UpdateRequest.MIN_REPFACT, String.valueOf(minRf));
        if (cmd.isInPlaceUpdate()) {
            params.set(DISTRIB_INPLACE_PREVVERSION, String.valueOf(cmd.prevVersion));
            // Use synchronous=true so that a new connection is used, instead
            // of the update being streamed through an existing streaming client.
            // When using a streaming client, the previous update
            // and the current in-place update (that depends on the previous update), if reordered
            // in the stream, can result in the current update being bottled up behind the previous
            // update in the stream and can lead to degraded performance.
            cmdDistrib.distribAdd(cmd, nodes, params, true, replicationTracker);
        } else {
            cmdDistrib.distribAdd(cmd, nodes, params, false, replicationTracker);
        }
    }
    // TODO: what to do when no idField?
    if (returnVersions && rsp != null && idField != null) {
        if (addsResponse == null) {
            addsResponse = new NamedList<String>(1);
            rsp.add("adds", addsResponse);
        }
        if (scratch == null)
            scratch = new CharsRefBuilder();
        idField.getType().indexedToReadable(cmd.getIndexedId(), scratch);
        addsResponse.add(scratch.toString(), cmd.getVersion());
    }
// TODO: keep track of errors?  needs to be done at a higher level though since
// an id may fail before it gets to this processor.
// Given that, it may also make sense to move the version reporting out of this
// processor too.
}

Example 12 with Node

use of org.apache.solr.update.SolrCmdDistributor.Node in project lucene-solr by apache.

the class DistributedUpdateProcessor method processDelete.

@Override
public void processDelete(DeleteUpdateCommand cmd) throws IOException {
    assert TestInjection.injectFailUpdateRequests();
    updateCommand = cmd;
    if (!cmd.isDeleteById()) {
        doDeleteByQuery(cmd);
        return;
    }
    if (zkEnabled) {
        zkCheck();
        nodes = setupRequest(cmd.getId(), null, cmd.getRoute());
    } else {
        isLeader = getNonZkLeaderAssumption(req);
    }
    boolean dropCmd = false;
    if (!forwardToLeader) {
        dropCmd = versionDelete(cmd);
    }
    if (dropCmd) {
        // TODO: do we need to add anything to the response?
        return;
    }
    if (zkEnabled && isLeader && !isSubShardLeader) {
        DocCollection coll = zkController.getClusterState().getCollection(collection);
        List<Node> subShardLeaders = getSubShardLeaders(coll, cloudDesc.getShardId(), cmd.getId(), null);
        // the list<node> will actually have only one element for an add request
        if (subShardLeaders != null && !subShardLeaders.isEmpty()) {
            ModifiableSolrParams params = new ModifiableSolrParams(filterParams(req.getParams()));
            params.set(DISTRIB_UPDATE_PARAM, DistribPhase.FROMLEADER.toString());
            params.set(DISTRIB_FROM, ZkCoreNodeProps.getCoreUrl(zkController.getBaseUrl(), req.getCore().getName()));
            params.set(DISTRIB_FROM_PARENT, cloudDesc.getShardId());
            cmdDistrib.distribDelete(cmd, subShardLeaders, params, true);
        }
        final List<Node> nodesByRoutingRules = getNodesByRoutingRules(zkController.getClusterState(), coll, cmd.getId(), null);
        if (nodesByRoutingRules != null && !nodesByRoutingRules.isEmpty()) {
            ModifiableSolrParams params = new ModifiableSolrParams(filterParams(req.getParams()));
            params.set(DISTRIB_UPDATE_PARAM, DistribPhase.FROMLEADER.toString());
            params.set(DISTRIB_FROM, ZkCoreNodeProps.getCoreUrl(zkController.getBaseUrl(), req.getCore().getName()));
            params.set(DISTRIB_FROM_COLLECTION, req.getCore().getCoreDescriptor().getCloudDescriptor().getCollectionName());
            params.set(DISTRIB_FROM_SHARD, req.getCore().getCoreDescriptor().getCloudDescriptor().getShardId());
            for (Node nodesByRoutingRule : nodesByRoutingRules) {
                cmdDistrib.distribDelete(cmd, Collections.singletonList(nodesByRoutingRule), params, true);
            }
        }
    }
    ModifiableSolrParams params = null;
    if (nodes != null) {
        params = new ModifiableSolrParams(filterParams(req.getParams()));
        params.set(DISTRIB_UPDATE_PARAM, (isLeader || isSubShardLeader ? DistribPhase.FROMLEADER.toString() : DistribPhase.TOLEADER.toString()));
        params.set(DISTRIB_FROM, ZkCoreNodeProps.getCoreUrl(zkController.getBaseUrl(), req.getCore().getName()));
        cmdDistrib.distribDelete(cmd, nodes, params);
    }
    // TODO: what to do when no idField?
    if (returnVersions && rsp != null && cmd.getIndexedId() != null && idField != null) {
        if (deleteResponse == null) {
            deleteResponse = new NamedList<String>(1);
            rsp.add("deletes", deleteResponse);
        }
        if (scratch == null)
            scratch = new CharsRefBuilder();
        idField.getType().indexedToReadable(cmd.getIndexedId(), scratch);
        // we're returning the version of the delete.. not the version of the doc we deleted.
        deleteResponse.add(scratch.toString(), cmd.getVersion());
    }
}

Example 13 with Node

use of org.apache.solr.update.SolrCmdDistributor.Node in project lucene-solr by apache.

the class DistributedUpdateProcessor method getNodesByRoutingRules.

private List<Node> getNodesByRoutingRules(ClusterState cstate, DocCollection coll, String id, SolrInputDocument doc) {
    DocRouter router = coll.getRouter();
    List<Node> nodes = null;
    if (router instanceof CompositeIdRouter) {
        CompositeIdRouter compositeIdRouter = (CompositeIdRouter) router;
        String myShardId = req.getCore().getCoreDescriptor().getCloudDescriptor().getShardId();
        Slice slice = coll.getSlice(myShardId);
        Map<String, RoutingRule> routingRules = slice.getRoutingRules();
        if (routingRules != null) {
            // delete by query case
            if (id == null) {
                for (Entry<String, RoutingRule> entry : routingRules.entrySet()) {
                    String targetCollectionName = entry.getValue().getTargetCollectionName();
                    Collection<Slice> activeSlices = cstate.getActiveSlices(targetCollectionName);
                    if (activeSlices != null && !activeSlices.isEmpty()) {
                        Slice any = activeSlices.iterator().next();
                        if (nodes == null)
                            nodes = new ArrayList<>();
                        nodes.add(new StdNode(new ZkCoreNodeProps(any.getLeader())));
                    }
                }
                return nodes;
            }
            String routeKey = SolrIndexSplitter.getRouteKey(id);
            if (routeKey != null) {
                RoutingRule rule = routingRules.get(routeKey + "!");
                if (rule != null) {
                    if (!rule.isExpired()) {
                        List<DocRouter.Range> ranges = rule.getRouteRanges();
                        if (ranges != null && !ranges.isEmpty()) {
                            int hash = compositeIdRouter.sliceHash(id, doc, null, coll);
                            for (DocRouter.Range range : ranges) {
                                if (range.includes(hash)) {
                                    DocCollection targetColl = cstate.getCollection(rule.getTargetCollectionName());
                                    Collection<Slice> activeSlices = targetColl.getRouter().getSearchSlicesSingle(id, null, targetColl);
                                    if (activeSlices == null || activeSlices.isEmpty()) {
                                        throw new SolrException(ErrorCode.SERVER_ERROR, "No active slices serving " + id + " found for target collection: " + rule.getTargetCollectionName());
                                    }
                                    Replica targetLeader = targetColl.getLeader(activeSlices.iterator().next().getName());
                                    nodes = new ArrayList<>(1);
                                    nodes.add(new StdNode(new ZkCoreNodeProps(targetLeader)));
                                    break;
                                }
                            }
                        }
                    } else {
                        ReentrantLock ruleExpiryLock = req.getCore().getRuleExpiryLock();
                        if (!ruleExpiryLock.isLocked()) {
                            try {
                                if (ruleExpiryLock.tryLock(10, TimeUnit.MILLISECONDS)) {
                                    log.info("Going to expire routing rule");
                                    try {
                                        Map<String, Object> map = Utils.makeMap(Overseer.QUEUE_OPERATION, OverseerAction.REMOVEROUTINGRULE.toLower(), ZkStateReader.COLLECTION_PROP, collection, ZkStateReader.SHARD_ID_PROP, myShardId, "routeKey", routeKey + "!");
                                        SolrZkClient zkClient = req.getCore().getCoreContainer().getZkController().getZkClient();
                                        DistributedQueue queue = Overseer.getStateUpdateQueue(zkClient);
                                        queue.offer(Utils.toJSON(map));
                                    } catch (KeeperException e) {
                                        log.warn("Exception while removing routing rule for route key: " + routeKey, e);
                                    } catch (Exception e) {
                                        log.error("Exception while removing routing rule for route key: " + routeKey, e);
                                    } finally {
                                        ruleExpiryLock.unlock();
                                    }
                                }
                            } catch (InterruptedException e) {
                                Thread.currentThread().interrupt();
                            }
                        }
                    }
                }
            }
        }
    }
    return nodes;
}

Example 14 with Node

use of org.apache.solr.update.SolrCmdDistributor.Node in project lucene-solr by apache.

the class DistributedUpdateProcessor method doDeleteByQuery.

public void doDeleteByQuery(DeleteUpdateCommand cmd) throws IOException {
    // even in non zk mode, tests simulate updates from a leader
    if (!zkEnabled) {
        isLeader = getNonZkLeaderAssumption(req);
    } else {
        zkCheck();
    }
    // NONE: we are the first to receive this deleteByQuery
    //       - it must be forwarded to the leader of every shard
    // TO:   we are a leader receiving a forwarded deleteByQuery... we must:
    //       - block all updates (use VersionInfo)
    //       - flush *all* updates going to our replicas
    //       - forward the DBQ to our replicas and wait for the response
    //       - log + execute the local DBQ
    // FROM: we are a replica receiving a DBQ from our leader
    //       - log + execute the local DBQ
    DistribPhase phase = DistribPhase.parseParam(req.getParams().get(DISTRIB_UPDATE_PARAM));
    DocCollection coll = zkEnabled ? zkController.getClusterState().getCollection(collection) : null;
    if (zkEnabled && DistribPhase.NONE == phase) {
        // start off by assuming we are not a leader for any shard
        boolean leaderForAnyShard = false;
        ModifiableSolrParams outParams = new ModifiableSolrParams(filterParams(req.getParams()));
        outParams.set(DISTRIB_UPDATE_PARAM, DistribPhase.TOLEADER.toString());
        outParams.set(DISTRIB_FROM, ZkCoreNodeProps.getCoreUrl(zkController.getBaseUrl(), req.getCore().getName()));
        SolrParams params = req.getParams();
        String route = params.get(ShardParams._ROUTE_);
        Collection<Slice> slices = coll.getRouter().getSearchSlices(route, params, coll);
        List<Node> leaders = new ArrayList<>(slices.size());
        for (Slice slice : slices) {
            String sliceName = slice.getName();
            Replica leader;
            try {
                leader = zkController.getZkStateReader().getLeaderRetry(collection, sliceName);
            } catch (InterruptedException e) {
                throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE, "Exception finding leader for shard " + sliceName, e);
            }
            // TODO: What if leaders changed in the meantime?
            // should we send out slice-at-a-time and if a node returns "hey, I'm not a leader" (or we get an error because it went down) then look up the new leader?
            // Am I the leader for this slice?
            ZkCoreNodeProps coreLeaderProps = new ZkCoreNodeProps(leader);
            String leaderCoreNodeName = leader.getName();
            String coreNodeName = req.getCore().getCoreDescriptor().getCloudDescriptor().getCoreNodeName();
            isLeader = coreNodeName.equals(leaderCoreNodeName);
            if (isLeader) {
                // don't forward to ourself
                leaderForAnyShard = true;
            } else {
                leaders.add(new RetryNode(coreLeaderProps, zkController.getZkStateReader(), collection, sliceName));
            }
        }
        // this will be distributed from the local commit
        outParams.remove("commit");
        cmdDistrib.distribDelete(cmd, leaders, outParams);
        if (!leaderForAnyShard) {
            return;
        }
        // change the phase to TOLEADER so we look up and forward to our own replicas (if any)
        phase = DistribPhase.TOLEADER;
    }
    List<Node> replicas = null;
    if (zkEnabled && DistribPhase.TOLEADER == phase) {
        // This core should be a leader
        isLeader = true;
        replicas = setupRequestForDBQ();
    } else if (DistribPhase.FROMLEADER == phase) {
        isLeader = false;
    }
    if (vinfo == null) {
        super.processDelete(cmd);
        return;
    }
    // at this point, there is an update we need to try and apply.
    // we may or may not be the leader.
    boolean isReplayOrPeersync = (cmd.getFlags() & (UpdateCommand.REPLAY | UpdateCommand.PEER_SYNC)) != 0;
    boolean leaderLogic = isLeader && !isReplayOrPeersync;
    versionDeleteByQuery(cmd);
    if (zkEnabled) {
        // forward to all replicas
        ModifiableSolrParams params = new ModifiableSolrParams(filterParams(req.getParams()));
        params.set(CommonParams.VERSION_FIELD, Long.toString(cmd.getVersion()));
        params.set(DISTRIB_UPDATE_PARAM, DistribPhase.FROMLEADER.toString());
        params.set(DISTRIB_FROM, ZkCoreNodeProps.getCoreUrl(zkController.getBaseUrl(), req.getCore().getName()));
        boolean someReplicas = false;
        boolean subShardLeader = false;
        try {
            subShardLeader = amISubShardLeader(coll, null, null, null);
            if (subShardLeader) {
                String myShardId = req.getCore().getCoreDescriptor().getCloudDescriptor().getShardId();
                Replica leaderReplica = zkController.getZkStateReader().getLeaderRetry(collection, myShardId);
                // DBQ forwarded to NRT and TLOG replicas
                List<ZkCoreNodeProps> replicaProps = zkController.getZkStateReader().getReplicaProps(collection, myShardId, leaderReplica.getName(), null, Replica.State.DOWN, EnumSet.of(Replica.Type.NRT, Replica.Type.TLOG));
                if (replicaProps != null) {
                    final List<Node> myReplicas = new ArrayList<>(replicaProps.size());
                    for (ZkCoreNodeProps replicaProp : replicaProps) {
                        myReplicas.add(new StdNode(replicaProp, collection, myShardId));
                    }
                    cmdDistrib.distribDelete(cmd, myReplicas, params);
                    someReplicas = true;
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new ZooKeeperException(ErrorCode.SERVER_ERROR, "", e);
        }
        if (leaderLogic) {
            List<Node> subShardLeaders = getSubShardLeaders(coll, cloudDesc.getShardId(), null, null);
            if (subShardLeaders != null) {
                cmdDistrib.distribDelete(cmd, subShardLeaders, params, true);
            }
            final List<Node> nodesByRoutingRules = getNodesByRoutingRules(zkController.getClusterState(), coll, null, null);
            if (nodesByRoutingRules != null && !nodesByRoutingRules.isEmpty()) {
                params = new ModifiableSolrParams(filterParams(req.getParams()));
                params.set(DISTRIB_UPDATE_PARAM, DistribPhase.FROMLEADER.toString());
                params.set(DISTRIB_FROM, ZkCoreNodeProps.getCoreUrl(zkController.getBaseUrl(), req.getCore().getName()));
                params.set(DISTRIB_FROM_COLLECTION, req.getCore().getCoreDescriptor().getCloudDescriptor().getCollectionName());
                params.set(DISTRIB_FROM_SHARD, req.getCore().getCoreDescriptor().getCloudDescriptor().getShardId());
                cmdDistrib.distribDelete(cmd, nodesByRoutingRules, params, true);
            }
            if (replicas != null) {
                cmdDistrib.distribDelete(cmd, replicas, params);
                someReplicas = true;
            }
        }
        if (someReplicas) {
            cmdDistrib.blockAndDoRetries();
        }
    }
    if (returnVersions && rsp != null) {
        if (deleteByQueryResponse == null) {
            deleteByQueryResponse = new NamedList<String>(1);
            rsp.add("deleteByQuery", deleteByQueryResponse);
        }
        deleteByQueryResponse.add(cmd.getQuery(), cmd.getVersion());
    }
}