/** {@inheritDoc} */
@Override
public Map<K, V> peekAll(
@Nullable Collection<? extends K> keys,
@Nullable GridPredicate<? super GridCacheEntry<K, V>>[] filter) {
if (keys == null || keys.isEmpty()) return emptyMap();
final Collection<K> skipped = new GridLeanSet<K>();
final Map<K, V> map = peekAll0(keys, filter, skipped);
if (map.size() + skipped.size() != keys.size()) {
map.putAll(
dht.peekAll(
F.view(
keys,
new P1<K>() {
@Override
public boolean apply(K k) {
return !map.containsKey(k) && !skipped.contains(k);
}
}),
filter));
}
return map;
}
/** @throws Exception If failed. */
public void testCreateFileColocated() throws Exception {
GridGgfsPath path = new GridGgfsPath("/colocated");
UUID uuid = UUID.randomUUID();
GridUuid affKey;
long idx = 0;
while (true) {
affKey = new GridUuid(uuid, idx);
if (grid(0).mapKeyToNode(DATA_CACHE_NAME, affKey).id().equals(grid(0).localNode().id()))
break;
idx++;
}
try (GridGgfsOutputStream out = fs.create(path, 1024, true, affKey, 0, 1024, null)) {
// Write 5M, should be enough to test distribution.
for (int i = 0; i < 15; i++) out.write(new byte[1024 * 1024]);
}
GridGgfsFile info = fs.info(path);
Collection<GridGgfsBlockLocation> affNodes = fs.affinity(path, 0, info.length());
assertEquals(1, affNodes.size());
Collection<UUID> nodeIds = F.first(affNodes).nodeIds();
assertEquals(1, nodeIds.size());
assertEquals(grid(0).localNode().id(), F.first(nodeIds));
}
/** @param node Node to remove. */
public void removeMappedNode(GridNode node) {
if (mappedDhtNodes.contains(node))
mappedDhtNodes = new ArrayList<>(F.view(mappedDhtNodes, F.notEqualTo(node)));
if (mappedNearNodes != null && mappedNearNodes.contains(node))
mappedNearNodes = new ArrayList<>(F.view(mappedNearNodes, F.notEqualTo(node)));
}
/** {@inheritDoc} */
@Override
public void stopListenAsync(@Nullable GridInClosure<? super GridFuture<R>>... lsnr) {
if (F.isEmpty(lsnr))
synchronized (mux) {
lsnrs.clear();
}
else
synchronized (mux) {
lsnrs.removeAll(F.asList(lsnr));
}
}
/**
* Checks for explicit events configuration.
*
* @param ignite Grid instance.
* @return {@code true} if all task events explicitly specified in configuration.
*/
public static boolean checkExplicitTaskMonitoring(Ignite ignite) {
int[] evts = ignite.configuration().getIncludeEventTypes();
if (F.isEmpty(evts)) return false;
for (int evt : VISOR_TASK_EVTS) {
if (!F.contains(evts, evt)) return false;
}
return true;
}
/**
* Creates signature for data.
*
* @param alg Algorithm.
* @param prv Provider.
* @param key Private key.
* @param data Data.
* @return Signature.
* @throws GeneralSecurityException If any exception occurs while signature creation.
*/
public static byte[] createSignature(String alg, String prv, PrivateKey key, byte[] data)
throws GeneralSecurityException {
assert !F.isEmpty(alg);
assert !F.isEmpty(prv);
assert key != null;
assert data != null;
Signature sign = Signature.getInstance(alg, prv);
sign.initSign(key);
sign.update(data);
return sign.sign();
}
/** {@inheritDoc} */
@Override
public GridDeployment getDeployment(final GridUuid ldrId) {
synchronized (mux) {
return F.find(
F.flat(cache.values()),
null,
new P1<SharedDeployment>() {
@Override
public boolean apply(SharedDeployment d) {
return d.classLoaderId().equals(ldrId);
}
});
}
}
/**
* Verifies signature for data.
*
* @param alg Algorithm.
* @param prv Provider.
* @param key Public key.
* @param data Data.
* @param sign Signature.
* @return {@code true} if signature was verified, {@code false} - otherwise.
* @throws GeneralSecurityException If any exception occurs while verifying.
*/
public static boolean verifySignature(
String alg, String prv, PublicKey key, byte[] data, byte[] sign)
throws GeneralSecurityException {
assert !F.isEmpty(alg);
assert !F.isEmpty(prv);
assert key != null;
assert data != null;
assert sign != null;
Signature sign0 = Signature.getInstance(alg, prv);
sign0.initVerify(key);
sign0.update(data);
return sign0.verify(sign);
}
/**
* Adds owned versions to map.
*
* @param vers Map of owned versions.
*/
public void ownedVersions(Map<IgniteTxKey, GridCacheVersion> vers) {
if (F.isEmpty(vers)) return;
if (owned == null) owned = new GridLeanMap<>(vers.size());
owned.putAll(vers);
}
/**
* @param ctx Kernal context.
* @param cfg Ignite configuration.
* @param providers Plugin providers.
*/
@SuppressWarnings("TypeMayBeWeakened")
public IgnitePluginProcessor(
GridKernalContext ctx, IgniteConfiguration cfg, List<PluginProvider> providers) {
super(ctx);
ExtensionRegistryImpl registry = new ExtensionRegistryImpl();
for (PluginProvider provider : providers) {
GridPluginContext pluginCtx = new GridPluginContext(ctx, cfg);
if (F.isEmpty(provider.name())) throw new IgniteException("Plugin name can not be empty.");
if (plugins.containsKey(provider.name()))
throw new IgniteException("Duplicated plugin name: " + provider.name());
plugins.put(provider.name(), provider);
pluginCtxMap.put(provider, pluginCtx);
provider.initExtensions(pluginCtx, registry);
if (provider.plugin() == null) throw new IgniteException("Plugin is null.");
}
extensions = registry.createExtensionMap();
}
/** {@inheritDoc} */
@Override
public V unswap(K key) throws GridException {
ctx.denyOnFlags(F.asList(READ, SKIP_SWAP));
// Unswap only from DHT. Near cache does not have swap storage.
return dht.unswap(key);
}
/** {@inheritDoc} */
@Override
public Map<K, V> peekAll(
@Nullable Collection<? extends K> keys, @Nullable Collection<GridCachePeekMode> modes)
throws GridException {
if (keys == null || keys.isEmpty()) return emptyMap();
final Collection<K> skipped = new GridLeanSet<K>();
final Map<K, V> map =
!modes.contains(PARTITIONED_ONLY)
? peekAll0(keys, modes, ctx.tm().localTxx(), skipped)
: new GridLeanMap<K, V>(0);
if (map.size() != keys.size() && !modes.contains(NEAR_ONLY)) {
map.putAll(
dht.peekAll(
F.view(
keys,
new P1<K>() {
@Override
public boolean apply(K k) {
return !map.containsKey(k) && !skipped.contains(k);
}
}),
modes));
}
return map;
}
/** {@inheritDoc} */
@Override
public boolean apply(@Nullable T1 t1, @Nullable T2 t2) {
lazyCompile();
if (expr != null) {
JexlContext ctx = new MapContext();
ctx.set(var1, t1);
ctx.set(var2, t2);
for (Map.Entry<String, Object> e : map.entrySet()) {
ctx.set(e.getKey(), e.getValue());
}
try {
Object obj = expr.evaluate(ctx);
if (obj instanceof Boolean) {
return (Boolean) obj;
}
} catch (Exception ex) {
throw F.wrap(ex);
}
}
return false;
}
/**
* @return Query info.
* @throws GridException In case of error.
*/
@SuppressWarnings({"unchecked"})
private GridCacheQueryInfo localQueryInfo() throws GridException {
GridCacheQueryBean qry = query();
GridPredicate<GridCacheEntry<Object, Object>> prjPred =
qry.query().projectionFilter() == null
? F.<GridCacheEntry<Object, Object>>alwaysTrue()
: qry.query().projectionFilter();
GridMarshaller marsh = cctx.marshaller();
GridReducer<Object, Object> rdc =
qry.reducer() != null
? marsh.<GridReducer<Object, Object>>unmarshal(marsh.marshal(qry.reducer()), null)
: null;
GridClosure<Object, Object> trans =
qry.transform() != null
? marsh.<GridClosure<Object, Object>>unmarshal(marsh.marshal(qry.transform()), null)
: null;
return new GridCacheQueryInfo(
true,
prjPred,
trans,
rdc,
qry.query(),
GridCacheLocalQueryFuture.this,
ctx.localNodeId(),
cctx.io().nextIoId(),
qry.query().includeMetadata(),
true,
qry.arguments());
}
/**
* @param mapping Mapping to order.
* @param committedVers Committed versions.
* @param rolledbackVers Rolled back versions.
*/
void orderCompleted(
GridDistributedTxMapping<K, V> mapping,
Collection<GridCacheVersion> committedVers,
Collection<GridCacheVersion> rolledbackVers) {
for (GridCacheTxEntry<K, V> txEntry : F.concat(false, mapping.reads(), mapping.writes())) {
while (true) {
GridDistributedCacheEntry<K, V> entry = (GridDistributedCacheEntry<K, V>) txEntry.cached();
try {
// Handle explicit locks.
GridCacheVersion base =
txEntry.explicitVersion() != null ? txEntry.explicitVersion() : xidVer;
entry.doneRemote(xidVer, base, committedVers, rolledbackVers);
if (ec()) entry.recheck();
break;
} catch (GridCacheEntryRemovedException ignored) {
assert entry.obsoleteVersion() != null;
if (log.isDebugEnabled())
log.debug(
"Replacing obsolete entry in remote transaction [entry="
+ entry
+ ", tx="
+ this
+ ']');
// Replace the entry.
txEntry.cached(cctx.cache().entryEx(txEntry.key()), entry.keyBytes());
}
}
}
}
/** {@inheritDoc} */
@Override
public String cacheName() {
try {
return (String) job.getDeployment().annotatedValue(job.getJob(), GridCacheName.class);
} catch (GridException e) {
throw F.wrap(e);
}
}
/** {@inheritDoc} */
@Override
public <T> T affinityKey() {
try {
return (T) job.getDeployment().annotatedValue(job.getJob(), GridCacheAffinityMapped.class);
} catch (GridException e) {
throw F.wrap(e);
}
}
/**
* @param id ID.
* @param name Name.
* @param age Age.
* @param orgId Organization ID.
*/
private Person(int id, String name, int age, int orgId) {
assert !F.isEmpty(name);
assert age > 0;
assert orgId > 0;
this.id = id;
this.name = name;
this.age = age;
this.orgId = orgId;
}
/**
* @param keys Keys.
* @param timeout Timeout.
* @param tx Transaction.
* @param filter Filter.
* @return Future.
*/
public GridFuture<Boolean> lockAllAsync(
Collection<? extends K> keys,
long timeout,
@Nullable GridCacheTxLocalEx<K, V> tx,
GridPredicate<? super GridCacheEntry<K, V>>[] filter) {
if (F.isEmpty(keys)) {
return new GridFinishedFuture<Boolean>(ctx.kernalContext(), true);
}
GridLocalLockFuture<K, V> fut =
new GridLocalLockFuture<K, V>(ctx, keys, tx, this, timeout, filter);
try {
for (K key : keys) {
while (true) {
GridLocalCacheEntry<K, V> entry = null;
try {
entry = entryExx(key);
if (!ctx.isAll(entry, filter)) {
fut.onFailed();
return fut;
}
// Removed exception may be thrown here.
GridCacheMvccCandidate<K> cand = fut.addEntry(entry);
if (cand == null && fut.isDone()) {
return fut;
}
break;
} catch (GridCacheEntryRemovedException ignored) {
if (log().isDebugEnabled()) {
log().debug("Got removed entry in lockAsync(..) method (will retry): " + entry);
}
}
}
}
if (!ctx.mvcc().addFuture(fut))
fut.onError(new GridException("Duplicate future ID (internal error): " + fut));
// Must have future added prior to checking locks.
fut.checkLocks();
return fut;
} catch (GridException e) {
fut.onError(e);
return fut;
}
}
/** {@inheritDoc} */
@SuppressWarnings("deprecation")
@Override
public void start() throws IgniteException {
if (sesFactory == null && F.isEmpty(hibernateCfgPath))
throw new IgniteException(
"Either session factory or Hibernate configuration file is required by "
+ getClass().getSimpleName()
+ '.');
if (!F.isEmpty(hibernateCfgPath)) {
if (sesFactory == null) {
try {
URL url = new URL(hibernateCfgPath);
sesFactory = new Configuration().configure(url).buildSessionFactory();
} catch (MalformedURLException ignored) {
// No-op.
}
if (sesFactory == null) {
File cfgFile = new File(hibernateCfgPath);
if (cfgFile.exists())
sesFactory = new Configuration().configure(cfgFile).buildSessionFactory();
}
if (sesFactory == null)
sesFactory = new Configuration().configure(hibernateCfgPath).buildSessionFactory();
if (sesFactory == null)
throw new IgniteException(
"Failed to resolve Hibernate configuration file: " + hibernateCfgPath);
closeSesOnStop = true;
} else
U.warn(
log,
"Hibernate configuration file configured in "
+ getClass().getSimpleName()
+ " will be ignored (session factory is already set).");
}
}
/**
* @param pid PID of the other party.
* @param size Size of the space.
* @return Token pair.
*/
private IgnitePair<String> inOutToken(int pid, int size) {
while (true) {
long idx = tokIdxGen.get();
if (tokIdxGen.compareAndSet(idx, idx + 2))
return F.pair(
new File(tokDir, TOKEN_FILE_NAME + idx + "-" + pid + "-" + size).getAbsolutePath(),
new File(tokDir, TOKEN_FILE_NAME + (idx + 1) + "-" + pid + "-" + size)
.getAbsolutePath());
}
}
/**
* Parses HTTP parameters in an appropriate format and return back map of values to predefined
* list of names.
*
* @param req Request.
* @return Map of parsed parameters.
*/
@SuppressWarnings({"unchecked"})
private Map<String, Object> parameters(ServletRequest req) {
Map<String, String[]> params = req.getParameterMap();
if (F.isEmpty(params)) return Collections.emptyMap();
Map<String, Object> map = U.newHashMap(params.size());
for (Map.Entry<String, String[]> entry : params.entrySet())
map.put(entry.getKey(), parameter(entry.getValue()));
return map;
}
/**
* Run command in separated console.
*
* @param workFolder Work folder for command.
* @param args A string array containing the program and its arguments.
* @return Started process.
* @throws IOException If failed to start process.
*/
public static Process openInConsole(@Nullable File workFolder, String... args)
throws IOException {
String[] commands = args;
String cmd = F.concat(Arrays.asList(args), " ");
if (U.isWindows()) commands = F.asArray("cmd", "/c", String.format("start %s", cmd));
if (U.isMacOs())
commands =
F.asArray(
"osascript",
"-e",
String.format("tell application \"Terminal\" to do script \"%s\"", cmd));
if (U.isUnix()) commands = F.asArray("xterm", "-sl", "1024", "-geometry", "200x50", "-e", cmd);
ProcessBuilder pb = new ProcessBuilder(commands);
if (workFolder != null) pb.directory(workFolder);
return pb.start();
}
/** @return Involved nodes. */
@Override
public Collection<? extends GridNode> nodes() {
return F.viewReadOnly(
futures(),
new GridClosure<GridFuture<?>, GridRichNode>() {
@Nullable
@Override
public GridRichNode apply(GridFuture<?> f) {
if (isMini(f)) return ((MiniFuture) f).node();
return cctx.rich().rich(cctx.discovery().localNode());
}
});
}
/** {@inheritDoc} */
@Override
public Iterator<GridCacheEntry<K, V>> iterator() {
return new EntryIterator(
nearSet.iterator(),
F.iterator0(
dhtSet,
false,
new P1<GridCacheEntry<K, V>>() {
@Override
public boolean apply(GridCacheEntry<K, V> e) {
return !GridNearCache.super.containsKey(e.getKey(), null);
}
}));
}
/**
* Checks {@link GridSystemProperties#GG_JETTY_PORT} system property and overrides default
* connector port if it present. Then initializes {@code port} with the found value.
*
* @param con Jetty connector.
*/
private void override(AbstractNetworkConnector con) {
String host = System.getProperty(GG_JETTY_HOST);
if (!F.isEmpty(host)) con.setHost(host);
int currPort = con.getPort();
Integer overridePort = Integer.getInteger(GG_JETTY_PORT);
if (overridePort != null && overridePort != 0) currPort = overridePort;
con.setPort(currPort);
port = currPort;
}
/** @param mappings Mappings. */
void addEntryMapping(@Nullable Map<UUID, GridDistributedTxMapping<K, V>> mappings) {
if (!F.isEmpty(mappings)) {
this.mappings.putAll(mappings);
if (log.isDebugEnabled())
log.debug(
"Added mappings to transaction [locId="
+ cctx.nodeId()
+ ", mappings="
+ mappings
+ ", tx="
+ this
+ ']');
}
}
/** {@inheritDoc} */
@Override
public GridFuture<Map<K, V>> getAllAsync(
@Nullable Collection<? extends K> keys,
@Nullable GridPredicate<? super GridCacheEntry<K, V>>[] filter) {
ctx.denyOnFlag(LOCAL);
if (F.isEmpty(keys))
return new GridFinishedFuture<Map<K, V>>(ctx.kernalContext(), Collections.<K, V>emptyMap());
GridCacheTxLocalAdapter<K, V> tx = ctx.tm().threadLocalTx();
if (tx != null && !tx.implicit()) return ctx.wrapCloneMap(tx.getAllAsync(keys, filter));
return loadAsync(keys, false, filter);
}
/**
* @param ldr Loader.
* @param nodeId Sender node ID.
* @param req Request.
* @return Remote transaction.
* @throws GridException If failed.
*/
@Nullable
public GridNearTxRemote<K, V> startRemoteTx(
ClassLoader ldr, UUID nodeId, GridDhtTxPrepareRequest<K, V> req) throws GridException {
if (!F.isEmpty(req.nearWrites())) {
GridNearTxRemote<K, V> tx =
new GridNearTxRemote<K, V>(
ldr,
nodeId,
req.nearNodeId(),
req.threadId(),
req.version(),
req.commitVersion(),
req.concurrency(),
req.isolation(),
req.isInvalidate(),
req.timeout(),
req.nearWrites(),
ctx);
if (!tx.empty()) {
tx = ctx.tm().onCreated(tx);
if (tx == null || !ctx.tm().onStarted(tx))
throw new GridCacheTxRollbackException("Attempt to start a completed transaction: " + tx);
// Prepare prior to reordering, so the pending locks added
// in prepare phase will get properly ordered as well.
tx.prepare();
// Add remote candidates and reorder completed and uncompleted versions.
tx.addRemoteCandidates(
req.candidatesByKey(), req.committedVersions(), req.rolledbackVersions());
if (req.concurrency() == EVENTUALLY_CONSISTENT) {
if (log.isDebugEnabled())
log.debug("Committing transaction during remote prepare: " + tx);
tx.commit();
if (log.isDebugEnabled()) log.debug("Committed transaction during remote prepare: " + tx);
}
}
return tx;
}
return null;
}
/**
* @param keys Keys to load.
* @param reload Reload flag.
* @param filter Filter.
* @return Loaded values.
*/
public GridFuture<Map<K, V>> loadAsync(
@Nullable Collection<? extends K> keys,
boolean reload,
@Nullable GridPredicate<? super GridCacheEntry<K, V>>[] filter) {
if (F.isEmpty(keys))
return new GridFinishedFuture<Map<K, V>>(ctx.kernalContext(), Collections.<K, V>emptyMap());
GridNearGetFuture<K, V> fut = new GridNearGetFuture<K, V>(ctx, keys, reload, null, filter);
// Register future for responses.
ctx.mvcc().addFuture(fut);
fut.init();
return ctx.wrapCloneMap(fut);
}
