Examples with IgniteInternalFuture org.apache.ignite.internal.IgniteInternalFuture used on opensource projects

Example 61 with IgniteInternalFuture

use of org.apache.ignite.internal.IgniteInternalFuture in project ignite by apache.

the class GridQueryProcessor method onCacheStart0.

/**
 * Create type descriptors from schema and initialize indexing for given cache.<p>
 * Use with {@link #busyLock} where appropriate.
 * @param cctx Cache context.
 * @param schema Initial schema.
 * @throws IgniteCheckedException If failed.
 */
@SuppressWarnings({ "deprecation", "ThrowableResultOfMethodCallIgnored" })
public void onCacheStart0(GridCacheContext<?, ?> cctx, QuerySchema schema) throws IgniteCheckedException {
    cctx.shared().database().checkpointReadLock();
    try {
        synchronized (stateMux) {
            boolean escape = cctx.config().isSqlEscapeAll();
            String cacheName = cctx.name();
            String schemaName = QueryUtils.normalizeSchemaName(cacheName, cctx.config().getSqlSchema());
            // Prepare candidates.
            List<Class<?>> mustDeserializeClss = new ArrayList<>();
            Collection<QueryTypeCandidate> cands = new ArrayList<>();
            Collection<QueryEntity> qryEntities = schema.entities();
            if (!F.isEmpty(qryEntities)) {
                for (QueryEntity qryEntity : qryEntities) {
                    QueryTypeCandidate cand = QueryUtils.typeForQueryEntity(cacheName, schemaName, cctx, qryEntity, mustDeserializeClss, escape);
                    cands.add(cand);
                }
            }
            // Ensure that candidates has unique index names.
            // Otherwise we will not be able to apply pending operations.
            Map<String, QueryTypeDescriptorImpl> tblTypMap = new HashMap<>();
            Map<String, QueryTypeDescriptorImpl> idxTypMap = new HashMap<>();
            for (QueryTypeCandidate cand : cands) {
                QueryTypeDescriptorImpl desc = cand.descriptor();
                QueryTypeDescriptorImpl oldDesc = tblTypMap.put(desc.tableName(), desc);
                if (oldDesc != null)
                    throw new IgniteException("Duplicate table name [cache=" + cacheName + ",tblName=" + desc.tableName() + ", type1=" + desc.name() + ", type2=" + oldDesc.name() + ']');
                for (String idxName : desc.indexes().keySet()) {
                    oldDesc = idxTypMap.put(idxName, desc);
                    if (oldDesc != null)
                        throw new IgniteException("Duplicate index name [cache=" + cacheName + ",idxName=" + idxName + ", type1=" + desc.name() + ", type2=" + oldDesc.name() + ']');
                }
            }
            // There could be only one in-flight operation for a cache.
            for (SchemaOperation op : schemaOps.values()) {
                if (F.eq(op.proposeMessage().deploymentId(), cctx.dynamicDeploymentId())) {
                    if (op.started()) {
                        SchemaOperationWorker worker = op.manager().worker();
                        assert !worker.cacheRegistered();
                        if (!worker.nop()) {
                            IgniteInternalFuture fut = worker.future();
                            assert fut.isDone();
                            if (fut.error() == null) {
                                SchemaAbstractOperation op0 = op.proposeMessage().operation();
                                if (op0 instanceof SchemaIndexCreateOperation) {
                                    SchemaIndexCreateOperation opCreate = (SchemaIndexCreateOperation) op0;
                                    QueryTypeDescriptorImpl typeDesc = tblTypMap.get(opCreate.tableName());
                                    assert typeDesc != null;
                                    QueryUtils.processDynamicIndexChange(opCreate.indexName(), opCreate.index(), typeDesc);
                                } else if (op0 instanceof SchemaIndexDropOperation) {
                                    SchemaIndexDropOperation opDrop = (SchemaIndexDropOperation) op0;
                                    QueryTypeDescriptorImpl typeDesc = idxTypMap.get(opDrop.indexName());
                                    assert typeDesc != null;
                                    QueryUtils.processDynamicIndexChange(opDrop.indexName(), null, typeDesc);
                                } else if (op0 instanceof SchemaAlterTableAddColumnOperation) {
                                    SchemaAlterTableAddColumnOperation opAddCol = (SchemaAlterTableAddColumnOperation) op0;
                                    QueryTypeDescriptorImpl typeDesc = tblTypMap.get(opAddCol.tableName());
                                    assert typeDesc != null;
                                    processDynamicAddColumn(typeDesc, opAddCol.columns());
                                } else if (op0 instanceof SchemaAlterTableDropColumnOperation) {
                                    SchemaAlterTableDropColumnOperation opDropCol = (SchemaAlterTableDropColumnOperation) op0;
                                    QueryTypeDescriptorImpl typeDesc = tblTypMap.get(opDropCol.tableName());
                                    assert typeDesc != null;
                                    processDynamicDropColumn(typeDesc, opDropCol.columns());
                                } else
                                    assert false;
                            }
                        }
                    }
                    break;
                }
            }
            // Ready to register at this point.
            registerCache0(cacheName, schemaName, cctx, cands);
            // Warn about possible implicit deserialization.
            if (!mustDeserializeClss.isEmpty()) {
                U.warnDevOnly(log, "Some classes in query configuration cannot be written in binary format " + "because they either implement Externalizable interface or have writeObject/readObject " + "methods. Instances of these classes will be deserialized in order to build indexes. Please " + "ensure that all nodes have these classes in classpath. To enable binary serialization " + "either implement " + Binarylizable.class.getSimpleName() + " interface or set explicit " + "serializer using BinaryTypeConfiguration.setSerializer() method: " + mustDeserializeClss);
            }
        }
    } finally {
        cctx.shared().database().checkpointReadUnlock();
    }
}

Example 62 with IgniteInternalFuture

use of org.apache.ignite.internal.IgniteInternalFuture in project ignite by apache.

the class GridNearAtomicSingleUpdateFuture method waitAndRemap.

/**
 * @param remapTopVer New topology version.
 */
private void waitAndRemap(AffinityTopologyVersion remapTopVer) {
    if (topLocked) {
        CachePartialUpdateCheckedException e = new CachePartialUpdateCheckedException("Failed to update keys (retry update if possible).");
        ClusterTopologyCheckedException cause = new ClusterTopologyCheckedException("Failed to update keys, topology changed while execute atomic update inside transaction.");
        cause.retryReadyFuture(cctx.affinity().affinityReadyFuture(remapTopVer));
        e.add(Collections.singleton(cctx.toCacheKeyObject(key)), cause);
        completeFuture(null, e, null);
        return;
    }
    IgniteInternalFuture<AffinityTopologyVersion> fut = cctx.shared().exchange().affinityReadyFuture(remapTopVer);
    if (fut == null)
        fut = new GridFinishedFuture<>(remapTopVer);
    fut.listen(new CI1<IgniteInternalFuture<AffinityTopologyVersion>>() {

        @Override
        public void apply(final IgniteInternalFuture<AffinityTopologyVersion> fut) {
            cctx.kernalContext().closure().runLocalSafe(new Runnable() {

                @Override
                public void run() {
                    mapOnTopology();
                }
            });
        }
    });
}

Example 63 with IgniteInternalFuture

use of org.apache.ignite.internal.IgniteInternalFuture in project ignite by apache.

the class GridRestProcessor method handleAsync0.

/**
 * @param req Request.
 * @return Future.
 */
private IgniteInternalFuture<GridRestResponse> handleAsync0(final GridRestRequest req) {
    if (!busyLock.tryReadLock())
        return new GridFinishedFuture<>(new IgniteCheckedException("Failed to handle request (received request while stopping grid)."));
    try {
        final GridWorkerFuture<GridRestResponse> fut = new GridWorkerFuture<>();
        workersCnt.increment();
        GridWorker w = new GridWorker(ctx.igniteInstanceName(), "rest-proc-worker", log) {

            @Override
            protected void body() {
                try {
                    IgniteInternalFuture<GridRestResponse> res = handleRequest(req);
                    res.listen(new IgniteInClosure<IgniteInternalFuture<GridRestResponse>>() {

                        @Override
                        public void apply(IgniteInternalFuture<GridRestResponse> f) {
                            try {
                                fut.onDone(f.get());
                            } catch (IgniteCheckedException e) {
                                fut.onDone(e);
                            }
                        }
                    });
                } catch (Throwable e) {
                    if (e instanceof Error)
                        U.error(log, "Client request execution failed with error.", e);
                    fut.onDone(U.cast(e));
                    if (e instanceof Error)
                        throw e;
                } finally {
                    workersCnt.decrement();
                }
            }
        };
        fut.setWorker(w);
        try {
            ctx.getRestExecutorService().execute(w);
        } catch (RejectedExecutionException e) {
            U.error(log, "Failed to execute worker due to execution rejection " + "(increase upper bound on REST executor service). " + "Will attempt to process request in the current thread instead.", e);
            w.run();
        }
        return fut;
    } finally {
        busyLock.readUnlock();
    }
}

Example 64 with IgniteInternalFuture

use of org.apache.ignite.internal.IgniteInternalFuture in project ignite by apache.

the class GridNearAtomicSingleUpdateFuture method mapOnTopology.

/**
 * {@inheritDoc}
 */
@Override
protected void mapOnTopology() {
    AffinityTopologyVersion topVer;
    if (cache.topology().stopping()) {
        completeFuture(null, new CacheStoppedException(cache.name()), null);
        return;
    }
    GridDhtTopologyFuture fut = cache.topology().topologyVersionFuture();
    if (fut.isDone()) {
        Throwable err = fut.validateCache(cctx, recovery, /*read*/
        false, key, null);
        if (err != null) {
            completeFuture(null, err, null);
            return;
        }
        topVer = fut.topologyVersion();
    } else {
        assert !topLocked : this;
        fut.listen(new CI1<IgniteInternalFuture<AffinityTopologyVersion>>() {

            @Override
            public void apply(IgniteInternalFuture<AffinityTopologyVersion> t) {
                cctx.kernalContext().closure().runLocalSafe(new Runnable() {

                    @Override
                    public void run() {
                        mapOnTopology();
                    }
                });
            }
        });
        return;
    }
    map(topVer);
}

Example 65 with IgniteInternalFuture

use of org.apache.ignite.internal.IgniteInternalFuture in project ignite by apache.

the class GridCacheCommandHandler method handleAsync.

/**
 * {@inheritDoc}
 */
@Override
public IgniteInternalFuture<GridRestResponse> handleAsync(final GridRestRequest req) {
    assert req instanceof GridRestCacheRequest : "Invalid command for topology handler: " + req;
    assert SUPPORTED_COMMANDS.contains(req.command());
    if (log.isDebugEnabled())
        log.debug("Handling cache REST request: " + req);
    GridRestCacheRequest req0 = (GridRestCacheRequest) req;
    final String cacheName = req0.cacheName() == null ? DFLT_CACHE_NAME : req0.cacheName();
    final Object key = req0.key();
    final Set<GridClientCacheFlag> cacheFlags = GridClientCacheFlag.parseCacheFlags(req0.cacheFlags());
    try {
        GridRestCommand cmd = req0.command();
        if (key == null && KEY_REQUIRED_REQUESTS.contains(cmd))
            throw new IgniteCheckedException(GridRestCommandHandlerAdapter.missingParameter("key"));
        final Long ttl = req0.ttl();
        IgniteInternalFuture<GridRestResponse> fut;
        switch(cmd) {
            case DESTROY_CACHE:
                {
                    // Do not check thread tx here since there can be active system cache txs.
                    fut = ((IgniteKernal) ctx.grid()).destroyCacheAsync(cacheName, false, false).chain(new CX1<IgniteInternalFuture<?>, GridRestResponse>() {

                        @Override
                        public GridRestResponse applyx(IgniteInternalFuture<?> f) throws IgniteCheckedException {
                            f.get();
                            return new GridRestResponse(null);
                        }
                    });
                    break;
                }
            case GET_OR_CREATE_CACHE:
                {
                    String templateName = req0.templateName();
                    if (F.isEmpty(templateName))
                        templateName = TEMPLATE_PARTITIONED;
                    CacheConfigurationOverride cfgOverride = req0.configuration();
                    boolean dfltPartTemplate = F.isEmpty(templateName) || TEMPLATE_PARTITIONED.equalsIgnoreCase(templateName);
                    boolean dfltReplTemplate = TEMPLATE_REPLICATED.equalsIgnoreCase(templateName);
                    if (dfltPartTemplate || dfltReplTemplate) {
                        if (cfgOverride == null)
                            cfgOverride = new CacheConfigurationOverride();
                        cfgOverride.mode(dfltPartTemplate ? PARTITIONED : REPLICATED);
                        if (cfgOverride.writeSynchronizationMode() == null)
                            cfgOverride.writeSynchronizationMode(FULL_SYNC);
                    }
                    // Do not check thread tx here since there can be active system cache txs.
                    fut = ((IgniteKernal) ctx.grid()).getOrCreateCacheAsync(cacheName, templateName, cfgOverride, false).chain(new CX1<IgniteInternalFuture<?>, GridRestResponse>() {

                        @Override
                        public GridRestResponse applyx(IgniteInternalFuture<?> f) throws IgniteCheckedException {
                            f.get();
                            return new GridRestResponse(null);
                        }
                    });
                    break;
                }
            case CACHE_METADATA:
                {
                    fut = ctx.task().execute(MetadataTask.class, req0.cacheName());
                    break;
                }
            case CACHE_CONTAINS_KEYS:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new ContainsKeysCommand(getKeys(req0)));
                    break;
                }
            case CACHE_CONTAINS_KEY:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new ContainsKeyCommand(key));
                    break;
                }
            case CACHE_GET:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new GetCommand(key));
                    break;
                }
            case CACHE_GET_AND_PUT:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new GetAndPutCommand(key, getValue(req0)));
                    break;
                }
            case CACHE_GET_AND_REPLACE:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new GetAndReplaceCommand(key, getValue(req0)));
                    break;
                }
            case CACHE_GET_AND_PUT_IF_ABSENT:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new GetAndPutIfAbsentCommand(key, getValue(req0)));
                    break;
                }
            case CACHE_PUT_IF_ABSENT:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new PutIfAbsentCommand(key, ttl, getValue(req0)));
                    break;
                }
            case CACHE_GET_ALL:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new GetAllCommand(getKeys(req0)));
                    break;
                }
            case CACHE_PUT:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new PutCommand(key, ttl, getValue(req0)));
                    break;
                }
            case CACHE_ADD:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new AddCommand(key, ttl, getValue(req0)));
                    break;
                }
            case CACHE_PUT_ALL:
                {
                    Map<Object, Object> map = req0.values();
                    if (F.isEmpty(map))
                        throw new IgniteCheckedException(GridRestCommandHandlerAdapter.missingParameter("values"));
                    for (Map.Entry<Object, Object> e : map.entrySet()) {
                        if (e.getKey() == null)
                            throw new IgniteCheckedException("Failing putAll operation (null keys are not allowed).");
                        if (e.getValue() == null)
                            throw new IgniteCheckedException("Failing putAll operation (null values are not allowed).");
                    }
                    // HashMap wrapping for correct serialization
                    map = new HashMap<>(map);
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new PutAllCommand(map));
                    break;
                }
            case CACHE_REMOVE:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new RemoveCommand(key));
                    break;
                }
            case CACHE_REMOVE_VALUE:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new RemoveValueCommand(key, getValue(req0)));
                    break;
                }
            case CACHE_REPLACE_VALUE:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new ReplaceValueCommand(key, getValue(req0), req0.value2()));
                    break;
                }
            case CACHE_GET_AND_REMOVE:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new GetAndRemoveCommand(key));
                    break;
                }
            case CACHE_REMOVE_ALL:
                {
                    Map<Object, Object> map = req0.values();
                    // HashSet wrapping for correct serialization
                    Set<Object> keys = map == null ? null : new HashSet<>(map.keySet());
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new RemoveAllCommand(keys));
                    break;
                }
            case CACHE_CLEAR:
                {
                    Map<Object, Object> map = req0.values();
                    // HashSet wrapping for correct serialization
                    Set<Object> cacheNames = map == null ? new HashSet<Object>(ctx.cache().publicCacheNames()) : new HashSet<>(map.keySet());
                    GridCompoundFuture compFut = new GridCompoundFuture();
                    for (Object cName : cacheNames) compFut.add(executeCommand(req.destinationId(), req.clientId(), (String) cName, cacheFlags, key, new RemoveAllCommand(null)));
                    compFut.markInitialized();
                    fut = compFut.chain(new CX1<GridCompoundFuture<GridCacheRestResponse, ?>, GridRestResponse>() {

                        @Override
                        public GridRestResponse applyx(GridCompoundFuture<GridCacheRestResponse, ?> cf) throws IgniteCheckedException {
                            boolean success = true;
                            for (IgniteInternalFuture<GridCacheRestResponse> f : cf.futures()) if ((Boolean) f.get().getResponse() != true)
                                success = false;
                            GridCacheRestResponse resp = new GridCacheRestResponse();
                            if (success)
                                resp.setResponse(true);
                            else
                                resp.setResponse(false);
                            return resp;
                        }
                    });
                    break;
                }
            case CACHE_REPLACE:
                {
                    final Object val = req0.value();
                    if (val == null)
                        throw new IgniteCheckedException(GridRestCommandHandlerAdapter.missingParameter("val"));
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new ReplaceCommand(key, ttl, val));
                    break;
                }
            case CACHE_CAS:
                {
                    final Object val1 = req0.value();
                    final Object val2 = req0.value2();
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new CasCommand(val2, val1, key));
                    break;
                }
            case CACHE_APPEND:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new AppendCommand(key, req0));
                    break;
                }
            case CACHE_PREPEND:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, cacheFlags, key, new PrependCommand(key, req0));
                    break;
                }
            case CACHE_METRICS:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, key, new MetricsCommand());
                    break;
                }
            case CACHE_SIZE:
                {
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, key, new SizeCommand());
                    break;
                }
            case CACHE_UPDATE_TLL:
                {
                    if (ttl == null)
                        throw new IgniteCheckedException(GridRestCommandHandlerAdapter.missingParameter("ttl"));
                    fut = executeCommand(req.destinationId(), req.clientId(), cacheName, key, new UpdateTllCommand(key, ttl));
                    break;
                }
            default:
                throw new IllegalArgumentException("Invalid command for cache handler: " + req);
        }
        return fut;
    } catch (IgniteException | IgniteCheckedException e) {
        U.error(log, "Failed to execute cache command: " + req, e);
        return new GridFinishedFuture<>(e);
    } finally {
        if (log.isDebugEnabled())
            log.debug("Handled cache REST request: " + req);
    }
}