From af27a0d6a020e308a8ebb83583a9923c17c07252 Mon Sep 17 00:00:00 2001 From: Mikhail Petrov Date: Mon, 6 Oct 2025 14:17:10 +0300 Subject: [PATCH 1/5] IGNITE-26608 --- .../common/ComputeTaskPermissionsTest.java | 6 +- .../internal/thread/context/Scope.java} | 32 +- .../context/ScopedAttributeValueStack.java | 117 ++++++ .../thread/context/ThreadContext.java | 62 +++ .../context/ThreadContextAttribute.java | 43 ++ .../ThreadContextAttributeRegistry.java | 71 ++++ .../context/ThreadContextAwareWrapper.java | 59 +++ .../thread/context/ThreadContextData.java | 127 ++++++ .../thread/context/ThreadContextScope.java | 57 +++ .../thread/context/ThreadContextSnapshot.java | 76 ++++ .../ThreadContextAwareExecutor.java | 47 +++ .../function/ThreadContextAwareCallable.java | 73 ++++ .../function/ThreadContextAwareRunnable.java | 58 +++ .../ignite/internal/IgniteSchedulerImpl.java | 6 +- .../internal/SecurityAwareBiPredicate.java | 4 +- .../internal/SecurityAwarePredicate.java | 4 +- .../consistency/ConsistencyRepairTask.java | 4 +- .../managers/communication/GridIoManager.java | 6 +- .../discovery/GridDiscoveryManager.java | 8 +- .../processors/cache/GridCacheAdapter.java | 4 +- .../GridCachePartitionExchangeManager.java | 6 +- .../cache/ValidationOnNodeJoinUtils.java | 4 +- .../query/continuous/SecurityAwareFilter.java | 4 +- .../SecurityAwareTransformerFactory.java | 4 +- .../processors/job/GridJobWorker.java | 6 +- .../odbc/ClientListenerNioListener.java | 6 +- .../processors/pool/PoolProcessor.java | 19 +- .../processors/rest/GridRestProcessor.java | 4 +- .../processors/security/IgniteSecurity.java | 49 ++- .../security/IgniteSecurityProcessor.java | 45 +- .../security/NoOpIgniteSecurityProcessor.java | 16 +- .../processors/security/SecurityUtils.java | 5 +- .../thread/SecurityAwareCallable.java | 76 ---- .../thread/SecurityAwareRunnable.java | 62 --- .../service/IgniteServiceProcessor.java | 4 +- .../pool/ThreadContextAwareIoPool.java} | 32 +- .../ThreadContextAwareStripedExecutor.java} | 43 +- ...ontextAwareStripedThreadPoolExecutor.java} | 28 +- ...ThreadContextAwareThreadPoolExecutor.java} | 47 +-- .../AuthenticationProcessorSelfTest.java | 12 +- .../context/ThreadContextAttributesTest.java | 390 ++++++++++++++++++ .../ignite/testsuites/SecurityTestSuite.java | 2 + 42 files changed, 1352 insertions(+), 376 deletions(-) rename modules/{core/src/main/java/org/apache/ignite/internal/processors/security/OperationSecurityContext.java => commons/src/main/java/org/apache/ignite/internal/thread/context/Scope.java} (55%) create mode 100644 modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ScopedAttributeValueStack.java create mode 100644 modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContext.java create mode 100644 modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextAttribute.java create mode 100644 modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextAttributeRegistry.java create mode 100644 modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextAwareWrapper.java create mode 100644 modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextData.java create mode 100644 modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextScope.java create mode 100644 modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextSnapshot.java create mode 100644 modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/ThreadContextAwareExecutor.java create mode 100644 modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/ThreadContextAwareCallable.java create mode 100644 modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/ThreadContextAwareRunnable.java delete mode 100644 modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareCallable.java delete mode 100644 modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareRunnable.java rename modules/core/src/main/java/org/apache/ignite/internal/{processors/security/thread/SecurityAwareIoPool.java => thread/context/pool/ThreadContextAwareIoPool.java} (58%) rename modules/core/src/main/java/org/apache/ignite/internal/{processors/security/thread/SecurityAwareStripedExecutor.java => thread/context/pool/ThreadContextAwareStripedExecutor.java} (59%) rename modules/core/src/main/java/org/apache/ignite/internal/{processors/security/thread/SecurityAwareStripedThreadPoolExecutor.java => thread/context/pool/ThreadContextAwareStripedThreadPoolExecutor.java} (59%) rename modules/core/src/main/java/org/apache/ignite/internal/{processors/security/thread/SecurityAwareThreadPoolExecutor.java => thread/context/pool/ThreadContextAwareThreadPoolExecutor.java} (65%) create mode 100644 modules/core/src/test/java/org/apache/ignite/internal/thread/context/ThreadContextAttributesTest.java diff --git a/modules/clients/src/test/java/org/apache/ignite/common/ComputeTaskPermissionsTest.java b/modules/clients/src/test/java/org/apache/ignite/common/ComputeTaskPermissionsTest.java index 390478bef794b..faf54855d73fb 100644 --- a/modules/clients/src/test/java/org/apache/ignite/common/ComputeTaskPermissionsTest.java +++ b/modules/clients/src/test/java/org/apache/ignite/common/ComputeTaskPermissionsTest.java @@ -50,12 +50,12 @@ import org.apache.ignite.internal.IgniteEx; import org.apache.ignite.internal.management.cache.VerifyBackupPartitionsTask; import org.apache.ignite.internal.processors.security.AbstractSecurityTest; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; import org.apache.ignite.internal.processors.security.PublicAccessJob; import org.apache.ignite.internal.processors.security.SecurityContext; import org.apache.ignite.internal.processors.security.compute.ComputePermissionCheckTest; import org.apache.ignite.internal.processors.security.impl.TestSecurityData; import org.apache.ignite.internal.processors.security.impl.TestSecurityPluginProvider; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.lang.ConsumerX; import org.apache.ignite.internal.util.lang.RunnableX; import org.apache.ignite.internal.util.lang.gridfunc.AtomicIntegerFactoryCallable; @@ -379,7 +379,7 @@ public void testSystemTaskCancel() throws Exception { SecurityContext initiatorSecCtx = securityContext("no-permissions-login-0"); SupplierX> starter = () -> { - try (OperationSecurityContext ignored1 = grid(0).context().security().withContext(initiatorSecCtx)) { + try (Scope ignored1 = grid(0).context().security().withContext(initiatorSecCtx)) { return new TestFutureAdapter<>( grid(0).context().closure().runAsync( BROADCAST, @@ -429,7 +429,7 @@ private void checkTaskCancel( assertTrue(taskStartedLatch.await(getTestTimeout(), MILLISECONDS)); try ( - OperationSecurityContext ignored = initiator == null + Scope ignored = initiator == null ? null : grid(0).context().security().withContext(initiator) ) { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/OperationSecurityContext.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/Scope.java similarity index 55% rename from modules/core/src/main/java/org/apache/ignite/internal/processors/security/OperationSecurityContext.java rename to modules/commons/src/main/java/org/apache/ignite/internal/thread/context/Scope.java index 7f65d942948ad..7099e1df14560 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/OperationSecurityContext.java +++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/Scope.java @@ -15,32 +15,18 @@ * limitations under the License. */ -package org.apache.ignite.internal.processors.security; +package org.apache.ignite.internal.thread.context; /** - * + * Represents a scope with {@link ThreadContextAttribute} values bound to it. A newly created scope inherits {@link ThreadContextAttribute} + * values of the enclosing scope. Closing a scope restores the {@link ThreadContextAttribute} values bound to the + * enclosing scope. If no enclosing scope is present, attributes are restored to their initial values. + * Note, each created scope MUST be closed. */ -public class OperationSecurityContext implements AutoCloseable { - /** Ignite Security. */ - private final IgniteSecurity proc; - - /** Security context. */ - private final SecurityContext secCtx; - - /** - * @param proc Ignite Security. - * @param secCtx Security context. - */ - OperationSecurityContext(IgniteSecurity proc, SecurityContext secCtx) { - this.proc = proc; - this.secCtx = secCtx; - } +public interface Scope extends AutoCloseable { + /** Binds attribute with specified value to the current scope. */ + public Scope withAttribute(ThreadContextAttribute attr, T val); /** {@inheritDoc} */ - @Override public void close() { - if (secCtx == null) - ((IgniteSecurityProcessor)proc).restoreDefaultContext(); - else - proc.withContext(secCtx); - } + @Override public void close(); } diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ScopedAttributeValueStack.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ScopedAttributeValueStack.java new file mode 100644 index 0000000000000..fecb1fb94179c --- /dev/null +++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ScopedAttributeValueStack.java @@ -0,0 +1,117 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.thread.context; + +import java.util.ArrayDeque; +import java.util.Deque; +import org.apache.ignite.internal.util.typedef.F; + +/** */ +class ScopedAttributeValueStack { + /** */ + private static final int DFLT_SCOPE_ATTR_VAL_CAPACITY = 2; + + /** */ + private final ThreadContextAttribute attr; + + /** */ + private Deque> scopedVals; + + /** */ + ScopedAttributeValueStack(ThreadContextAttribute attr) { + this.attr = attr; + } + + /** */ + boolean pop(int scopeDepth) { + if (isEmpty() || scopedVals.peek().scopeDepth() != scopeDepth) + return false; + + scopedVals.pop(); + + return true; + } + + /** */ + void push(int scopeDepth, T val) { + if (scopedVals == null) + scopedVals = new ArrayDeque<>(DFLT_SCOPE_ATTR_VAL_CAPACITY); + + ScopedAttributeValue scopedVal = scopedVals.peek(); + + if (scopedVal != null && scopedVal.scopeDepth == scopeDepth) + scopedVal.value(val); + else + scopedVals.push(new ScopedAttributeValue<>(scopeDepth, val)); + } + + /** */ + T peek() { + return isEmpty() ? attr.initialValue() : scopedVals.peek().value(); + } + + /** */ + ThreadContextSnapshot exportTo(ThreadContextSnapshot snapshot) { + T val = peek(); + + return val == attr.initialValue() ? snapshot : snapshot.withAttribute(attr, val); + } + + /** */ + void restoreInitial(int scopeDepth) { + if (isEmpty() || scopedVals.peek().value() == attr.initialValue()) + return; + + scopedVals.push(new ScopedAttributeValue<>(scopeDepth, attr.initialValue())); + } + + /** */ + boolean isEmpty() { + return F.isEmpty(scopedVals); + } + + /** */ + private static class ScopedAttributeValue { + /** */ + private final int scopeDepth; + + /** */ + private T val; + + /** */ + ScopedAttributeValue(int scopeDepth, T val) { + this.scopeDepth = scopeDepth; + this.val = val; + } + + /** */ + int scopeDepth() { + return scopeDepth; + } + + /** */ + T value() { + return val; + } + + /** */ + void value(T val) { + this.val = val; + } + } +} diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContext.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContext.java new file mode 100644 index 0000000000000..2e7f69875eb62 --- /dev/null +++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContext.java @@ -0,0 +1,62 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.thread.context; + +/** Represents entry point to manage Thread Context {@link Scope}s and associated attributes values. */ +public class ThreadContext { + /** */ + private static final ThreadLocal THREAD_CONTEXT_DATA_HOLDER = ThreadLocal.withInitial(ThreadContextData::new); + + /** */ + private ThreadContext() { + // No-op. + } + + /** + * @param attr Attribute. + * @return Value bound to the specified attribute for the current scope. + */ + public static T get(ThreadContextAttribute attr) { + return data().get(attr); + } + + /** Creates {@link Scope} with no attribute values bound to it. */ + public static Scope createScope() { + return ThreadContextScope.create(); + } + + /** Creates {@link Scope} with specified attribute value bound to it. */ + public static Scope withAttribute(ThreadContextAttribute attr, T val) { + return createScope().withAttribute(attr, val); + } + + /** Creates {@link Scope} with attribute values restored from specified snapshot. */ + public static Scope withSnapshot(ThreadContextSnapshot snapshot) { + return ThreadContextScope.createWith(snapshot); + } + + /** @return Snapshot of thread Context attribute values. */ + public static ThreadContextSnapshot createSnapshot() { + return data().createSnapshot(); + } + + /** */ + static ThreadContextData data() { + return THREAD_CONTEXT_DATA_HOLDER.get(); + } +} diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextAttribute.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextAttribute.java new file mode 100644 index 0000000000000..7bd6d74c0fb4e --- /dev/null +++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextAttribute.java @@ -0,0 +1,43 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.thread.context; + +/** */ +public class ThreadContextAttribute { + /** */ + private final int id; + + /** */ + private final T initialVal; + + /** */ + ThreadContextAttribute(int id, T initialVal) { + this.id = id; + this.initialVal = initialVal; + } + + /** */ + int id() { + return id; + } + + /** */ + public T initialValue() { + return initialVal; + } +} diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextAttributeRegistry.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextAttributeRegistry.java new file mode 100644 index 0000000000000..a45d9051e5f7e --- /dev/null +++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextAttributeRegistry.java @@ -0,0 +1,71 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.thread.context; + +import java.util.List; +import java.util.concurrent.CopyOnWriteArrayList; + +/** */ +public class ThreadContextAttributeRegistry { + /** */ + private static final ThreadContextAttributeRegistry INSTANCE = new ThreadContextAttributeRegistry(); + + /** */ + private final List> attrs = new CopyOnWriteArrayList<>(); + + /** + * Registers attribute with initial value set to {@code null}. + * + * @see #register(Object) + */ + public ThreadContextAttribute register() { + return register(null); + } + + /** + * Registers attribute with specified initial value. Initial value is returned by + * {@link ThreadContext#get(ThreadContextAttribute)} method if attribute value is not set explicitly. + * Returned value represents a key used to access attribute value via {@link ThreadContext#get(ThreadContextAttribute)} + * or {@link ThreadContext#withAttribute(ThreadContextAttribute, Object)} methods. + * + * @param initialVal Attribute initial value. + * @return Registered attribute instance. + */ + public synchronized ThreadContextAttribute register(T initialVal) { + ThreadContextAttribute attr = new ThreadContextAttribute<>(attrs.size(), initialVal); + + attrs.add(attr); + + return attr; + } + + /** */ + ThreadContextAttribute attribute(int id) { + return (ThreadContextAttribute)attrs.get(id); + } + + /** */ + int size() { + return attrs.size(); + } + + /** */ + public static ThreadContextAttributeRegistry instance() { + return INSTANCE; + } +} diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextAwareWrapper.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextAwareWrapper.java new file mode 100644 index 0000000000000..455cd0df59c42 --- /dev/null +++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextAwareWrapper.java @@ -0,0 +1,59 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.thread.context; + +import java.util.function.BiFunction; +import org.apache.ignite.internal.IgniteInternalWrapper; + +/** */ +public abstract class ThreadContextAwareWrapper implements IgniteInternalWrapper { + /** */ + protected final T delegate; + + /** */ + protected final ThreadContextSnapshot snapshot; + + /** */ + @Override public T delegate() { + return delegate; + } + + /** */ + protected ThreadContextAwareWrapper(T delegate, ThreadContextSnapshot snapshot) { + this.delegate = delegate; + this.snapshot = snapshot; + } + + /** */ + protected static T wrap(T delegate, BiFunction wrapper) { + return wrap(delegate, wrapper, false); + } + + /** */ + protected static T wrap(T delegate, BiFunction wrapper, boolean ignoreEmptyContext) { + if (delegate == null || delegate instanceof ThreadContextAwareWrapper) + return delegate; + + ThreadContextSnapshot snapshot = ThreadContext.createSnapshot(); + + if (ignoreEmptyContext && snapshot.isEmpty()) + return delegate; + + return wrapper.apply(delegate, snapshot); + } +} diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextData.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextData.java new file mode 100644 index 0000000000000..04453225b48f9 --- /dev/null +++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextData.java @@ -0,0 +1,127 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.thread.context; + +/** */ +class ThreadContextData { + /** */ + private static final ScopedAttributeValueStack[] EMPTY = new ScopedAttributeValueStack[0]; + + /** */ + private final ThreadContextAttributeRegistry attrReg = ThreadContextAttributeRegistry.instance(); + + /** */ + private int activeScopeDepth; + + /** */ + private int activeAttrsCnt; + + /** */ + private ScopedAttributeValueStack[] attrs = EMPTY; + + /** */ + T get(ThreadContextAttribute attr) { + ScopedAttributeValueStack attrVals = attributeValues(attr.id()); + + return attrVals.peek(); + } + + /** */ + void put(ThreadContextAttribute attr, T val) { + ScopedAttributeValueStack attrVals = attributeValues(attr.id()); + + if (attrVals.peek() == val) + return; + + if (attrVals.isEmpty()) + ++activeAttrsCnt; + + attrVals.push(activeScopeDepth, val); + } + + /** */ + ThreadContextSnapshot createSnapshot() { + if (activeAttrsCnt == 0) + return ThreadContextSnapshot.emptySnapshot(); + + ThreadContextSnapshot snapshot = ThreadContextSnapshot.emptySnapshot(); + + for (ScopedAttributeValueStack attrVals : attrs) + snapshot = attrVals.exportTo(snapshot); + + return snapshot; + } + + /** */ + void restoreSnapshot(ThreadContextSnapshot snapshot) { + if (snapshot.isEmpty() && activeAttrsCnt == 0) + return; + + for (int id = attrReg.size() - 1; id >= 0; id--) { + if (!snapshot.isEmpty() && snapshot.attribute().id() == id) { + put(snapshot.attribute(), snapshot.attributeValue()); + + snapshot = snapshot.previous(); + } + else + attributeValues(id).restoreInitial(activeScopeDepth); + } + } + + /** */ + void onScopeCreated() { + ++activeScopeDepth; + } + + /** */ + void onScopeClosed() { + if (activeAttrsCnt != 0) + clearActiveScopeData(); + + --activeScopeDepth; + } + + /** */ + private void clearActiveScopeData() { + for (ScopedAttributeValueStack attrVals : attrs) { + if (attrVals.pop(activeScopeDepth) && attrVals.isEmpty()) + --activeAttrsCnt; + } + } + + /** */ + private ScopedAttributeValueStack attributeValues(int id) { + if (attrs.length <= id) + fetchRegisteredAttibutes(); + + return (ScopedAttributeValueStack)attrs[id]; + } + + /** */ + private void fetchRegisteredAttibutes() { + ScopedAttributeValueStack[] upd = new ScopedAttributeValueStack[attrReg.size()]; + + if (attrs.length != 0) + System.arraycopy(attrs, 0, upd, 0, attrs.length); + + for (int id = attrs.length; id < attrReg.size(); id++) + upd[id] = new ScopedAttributeValueStack<>(attrReg.attribute(id)); + + attrs = upd; + } +} diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextScope.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextScope.java new file mode 100644 index 0000000000000..1303ecfbb4d49 --- /dev/null +++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextScope.java @@ -0,0 +1,57 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.thread.context; + +/** */ +class ThreadContextScope implements Scope { + /** */ + private static final Scope INSTANCE = new ThreadContextScope(); + + /** */ + private ThreadContextScope() { + // No-op. + } + + /** {@inheritDoc} */ + @Override public Scope withAttribute(ThreadContextAttribute attr, T val) { + ThreadContext.data().put(attr, val); + + return this; + } + + /** {@inheritDoc} */ + @Override public void close() { + ThreadContext.data().onScopeClosed(); + } + + /** */ + static Scope create() { + ThreadContext.data().onScopeCreated(); + + return INSTANCE; + } + + /** */ + static Scope createWith(ThreadContextSnapshot snapshot) { + ThreadContext.data().onScopeCreated(); + + ThreadContext.data().restoreSnapshot(snapshot); + + return INSTANCE; + } +} diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextSnapshot.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextSnapshot.java new file mode 100644 index 0000000000000..53d84a22acfff --- /dev/null +++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/ThreadContextSnapshot.java @@ -0,0 +1,76 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.thread.context; + +/** */ +public class ThreadContextSnapshot { + /** */ + private static final ThreadContextSnapshot EMPTY = new ThreadContextSnapshot(null, null, null); + + /** */ + private final ThreadContextAttribute attr; + + /** */ + private final Object attrVal; + + /** */ + private final ThreadContextSnapshot prev; + + /** */ + private ThreadContextSnapshot(ThreadContextAttribute attr, Object attrVal, ThreadContextSnapshot prev) { + this.attr = attr; + this.attrVal = attrVal; + this.prev = prev; + } + + /** */ + ThreadContextAttribute attribute() { + assert !isEmpty(); + + return (ThreadContextAttribute)attr; + } + + /** */ + T attributeValue() { + assert !isEmpty(); + + return (T)attrVal; + } + + /** */ + ThreadContextSnapshot previous() { + assert !isEmpty(); + + return prev; + } + + /** */ + boolean isEmpty() { + return this == EMPTY; + } + + /** */ + ThreadContextSnapshot withAttribute(ThreadContextAttribute attr, T val) { + return new ThreadContextSnapshot(attr, val, this); + } + + /** */ + static ThreadContextSnapshot emptySnapshot() { + return EMPTY; + } +} diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/ThreadContextAwareExecutor.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/ThreadContextAwareExecutor.java new file mode 100644 index 0000000000000..3fa876be61a60 --- /dev/null +++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/ThreadContextAwareExecutor.java @@ -0,0 +1,47 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.thread.context.concurrent; + +import java.util.concurrent.Executor; +import org.apache.ignite.internal.thread.context.function.ThreadContextAwareRunnable; +import org.jetbrains.annotations.NotNull; + +/** */ +public class ThreadContextAwareExecutor implements Executor { + /** */ + private final Executor delegate; + + /** */ + private ThreadContextAwareExecutor(Executor delegate) { + this.delegate = delegate; + } + + /** {@inheritDoc} */ + @Override public void execute(@NotNull Runnable command) { + delegate.execute(ThreadContextAwareRunnable.wrap(command)); + } + + /** + * Creates executor wrapper that automatically captures scoped thread context attributes for the thread that + * invokes task execution. Captured attribute values will be restored before task execution, potentially in another + * thread. + */ + public static Executor wrap(Executor delegate) { + return delegate == null ? null : new ThreadContextAwareExecutor(delegate); + } +} diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/ThreadContextAwareCallable.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/ThreadContextAwareCallable.java new file mode 100644 index 0000000000000..1fda538e4bf95 --- /dev/null +++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/ThreadContextAwareCallable.java @@ -0,0 +1,73 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.thread.context.function; + +import java.util.Collection; +import java.util.concurrent.Callable; +import java.util.stream.Collectors; +import org.apache.ignite.internal.thread.context.Scope; +import org.apache.ignite.internal.thread.context.ThreadContext; +import org.apache.ignite.internal.thread.context.ThreadContextAwareWrapper; +import org.apache.ignite.internal.thread.context.ThreadContextSnapshot; + +/** */ +public class ThreadContextAwareCallable extends ThreadContextAwareWrapper> implements Callable { + /** */ + private ThreadContextAwareCallable(Callable delegate, ThreadContextSnapshot snapshot) { + super(delegate, snapshot); + } + + /** {@inheritDoc} */ + @Override public T call() throws Exception { + try (Scope ignored = ThreadContext.withSnapshot(snapshot)) { + return delegate.call(); + } + } + + /** + * Creates a wrapper that stores a specified {@link Callable} along with the thread context attributes values bound + * to the thread when this method is called. Captured attribute values will be restored before {@link Callable} execution, + * potentially in another thread. + */ + public static Callable wrap(Callable delegate) { + return wrap(delegate, ThreadContextAwareCallable::new); + } + + /** + * Creates a wrapper that stores a specified {@link Callable} along with the thread context attributes values bound + * to the thread when this method is called. Captured attribute values will be restored before {@link Callable} execution, + * potentially in another thread. + * If all Thread Context attributes holds initial values when this method is called, it does nothing and returns original + * {@link Callable}. + */ + public static Callable wrapIfActiveAttributesPresent(Callable delegate) { + return wrap(delegate, ThreadContextAwareCallable::new, true); + } + + /** The same as {@link #wrap(Collection)} but wraps each specified {@link Callable}. */ + public static Collection> wrap(Collection> tasks) { + return tasks == null ? null : tasks.stream().map(ThreadContextAwareCallable::wrap).collect(Collectors.toList()); + } + + /** The same as {@link #wrapIfActiveAttributesPresent(Collection)} but wraps each specified {@link Callable}. */ + public static Collection> wrapIfActiveAttributesPresent(Collection> tasks) { + return tasks == null + ? null + : tasks.stream().map(ThreadContextAwareCallable::wrapIfActiveAttributesPresent).collect(Collectors.toList()); + } +} diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/ThreadContextAwareRunnable.java b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/ThreadContextAwareRunnable.java new file mode 100644 index 0000000000000..42449446629da --- /dev/null +++ b/modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/ThreadContextAwareRunnable.java @@ -0,0 +1,58 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.thread.context.function; + +import org.apache.ignite.internal.thread.context.Scope; +import org.apache.ignite.internal.thread.context.ThreadContext; +import org.apache.ignite.internal.thread.context.ThreadContextAwareWrapper; +import org.apache.ignite.internal.thread.context.ThreadContextSnapshot; + +/** */ +public class ThreadContextAwareRunnable extends ThreadContextAwareWrapper implements Runnable { + /** */ + public ThreadContextAwareRunnable(Runnable delegate, ThreadContextSnapshot snapshot) { + super(delegate, snapshot); + } + + /** {@inheritDoc} */ + @Override public void run() { + try (Scope ignored = ThreadContext.withSnapshot(snapshot)) { + delegate.run(); + } + } + + /** + * Creates a wrapper that stores a specified {@link Runnable} along with the thread context attributes values bound + * to the thread when this method is called. Captured attribute values will be restored before {@link Runnable} execution, + * potentially in another thread. + */ + public static Runnable wrap(Runnable delegate) { + return wrap(delegate, ThreadContextAwareRunnable::new); + } + + /** + * Creates a wrapper that stores a specified {@link Runnable} along with the thread context attributes values bound + * to the thread when this method is called. Captured attribute values will be restored before {@link Runnable} execution, + * potentially in another thread. + * If all Thread Context attributes holds initial values when this method is called, it does nothing and returns original + * {@link Runnable}. + */ + public static Runnable wrapIfActiveAttributesPresent(Runnable delegate) { + return wrap(delegate, ThreadContextAwareRunnable::new, true); + } +} diff --git a/modules/core/src/main/java/org/apache/ignite/internal/IgniteSchedulerImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/IgniteSchedulerImpl.java index 2092e1256ad8c..9456ecfcd0ad7 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/IgniteSchedulerImpl.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/IgniteSchedulerImpl.java @@ -27,8 +27,8 @@ import java.util.concurrent.Callable; import java.util.concurrent.TimeUnit; import org.apache.ignite.IgniteScheduler; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; import org.apache.ignite.internal.processors.security.SecurityUtils; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.future.IgniteFutureImpl; import org.apache.ignite.internal.util.lang.GridPlainCallable; import org.apache.ignite.internal.util.lang.GridPlainRunnable; @@ -211,7 +211,7 @@ private SecurityAwareClosure(UUID secSubjId, Callable c) { @Override public void run() { assert runnable != null; - try (OperationSecurityContext c = ctx.security().withContext(secSubjId)) { + try (Scope ignored = ctx.security().withContext(secSubjId)) { runnable.run(); } } @@ -220,7 +220,7 @@ private SecurityAwareClosure(UUID secSubjId, Callable c) { @Override public T call() throws Exception { assert call != null; - try (OperationSecurityContext c = ctx.security().withContext(secSubjId)) { + try (Scope ignored = ctx.security().withContext(secSubjId)) { return call.call(); } } diff --git a/modules/core/src/main/java/org/apache/ignite/internal/SecurityAwareBiPredicate.java b/modules/core/src/main/java/org/apache/ignite/internal/SecurityAwareBiPredicate.java index 5ae1ee1f673a2..51f75b823baaf 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/SecurityAwareBiPredicate.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/SecurityAwareBiPredicate.java @@ -21,8 +21,8 @@ import java.util.UUID; import org.apache.ignite.internal.processors.security.AbstractSecurityAwareExternalizable; import org.apache.ignite.internal.processors.security.IgniteSecurity; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; import org.apache.ignite.internal.processors.security.sandbox.IgniteSandbox; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.lang.IgniteBiPredicate; /** @@ -52,7 +52,7 @@ public SecurityAwareBiPredicate(UUID subjectId, IgniteBiPredicate origin @Override public boolean apply(E1 e1, E2 e2) { IgniteSecurity security = ignite.context().security(); - try (OperationSecurityContext c = security.withContext(subjectId)) { + try (Scope ignored = security.withContext(subjectId)) { IgniteSandbox sandbox = security.sandbox(); return sandbox.enabled() ? sandbox.execute(() -> original.apply(e1, e2)) : original.apply(e1, e2); diff --git a/modules/core/src/main/java/org/apache/ignite/internal/SecurityAwarePredicate.java b/modules/core/src/main/java/org/apache/ignite/internal/SecurityAwarePredicate.java index 4c412db01aeda..60723b00e8f93 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/SecurityAwarePredicate.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/SecurityAwarePredicate.java @@ -21,8 +21,8 @@ import java.util.UUID; import org.apache.ignite.internal.processors.security.AbstractSecurityAwareExternalizable; import org.apache.ignite.internal.processors.security.IgniteSecurity; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; import org.apache.ignite.internal.processors.security.sandbox.IgniteSandbox; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.lang.IgnitePredicate; /** @@ -52,7 +52,7 @@ public SecurityAwarePredicate(UUID subjectId, IgnitePredicate original) { @Override public boolean apply(E evt) { IgniteSecurity security = ignite.context().security(); - try (OperationSecurityContext c = security.withContext(subjectId)) { + try (Scope ignored = security.withContext(subjectId)) { IgniteSandbox sandbox = security.sandbox(); return sandbox.enabled() ? sandbox.execute(() -> original.apply(evt)) : original.apply(evt); diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/consistency/ConsistencyRepairTask.java b/modules/core/src/main/java/org/apache/ignite/internal/management/consistency/ConsistencyRepairTask.java index 0a46c30d73bd7..8cbdf15845856 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/consistency/ConsistencyRepairTask.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/consistency/ConsistencyRepairTask.java @@ -40,7 +40,7 @@ import org.apache.ignite.internal.processors.cache.distributed.dht.topology.GridDhtLocalPartition; import org.apache.ignite.internal.processors.cache.distributed.near.consistency.IgniteIrreparableConsistencyViolationException; import org.apache.ignite.internal.processors.cache.persistence.CacheDataRow; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.GridConcurrentHashSet; import org.apache.ignite.internal.util.lang.GridCursor; import org.apache.ignite.internal.util.typedef.F; @@ -273,7 +273,7 @@ private String processPartition(int p, ConsistencyRepairCommandArg arg) { * @param keys Keys. */ private void repair(IgniteCache cache, Set keys) { - try (OperationSecurityContext ignored = ignite.context().security().withContext(ignite.localNode().id())) { + try (Scope ignored = ignite.context().security().withContext(ignite.localNode().id())) { cache.getAll(keys); // Repair. } catch (CacheException e) { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/managers/communication/GridIoManager.java b/modules/core/src/main/java/org/apache/ignite/internal/managers/communication/GridIoManager.java index 661e023febe96..dd0d95352c787 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/managers/communication/GridIoManager.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/managers/communication/GridIoManager.java @@ -99,12 +99,12 @@ import org.apache.ignite.internal.processors.cache.persistence.file.RandomAccessFileIOFactory; import org.apache.ignite.internal.processors.platform.message.PlatformMessageFilter; import org.apache.ignite.internal.processors.pool.PoolProcessor; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; import org.apache.ignite.internal.processors.timeout.GridTimeoutObject; import org.apache.ignite.internal.processors.tracing.MTC; import org.apache.ignite.internal.processors.tracing.MTC.TraceSurroundings; import org.apache.ignite.internal.processors.tracing.Span; import org.apache.ignite.internal.processors.tracing.SpanTags; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.GridBoundedConcurrentLinkedHashSet; import org.apache.ignite.internal.util.IgniteUtils; import org.apache.ignite.internal.util.StripedCompositeReadWriteLock; @@ -1872,7 +1872,7 @@ private void invokeListener(Byte plc, GridMessageListener lsnr, UUID nodeId, Obj UUID newSecSubjId = secSubjId != null ? secSubjId : nodeId; - try (OperationSecurityContext s = ctx.security().withContext(newSecSubjId)) { + try (Scope ignored = ctx.security().withContext(newSecSubjId)) { lsnr.onMessage(nodeId, msg, plc); } finally { @@ -3640,7 +3640,7 @@ private class GridUserMessageListener implements GridMessageListener { if (msgBody != null) { if (predLsnr != null) { - try (OperationSecurityContext s = ctx.security().withContext(initNodeId)) { + try (Scope ignored = ctx.security().withContext(initNodeId)) { if (!predLsnr.apply(nodeId, msgBody)) removeMessageListener(TOPIC_COMM_USER, this); } diff --git a/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java b/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java index 7334cfc16c9a9..01cf695732d3d 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java @@ -93,9 +93,9 @@ import org.apache.ignite.internal.processors.cluster.DiscoveryDataClusterState; import org.apache.ignite.internal.processors.cluster.IGridClusterStateProcessor; import org.apache.ignite.internal.processors.security.IgniteSecurity; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; import org.apache.ignite.internal.processors.security.SecurityContext; import org.apache.ignite.internal.processors.tracing.messages.SpanContainer; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.GridAtomicLong; import org.apache.ignite.internal.util.GridBoundedConcurrentLinkedHashMap; import org.apache.ignite.internal.util.GridSpinBusyLock; @@ -937,7 +937,7 @@ public SecurityAwareNotificationTask(DiscoveryNotification notification) { if (customMsg instanceof SecurityAwareCustomMessageWrapper) { UUID secSubjId = ((SecurityAwareCustomMessageWrapper)customMsg).securitySubjectId(); - try (OperationSecurityContext ignored = ctx.security().withContext(secSubjId)) { + try (Scope ignored = ctx.security().withContext(secSubjId)) { super.run(); } } @@ -948,7 +948,7 @@ public SecurityAwareNotificationTask(DiscoveryNotification notification) { notification.getNode() ); - try (OperationSecurityContext ignored = ctx.security().withContext(initiatorNodeSecCtx)) { + try (Scope ignored = ctx.security().withContext(initiatorNodeSecCtx)) { super.run(); } } @@ -3084,7 +3084,7 @@ private void body0() throws InterruptedException { blockingSectionEnd(); } - try (OperationSecurityContext ignored = withRemoteSecurityContext(ctx, evt.secCtx)) { + try (Scope ignored = withRemoteSecurityContext(ctx, evt.secCtx)) { int type = evt.type; AffinityTopologyVersion topVer = evt.topVer; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java index 6f2ebe7ade62a..f6a8cee0b6039 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java @@ -112,9 +112,9 @@ import org.apache.ignite.internal.processors.platform.cache.PlatformCacheEntryFilter; import org.apache.ignite.internal.processors.platform.client.cache.ImmutableArrayMap; import org.apache.ignite.internal.processors.platform.client.cache.ImmutableArraySet; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; import org.apache.ignite.internal.processors.security.SecurityContext; import org.apache.ignite.internal.processors.task.GridInternal; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.transactions.IgniteTxHeuristicCheckedException; import org.apache.ignite.internal.transactions.IgniteTxRollbackCheckedException; import org.apache.ignite.internal.transactions.IgniteTxTimeoutCheckedException; @@ -3888,7 +3888,7 @@ else if (ctx.gate().isStopped()) ctx.operationContextPerCall(opCtx); ctx.shared().txContextReset(); - try (OperationSecurityContext ignored = ctx.kernalContext().security().withContext(secCtx)) { + try (Scope ignored = ctx.kernalContext().security().withContext(secCtx)) { opFut = op.op(tx0).chain(clo); } catch (Throwable e) { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCachePartitionExchangeManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCachePartitionExchangeManager.java index 6bff39ae692d1..d35e2457c7bc4 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCachePartitionExchangeManager.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCachePartitionExchangeManager.java @@ -107,11 +107,11 @@ import org.apache.ignite.internal.processors.metric.impl.BooleanMetricImpl; import org.apache.ignite.internal.processors.metric.impl.HistogramMetricImpl; import org.apache.ignite.internal.processors.query.schema.SchemaNodeLeaveExchangeWorkerTask; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; import org.apache.ignite.internal.processors.security.SecurityContext; import org.apache.ignite.internal.processors.timeout.GridTimeoutObject; import org.apache.ignite.internal.processors.tracing.Span; import org.apache.ignite.internal.processors.tracing.SpanTags; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.GridListSet; import org.apache.ignite.internal.util.GridPartitionStateMap; import org.apache.ignite.internal.util.GridStringBuilder; @@ -3062,7 +3062,7 @@ private void body0() throws InterruptedException, IgniteCheckedException { if (task == null) continue; // Main while loop. - try (OperationSecurityContext c = withRemoteSecurityContext(cctx.kernalContext(), task.securityContext())) { + try (Scope ignored = withRemoteSecurityContext(cctx.kernalContext(), task.securityContext())) { if (!isExchangeTask(task)) { processCustomTask(task); @@ -3188,7 +3188,7 @@ else if (task instanceof ForceRebalanceExchangeTask) { break; } - catch (IgniteFutureTimeoutCheckedException ignored) { + catch (IgniteFutureTimeoutCheckedException ignoredEx) { updateHeartbeat(); if (nextDumpTime <= U.currentTimeMillis()) { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/ValidationOnNodeJoinUtils.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/ValidationOnNodeJoinUtils.java index eb3fd275afc40..e08e238dfd100 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/ValidationOnNodeJoinUtils.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/ValidationOnNodeJoinUtils.java @@ -51,8 +51,8 @@ import org.apache.ignite.internal.processors.datastructures.DataStructuresProcessor; import org.apache.ignite.internal.processors.query.QuerySchemaPatch; import org.apache.ignite.internal.processors.query.QueryUtils; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; import org.apache.ignite.internal.processors.security.SecurityContext; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.internal.CU; import org.apache.ignite.internal.util.typedef.internal.U; @@ -152,7 +152,7 @@ public class ValidationOnNodeJoinUtils { for (CacheJoinNodeDiscoveryData.CacheInfo cacheInfo : nodeData.caches().values()) { if (secCtx != null && cacheInfo.cacheType() == CacheType.USER) { - try (OperationSecurityContext s = ctx.security().withContext(secCtx)) { + try (Scope ignored = ctx.security().withContext(secCtx)) { GridCacheProcessor.authorizeCacheCreate(ctx.security(), cacheInfo.cacheData().config()); } catch (SecurityException ex) { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/query/continuous/SecurityAwareFilter.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/query/continuous/SecurityAwareFilter.java index 1f15faa34d8b6..91d53798b0e0c 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/query/continuous/SecurityAwareFilter.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/query/continuous/SecurityAwareFilter.java @@ -25,8 +25,8 @@ import org.apache.ignite.cache.CacheEntryEventSerializableFilter; import org.apache.ignite.internal.processors.security.AbstractSecurityAwareExternalizable; import org.apache.ignite.internal.processors.security.IgniteSecurity; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; import org.apache.ignite.internal.processors.security.sandbox.IgniteSandbox; +import org.apache.ignite.internal.thread.context.Scope; /** * Security aware remote filter. @@ -60,7 +60,7 @@ public SecurityAwareFilter(UUID subjectId, CacheEntryEventFilter original) IgniteSecurity security = ignite.context().security(); - try (OperationSecurityContext c = security.withContext(subjectId)) { + try (Scope ignored = security.withContext(subjectId)) { IgniteSandbox sandbox = security.sandbox(); return sandbox.enabled() ? sandbox.execute(() -> original.evaluate(evt)) : original.evaluate(evt); diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/query/continuous/SecurityAwareTransformerFactory.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/query/continuous/SecurityAwareTransformerFactory.java index 8e4e8585304c5..9e958a4ff5aaf 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/query/continuous/SecurityAwareTransformerFactory.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/query/continuous/SecurityAwareTransformerFactory.java @@ -22,8 +22,8 @@ import javax.cache.configuration.Factory; import org.apache.ignite.internal.processors.security.AbstractSecurityAwareExternalizable; import org.apache.ignite.internal.processors.security.IgniteSecurity; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; import org.apache.ignite.internal.processors.security.sandbox.IgniteSandbox; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.lang.IgniteClosure; /** @@ -58,7 +58,7 @@ public SecurityAwareTransformerFactory(UUID subjectId, Factory cl.apply(e)) : cl.apply(e); diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/job/GridJobWorker.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/job/GridJobWorker.java index 84a36b3012659..54b8858713971 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/job/GridJobWorker.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/job/GridJobWorker.java @@ -51,12 +51,12 @@ import org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion; import org.apache.ignite.internal.processors.cache.distributed.dht.GridReservable; import org.apache.ignite.internal.processors.query.GridQueryProcessor; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; import org.apache.ignite.internal.processors.security.SecurityContext; import org.apache.ignite.internal.processors.security.SecurityUtils; import org.apache.ignite.internal.processors.service.GridServiceNotFoundException; import org.apache.ignite.internal.processors.task.GridInternal; import org.apache.ignite.internal.processors.timeout.GridTimeoutObject; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.X; import org.apache.ignite.internal.util.typedef.internal.LT; @@ -564,7 +564,7 @@ private void execute0(boolean skipNtf) { SqlFieldsQuery.setThreadedQueryInitiatorId("task:" + ses.getTaskName() + ":" + getJobId()); - try (OperationSecurityContext ignored = ctx.security().withContext(secCtx)) { + try (Scope ignored = ctx.security().withContext(secCtx)) { if (partsReservation != null) { try { if (!partsReservation.reserve()) { @@ -784,7 +784,7 @@ public void cancel(boolean sys) { status = CANCELLED; U.wrapThreadLoader(dep.classLoader(), (IgniteRunnable)() -> { - try (OperationSecurityContext c = ctx.security().withContext(secCtx)) { + try (Scope ignored = ctx.security().withContext(secCtx)) { job0.cancel(); } }); diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/odbc/ClientListenerNioListener.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/odbc/ClientListenerNioListener.java index f56867a0eebbf..3d6f6ab75c3be 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/odbc/ClientListenerNioListener.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/odbc/ClientListenerNioListener.java @@ -39,7 +39,7 @@ import org.apache.ignite.internal.processors.odbc.odbc.OdbcConnectionContext; import org.apache.ignite.internal.processors.platform.client.ClientConnectionContext; import org.apache.ignite.internal.processors.platform.client.ClientStatus; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.GridSpinBusyLock; import org.apache.ignite.internal.util.nio.GridNioServerListenerAdapter; import org.apache.ignite.internal.util.nio.GridNioSession; @@ -230,7 +230,7 @@ public ClientListenerNioListener( ClientListenerResponse resp; - try (OperationSecurityContext ignored = ctx.security().withContext(connCtx.securityContext())) { + try (Scope ignored = ctx.security().withContext(connCtx.securityContext())) { resp = hnd.handle(req); } @@ -569,7 +569,7 @@ private void ensureConnectionAllowed(ClientListenerConnectionContext connCtx) th // When security is enabled, only an administrator can connect and execute commands. if (connCtx.securityContext() != null) { - try (OperationSecurityContext ignored = ctx.security().withContext(connCtx.securityContext())) { + try (Scope ignored = ctx.security().withContext(connCtx.securityContext())) { ctx.security().authorize(SecurityPermission.ADMIN_OPS); } catch (SecurityException e) { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java index 9073f8e89c992..32082268ce1dc 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java @@ -44,11 +44,11 @@ import org.apache.ignite.internal.processors.GridProcessorAdapter; import org.apache.ignite.internal.processors.plugin.IgnitePluginProcessor; import org.apache.ignite.internal.processors.security.IgniteSecurity; -import org.apache.ignite.internal.processors.security.thread.SecurityAwareIoPool; -import org.apache.ignite.internal.processors.security.thread.SecurityAwareStripedExecutor; -import org.apache.ignite.internal.processors.security.thread.SecurityAwareStripedThreadPoolExecutor; -import org.apache.ignite.internal.processors.security.thread.SecurityAwareThreadPoolExecutor; import org.apache.ignite.internal.processors.timeout.GridTimeoutProcessor; +import org.apache.ignite.internal.thread.context.pool.ThreadContextAwareIoPool; +import org.apache.ignite.internal.thread.context.pool.ThreadContextAwareStripedExecutor; +import org.apache.ignite.internal.thread.context.pool.ThreadContextAwareStripedThreadPoolExecutor; +import org.apache.ignite.internal.thread.context.pool.ThreadContextAwareThreadPoolExecutor; import org.apache.ignite.internal.util.StripedExecutor; import org.apache.ignite.internal.util.tostring.GridToStringExclude; import org.apache.ignite.internal.util.typedef.F; @@ -280,7 +280,7 @@ public PoolProcessor(GridKernalContext ctx) { throw new IgniteException("Failed to register IO executor pool because its ID as " + "already used: " + id); - extPools[id] = ctx.security().enabled() ? new SecurityAwareIoPool(ctx.security(), ex) : ex; + extPools[id] = ctx.security().enabled() ? ThreadContextAwareIoPool.wrap(ex) : ex; } } } @@ -1216,8 +1216,7 @@ private IgniteStripedThreadPoolExecutor createStripedThreadPoolExecutor( long keepAliveTime ) { return ctx.security().enabled() - ? new SecurityAwareStripedThreadPoolExecutor( - ctx.security(), + ? new ThreadContextAwareStripedThreadPoolExecutor( concurrentLvl, igniteInstanceName, threadNamePrefix, @@ -1245,8 +1244,7 @@ private StripedExecutor createStripedExecutor( long failureDetectionTimeout ) { return ctx.security().enabled() - ? new SecurityAwareStripedExecutor( - ctx.security(), + ? new ThreadContextAwareStripedExecutor( cnt, igniteInstanceName, poolName, @@ -1270,8 +1268,7 @@ private IgniteThreadPoolExecutor createExecutorService( UncaughtExceptionHandler eHnd ) { return ctx.security().enabled() - ? new SecurityAwareThreadPoolExecutor( - ctx.security(), + ? new ThreadContextAwareThreadPoolExecutor( threadNamePrefix, igniteInstanceName, corePoolSize, diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/GridRestProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/GridRestProcessor.java index 0c521ceef9b73..f26b3af040e2b 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/GridRestProcessor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/rest/GridRestProcessor.java @@ -68,8 +68,8 @@ import org.apache.ignite.internal.processors.rest.request.GridRestRequest; import org.apache.ignite.internal.processors.rest.request.GridRestTaskRequest; import org.apache.ignite.internal.processors.rest.request.RestQueryRequest; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; import org.apache.ignite.internal.processors.security.SecurityContext; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.GridSpinReadWriteLock; import org.apache.ignite.internal.util.future.GridFinishedFuture; import org.apache.ignite.internal.util.typedef.C1; @@ -290,7 +290,7 @@ else if (!(req instanceof GridRestAuthenticationRequest) && startLatch.getCount( if (secCtx0 == null || ses.isTokenExpired(sesTokTtl)) ses.secCtx = secCtx0 = authenticate(req, ses); - try (OperationSecurityContext s = ctx.security().withContext(secCtx0)) { + try (Scope ignored = ctx.security().withContext(secCtx0)) { authorize(req); return handleRequest0(req); diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/IgniteSecurity.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/security/IgniteSecurity.java index bdcaa966de1cd..ab3be1e01cd08 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/IgniteSecurity.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/security/IgniteSecurity.java @@ -22,6 +22,8 @@ import org.apache.ignite.IgniteCheckedException; import org.apache.ignite.cluster.ClusterNode; import org.apache.ignite.internal.processors.security.sandbox.IgniteSandbox; +import org.apache.ignite.internal.thread.context.Scope; +import org.apache.ignite.internal.thread.context.ThreadContext; import org.apache.ignite.plugin.security.AuthenticationContext; import org.apache.ignite.plugin.security.SecurityCredentials; import org.apache.ignite.plugin.security.SecurityException; @@ -42,30 +44,53 @@ */ public interface IgniteSecurity { /** - * Creates {@link OperationSecurityContext}. All calls of methods {@link #authorize(String, SecurityPermission)} or {@link - * #authorize(SecurityPermission)} will be processed into the context of passed {@link SecurityContext} until - * holder {@link OperationSecurityContext} will be closed. + * Creates new {@link Scope} with Security Context Attribute set to the specified value. * * @param secCtx Security Context. - * @return Security context holder. + * @return Thread Context Scope. + * + * @see #withContext(Scope, SecurityContext) + */ + public default Scope withContext(SecurityContext secCtx) { + return withContext(ThreadContext.createScope(), secCtx); + } + + /** + * Creates new {@link Scope} with Security Context Attribute set to the Security Context corresponding to the + * specified Subject ID. + * + * @param subjId Security Subject ID. + * @return Thread Context Scope. + * + * @see #withContext(Scope, SecurityContext) + */ + public default Scope withContext(UUID subjId) { + return withContext(ThreadContext.createScope(), securityContext(subjId)); + } + + /** + * Adds Security Context Attribute with specified value to the {@link Scope}. All {@link #authorize(String, SecurityPermission)} + * or {@link #authorize(SecurityPermission)} method calls will use this value to determine operation initiator. + * + * @param scope Thread Context Scope. + * @param secCtx Security Context. + * @return Thread Context Scope. */ - public OperationSecurityContext withContext(SecurityContext secCtx); + public Scope withContext(Scope scope, SecurityContext secCtx); /** - * Creates {@link OperationSecurityContext}. All calls of methods {@link #authorize(String, SecurityPermission)} or {@link - * #authorize(SecurityPermission)} will be processed into the context of {@link SecurityContext} that is owned by - * the node with given nodeId until holder {@link OperationSecurityContext} will be closed. + * Gets Security Context corresponding to the specified Subject ID. * - * @param nodeId Node id. - * @return Security context holder. + * @param subjId Security Subject ID. + * @return Security Context. */ - public OperationSecurityContext withContext(UUID nodeId); + public SecurityContext securityContext(UUID subjId); /** @return {@code True} if current thread executed in default security context. */ public boolean isDefaultContext(); /** - * @return SecurityContext of holder {@link OperationSecurityContext}. + * @return SecurityContext of holder {@link Scope}. */ public SecurityContext securityContext(); diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/IgniteSecurityProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/security/IgniteSecurityProcessor.java index 39721c717f1f4..2b6d2743df427 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/IgniteSecurityProcessor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/security/IgniteSecurityProcessor.java @@ -32,6 +32,10 @@ import org.apache.ignite.internal.processors.security.sandbox.AccessControllerSandbox; import org.apache.ignite.internal.processors.security.sandbox.IgniteSandbox; import org.apache.ignite.internal.processors.security.sandbox.NoOpSandbox; +import org.apache.ignite.internal.thread.context.Scope; +import org.apache.ignite.internal.thread.context.ThreadContext; +import org.apache.ignite.internal.thread.context.ThreadContextAttribute; +import org.apache.ignite.internal.thread.context.ThreadContextAttributeRegistry; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.lang.IgniteFuture; @@ -85,8 +89,8 @@ static boolean hasSandboxedNodes() { return SANDBOXED_NODES_COUNTER.get() > 0; } - /** Current security context if differs from {@link #dfltSecCtx}. */ - private final ThreadLocal curSecCtx = new ThreadLocal<>(); + /** Thread context attribute that holds Security Context. */ + private static final ThreadContextAttribute SEC_CTX = ThreadContextAttributeRegistry.instance().register(); /** Security processor. */ private final GridSecurityProcessor secPrc; @@ -106,13 +110,6 @@ static boolean hasSandboxedNodes() { /** Default security context. */ private volatile SecurityContext dfltSecCtx; - /** Default operation security context for the case when current and new contexts are default. */ - private final OperationSecurityContext dfltOpCtx = new OperationSecurityContext(this, null) { - @Override public void close() { - // No-op. - } - }; - /** * @param ctx Grid kernal context. * @param secPrc Security processor. @@ -129,25 +126,12 @@ public IgniteSecurityProcessor(GridKernalContext ctx, GridSecurityProcessor secP } /** {@inheritDoc} */ - @Override public OperationSecurityContext withContext(SecurityContext secCtx) { - assert secCtx != null; - - SecurityContext dflt = dfltSecCtx; - SecurityContext cur = curSecCtx.get(); - - boolean isNewCtxDflt = secCtx == dflt; - boolean isCurCtxDflt = cur == null; - - if (isCurCtxDflt && isNewCtxDflt) - return dfltOpCtx; - - curSecCtx.set(isNewCtxDflt ? null : secCtx); - - return new OperationSecurityContext(this, isCurCtxDflt ? null : cur); + @Override public Scope withContext(Scope scope, SecurityContext secCtx) { + return scope.withAttribute(SEC_CTX, secCtx == dfltSecCtx ? null : secCtx); } /** {@inheritDoc} */ - @Override public OperationSecurityContext withContext(UUID subjId) { + @Override public SecurityContext securityContext(UUID subjId) { try { SecurityContext res = secPrc.securityContext(subjId); @@ -158,7 +142,7 @@ public IgniteSecurityProcessor(GridKernalContext ctx, GridSecurityProcessor secP throw new IllegalStateException("Failed to find security context for subject with given ID : " + subjId); } - return withContext(res); + return res; } catch (Throwable e) { log.error(FAILED_OBTAIN_SEC_CTX_MSG, e); @@ -187,19 +171,14 @@ public IgniteSecurityProcessor(GridKernalContext ctx, GridSecurityProcessor secP ); } - /** Restores local node context for the current thread. */ - void restoreDefaultContext() { - curSecCtx.set(null); - } - /** {@inheritDoc} */ @Override public boolean isDefaultContext() { - return curSecCtx.get() == null; + return ThreadContext.get(SEC_CTX) == null; } /** {@inheritDoc} */ @Override public SecurityContext securityContext() { - SecurityContext res = curSecCtx.get(); + SecurityContext res = ThreadContext.get(SEC_CTX); return res == null ? dfltSecCtx : res; } diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/NoOpIgniteSecurityProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/security/NoOpIgniteSecurityProcessor.java index 0dc6151cf6cf6..ea50b110b9db3 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/NoOpIgniteSecurityProcessor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/security/NoOpIgniteSecurityProcessor.java @@ -25,6 +25,7 @@ import org.apache.ignite.internal.GridKernalContext; import org.apache.ignite.internal.processors.security.sandbox.IgniteSandbox; import org.apache.ignite.internal.processors.security.sandbox.NoOpSandbox; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.plugin.security.AuthenticationContext; import org.apache.ignite.plugin.security.SecurityCredentials; import org.apache.ignite.plugin.security.SecurityException; @@ -44,13 +45,6 @@ public class NoOpIgniteSecurityProcessor extends IgniteSecurityAdapter { /** Error message that occurs when trying to perform security operations if security disabled. */ public static final String SECURITY_DISABLED_ERROR_MSG = "Operation cannot be performed: Ignite security disabled."; - /** No operation security context. */ - private final OperationSecurityContext opSecCtx = new OperationSecurityContext(this, null) { - @Override public void close() { - // No-op. - } - }; - /** Instance of IgniteSandbox. */ private final IgniteSandbox sandbox = new NoOpSandbox(); @@ -62,13 +56,13 @@ public NoOpIgniteSecurityProcessor(GridKernalContext ctx) { } /** {@inheritDoc} */ - @Override public OperationSecurityContext withContext(SecurityContext secCtx) { - return opSecCtx; + @Override public Scope withContext(Scope scope, SecurityContext secCtx) { + return scope; } /** {@inheritDoc} */ - @Override public OperationSecurityContext withContext(UUID nodeId) { - return opSecCtx; + @Override public SecurityContext securityContext(UUID subjId) { + return null; } /** {@inheritDoc} */ diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/SecurityUtils.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/security/SecurityUtils.java index 24dfa4ca01246..0911df2a584eb 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/SecurityUtils.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/security/SecurityUtils.java @@ -47,6 +47,7 @@ import org.apache.ignite.internal.processors.cache.GridCacheSharedContext; import org.apache.ignite.internal.processors.security.sandbox.IgniteDomainCombiner; import org.apache.ignite.internal.processors.security.sandbox.IgniteSandbox; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.internal.A; import org.apache.ignite.internal.util.typedef.internal.U; @@ -201,9 +202,9 @@ public static UUID securitySubjectId(GridCacheSharedContext cctx) { * context change is needed. * Note that this method is safe to use only when it is known to be called in the security context of the local node * (e.g. in system workers). - * @return {@link OperationSecurityContext} instance if new security context is set, otherwise {@code null}. + * @return {@link Scope} instance if new security context is set, otherwise {@code null}. */ - public static OperationSecurityContext withRemoteSecurityContext(GridKernalContext ctx, SecurityContext secCtx) { + public static Scope withRemoteSecurityContext(GridKernalContext ctx, SecurityContext secCtx) { if (secCtx == null) return null; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareCallable.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareCallable.java deleted file mode 100644 index 43845f198f8ae..0000000000000 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareCallable.java +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.ignite.internal.processors.security.thread; - -import java.util.Collection; -import java.util.concurrent.Callable; -import java.util.stream.Collectors; -import org.apache.ignite.internal.processors.security.IgniteSecurity; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; -import org.apache.ignite.internal.processors.security.SecurityContext; - -/** - * Represents a {@link Callable} wrapper that executes the original {@link Callable} with the security context - * current at the time the wrapper was created. - */ -class SecurityAwareCallable implements Callable { - /** Original callable. */ - private final Callable delegate; - - /** */ - private final IgniteSecurity security; - - /** */ - private final SecurityContext secCtx; - - /** */ - private SecurityAwareCallable(IgniteSecurity security, Callable delegate) { - assert security.enabled(); - assert delegate != null; - - this.delegate = delegate; - this.security = security; - secCtx = security.securityContext(); - } - - /** {@inheritDoc} */ - @Override public T call() throws Exception { - try (OperationSecurityContext ignored = security.withContext(secCtx)) { - return delegate.call(); - } - } - - /** */ - static Callable of(IgniteSecurity sec, Callable delegate) { - if (delegate == null || sec.isDefaultContext()) - return delegate; - - return new SecurityAwareCallable<>(sec, delegate); - } - - /** */ - static Collection> of( - IgniteSecurity sec, - Collection> tasks - ) { - if (tasks == null || sec.isDefaultContext()) - return tasks; - - return tasks.stream().map(t -> t == null ? null : new SecurityAwareCallable<>(sec, t)).collect(Collectors.toList()); - } -} diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareRunnable.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareRunnable.java deleted file mode 100644 index 4ea8765d147e6..0000000000000 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareRunnable.java +++ /dev/null @@ -1,62 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.ignite.internal.processors.security.thread; - -import org.apache.ignite.internal.processors.security.IgniteSecurity; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; -import org.apache.ignite.internal.processors.security.SecurityContext; - -/** - * Represents a {@link Runnable} wrapper that executes the original {@link Runnable} with the security context - * current at the time the wrapper was created. - */ -class SecurityAwareRunnable implements Runnable { - /** */ - private final Runnable delegate; - - /** */ - private final IgniteSecurity security; - - /** */ - private final SecurityContext secCtx; - - /** */ - private SecurityAwareRunnable(IgniteSecurity security, Runnable delegate) { - assert security.enabled(); - assert delegate != null; - - this.delegate = delegate; - this.security = security; - secCtx = security.securityContext(); - } - - /** {@inheritDoc} */ - @Override public void run() { - try (OperationSecurityContext ignored = security.withContext(secCtx)) { - delegate.run(); - } - } - - /** */ - static Runnable of(IgniteSecurity security, Runnable delegate) { - if (delegate == null || security.isDefaultContext()) - return delegate; - - return new SecurityAwareRunnable(security, delegate); - } -} diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/service/IgniteServiceProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/service/IgniteServiceProcessor.java index 7bf646d8d18ba..ee6da263d37ee 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/service/IgniteServiceProcessor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/service/IgniteServiceProcessor.java @@ -71,8 +71,8 @@ import org.apache.ignite.internal.processors.metric.MetricRegistryImpl; import org.apache.ignite.internal.processors.platform.services.PlatformService; import org.apache.ignite.internal.processors.platform.services.PlatformServiceConfiguration; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; import org.apache.ignite.internal.processors.security.SecurityContext; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.future.GridCompoundFuture; import org.apache.ignite.internal.util.future.GridFinishedFuture; import org.apache.ignite.internal.util.future.GridFutureAdapter; @@ -2083,7 +2083,7 @@ private SecurityException checkDeployPermissionDuringJoin(ClusterNode node, List return err; } - try (OperationSecurityContext ignored = ctx.security().withContext(secCtx)) { + try (Scope ignored = ctx.security().withContext(secCtx)) { for (ServiceInfo desc : svcs) { SecurityException err = checkPermissions(desc.name(), SERVICE_DEPLOY); diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareIoPool.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareIoPool.java similarity index 58% rename from modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareIoPool.java rename to modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareIoPool.java index c9e2359c1ac37..ebadf3636e779 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareIoPool.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareIoPool.java @@ -15,18 +15,14 @@ * limitations under the License. */ -package org.apache.ignite.internal.processors.security.thread; +package org.apache.ignite.internal.thread.context.pool; import java.util.concurrent.Executor; -import org.apache.ignite.internal.processors.security.IgniteSecurity; +import org.apache.ignite.internal.thread.context.concurrent.ThreadContextAwareExecutor; import org.apache.ignite.plugin.extensions.communication.IoPool; -import org.jetbrains.annotations.NotNull; - -/** Wrapper of {@link IoPool} that executes tasks in security context that was actual when task was added to pool queue. */ -public class SecurityAwareIoPool implements IoPool { - /** */ - private final IgniteSecurity security; +/** */ +public class ThreadContextAwareIoPool implements IoPool { /** */ private final IoPool delegate; @@ -34,20 +30,9 @@ public class SecurityAwareIoPool implements IoPool { private final Executor executor; /** */ - public SecurityAwareIoPool(IgniteSecurity security, IoPool delegate) { - assert security.enabled(); - assert delegate != null; - - this.security = security; + private ThreadContextAwareIoPool(IoPool delegate) { this.delegate = delegate; - - final Executor delegateExecutor = delegate.executor(); - - executor = delegateExecutor == null ? null : new Executor() { - @Override public void execute(@NotNull Runnable cmd) { - delegateExecutor.execute(SecurityAwareRunnable.of(SecurityAwareIoPool.this.security, cmd)); - } - }; + this.executor = ThreadContextAwareExecutor.wrap(delegate.executor()); } /** {@inheritDoc} */ @@ -59,4 +44,9 @@ public SecurityAwareIoPool(IgniteSecurity security, IoPool delegate) { @Override public Executor executor() { return executor; } + + /** */ + public static IoPool wrap(IoPool pool) { + return pool == null ? null : new ThreadContextAwareIoPool(pool); + } } diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareStripedExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedExecutor.java similarity index 59% rename from modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareStripedExecutor.java rename to modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedExecutor.java index f2239716cd839..daeaf001026e9 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareStripedExecutor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedExecutor.java @@ -15,42 +15,19 @@ * limitations under the License. */ -package org.apache.ignite.internal.processors.security.thread; +package org.apache.ignite.internal.thread.context.pool; import org.apache.ignite.IgniteLogger; -import org.apache.ignite.internal.processors.security.IgniteSecurity; +import org.apache.ignite.internal.thread.context.function.ThreadContextAwareRunnable; import org.apache.ignite.internal.util.StripedExecutor; import org.apache.ignite.internal.util.worker.GridWorkerListener; import org.apache.ignite.lang.IgniteInClosure; import org.jetbrains.annotations.NotNull; -/** - * Extends {@link StripedExecutor} with the ability to execute tasks in security context that was actual when task was - * added to executor's queue. - */ -public class SecurityAwareStripedExecutor extends StripedExecutor { - /** */ - private final IgniteSecurity security; - - /** */ - public SecurityAwareStripedExecutor( - IgniteSecurity security, - int cnt, - String igniteInstanceName, - String poolName, - IgniteLogger log, - IgniteInClosure errHnd, - GridWorkerListener gridWorkerLsnr, - long failureDetectionTimeout - ) { - super(cnt, igniteInstanceName, poolName, log, errHnd, gridWorkerLsnr, failureDetectionTimeout); - - this.security = security; - } - +/** */ +public class ThreadContextAwareStripedExecutor extends StripedExecutor { /** */ - public SecurityAwareStripedExecutor( - IgniteSecurity security, + public ThreadContextAwareStripedExecutor( int cnt, String igniteInstanceName, String poolName, @@ -61,17 +38,15 @@ public SecurityAwareStripedExecutor( long failureDetectionTimeout ) { super(cnt, igniteInstanceName, poolName, log, errHnd, stealTasks, gridWorkerLsnr, failureDetectionTimeout); - - this.security = security; } /** {@inheritDoc} */ - @Override public void execute(int idx, Runnable cmd) { - super.execute(idx, SecurityAwareRunnable.of(security, cmd)); + @Override public void execute(@NotNull Runnable cmd) { + super.execute(ThreadContextAwareRunnable.wrapIfActiveAttributesPresent(cmd)); } /** {@inheritDoc} */ - @Override public void execute(@NotNull Runnable cmd) { - super.execute(SecurityAwareRunnable.of(security, cmd)); + @Override public void execute(int idx, Runnable cmd) { + super.execute(idx, ThreadContextAwareRunnable.wrapIfActiveAttributesPresent(cmd)); } } diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareStripedThreadPoolExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedThreadPoolExecutor.java similarity index 59% rename from modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareStripedThreadPoolExecutor.java rename to modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedThreadPoolExecutor.java index ff80f2972a8f5..300dc6eb1df6e 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareStripedThreadPoolExecutor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedThreadPoolExecutor.java @@ -15,35 +15,27 @@ * limitations under the License. */ -package org.apache.ignite.internal.processors.security.thread; +package org.apache.ignite.internal.thread.context.pool; -import org.apache.ignite.internal.processors.security.IgniteSecurity; +import org.apache.ignite.internal.thread.context.function.ThreadContextAwareRunnable; import org.apache.ignite.thread.IgniteStripedThreadPoolExecutor; -/** - * Extends {@link IgniteStripedThreadPoolExecutor} with the ability to execute tasks in security context that was actual - * when task was added to executor's queue. - */ -public class SecurityAwareStripedThreadPoolExecutor extends IgniteStripedThreadPoolExecutor { - /** */ - private final IgniteSecurity security; - +/** */ +public class ThreadContextAwareStripedThreadPoolExecutor extends IgniteStripedThreadPoolExecutor { /** */ - public SecurityAwareStripedThreadPoolExecutor( - IgniteSecurity security, - int concurrentLvl, - String igniteInstanceName, + public ThreadContextAwareStripedThreadPoolExecutor( + int concurrentLvl, + String igniteInstanceName, String threadNamePrefix, - Thread.UncaughtExceptionHandler eHnd, - boolean allowCoreThreadTimeOut, + Thread.UncaughtExceptionHandler eHnd, + boolean allowCoreThreadTimeOut, long keepAliveTime ) { super(concurrentLvl, igniteInstanceName, threadNamePrefix, eHnd, allowCoreThreadTimeOut, keepAliveTime); - this.security = security; } /** {@inheritDoc} */ @Override public void execute(Runnable task, int idx) { - super.execute(SecurityAwareRunnable.of(security, task), idx); + super.execute(ThreadContextAwareRunnable.wrapIfActiveAttributesPresent(task), idx); } } diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareThreadPoolExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareThreadPoolExecutor.java similarity index 65% rename from modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareThreadPoolExecutor.java rename to modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareThreadPoolExecutor.java index 16c3216ab9902..afc6f614678a8 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/security/thread/SecurityAwareThreadPoolExecutor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareThreadPoolExecutor.java @@ -15,7 +15,7 @@ * limitations under the License. */ -package org.apache.ignite.internal.processors.security.thread; +package org.apache.ignite.internal.thread.context.pool; import java.util.Collection; import java.util.List; @@ -23,24 +23,17 @@ import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; -import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; -import org.apache.ignite.internal.processors.security.IgniteSecurity; +import org.apache.ignite.internal.thread.context.function.ThreadContextAwareCallable; +import org.apache.ignite.internal.thread.context.function.ThreadContextAwareRunnable; import org.apache.ignite.thread.IgniteThreadPoolExecutor; import org.jetbrains.annotations.NotNull; -/** - * Extends {@link ThreadPoolExecutor} with the ability to execute tasks in security context that was actual when task was - * added to executor's queue. - */ -public class SecurityAwareThreadPoolExecutor extends IgniteThreadPoolExecutor { - /** */ - private final IgniteSecurity security; - +/** */ +public class ThreadContextAwareThreadPoolExecutor extends IgniteThreadPoolExecutor { /** */ - public SecurityAwareThreadPoolExecutor( - IgniteSecurity security, + public ThreadContextAwareThreadPoolExecutor( String threadNamePrefix, String igniteInstanceName, int corePoolSize, @@ -51,51 +44,51 @@ public SecurityAwareThreadPoolExecutor( Thread.UncaughtExceptionHandler eHnd ) { super(threadNamePrefix, igniteInstanceName, corePoolSize, maxPoolSize, keepAliveTime, workQ, plc, eHnd); - - this.security = security; } /** {@inheritDoc} */ @NotNull @Override public Future submit(@NotNull Callable task) { - return super.submit(SecurityAwareCallable.of(security, task)); + return super.submit(ThreadContextAwareCallable.wrapIfActiveAttributesPresent(task)); } /** {@inheritDoc} */ @NotNull @Override public Future submit(@NotNull Runnable task, T res) { - return super.submit(SecurityAwareRunnable.of(security, task), res); + return super.submit(ThreadContextAwareRunnable.wrapIfActiveAttributesPresent(task), res); } /** {@inheritDoc} */ @NotNull @Override public Future submit(@NotNull Runnable task) { - return super.submit(SecurityAwareRunnable.of(security, task)); + return super.submit(ThreadContextAwareRunnable.wrapIfActiveAttributesPresent(task)); } /** {@inheritDoc} */ - @NotNull @Override public List> invokeAll( - @NotNull Collection> tasks) throws InterruptedException { - return super.invokeAll(SecurityAwareCallable.of(security, tasks)); + @NotNull @Override public List> invokeAll(@NotNull Collection> tasks) throws InterruptedException { + return super.invokeAll(ThreadContextAwareCallable.wrapIfActiveAttributesPresent(tasks)); } /** {@inheritDoc} */ - @NotNull @Override public List> invokeAll(@NotNull Collection> tasks, - long timeout, @NotNull TimeUnit unit) throws InterruptedException { - return super.invokeAll(SecurityAwareCallable.of(security, tasks), timeout, unit); + @NotNull @Override public List> invokeAll( + @NotNull Collection> tasks, + long timeout, + @NotNull TimeUnit unit + ) throws InterruptedException { + return super.invokeAll(ThreadContextAwareCallable.wrapIfActiveAttributesPresent(tasks), timeout, unit); } /** {@inheritDoc} */ @NotNull @Override public T invokeAny(@NotNull Collection> tasks) throws InterruptedException, ExecutionException { - return super.invokeAny(SecurityAwareCallable.of(security, tasks)); + return super.invokeAny(ThreadContextAwareCallable.wrapIfActiveAttributesPresent(tasks)); } /** {@inheritDoc} */ @Override public T invokeAny(@NotNull Collection> tasks, long timeout, @NotNull TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { - return super.invokeAny(SecurityAwareCallable.of(security, tasks), timeout, unit); + return super.invokeAny(ThreadContextAwareCallable.wrapIfActiveAttributesPresent(tasks), timeout, unit); } /** {@inheritDoc} */ @Override public void execute(@NotNull Runnable cmd) { - super.execute(SecurityAwareRunnable.of(security, cmd)); + super.execute(ThreadContextAwareRunnable.wrapIfActiveAttributesPresent(cmd)); } } diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/authentication/AuthenticationProcessorSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/authentication/AuthenticationProcessorSelfTest.java index 3cc4cbc001e78..c81fd4492d7a3 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/authentication/AuthenticationProcessorSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/authentication/AuthenticationProcessorSelfTest.java @@ -32,8 +32,8 @@ import org.apache.ignite.internal.IgniteEx; import org.apache.ignite.internal.IgniteInternalFuture; import org.apache.ignite.internal.processors.security.IgniteSecurity; -import org.apache.ignite.internal.processors.security.OperationSecurityContext; import org.apache.ignite.internal.processors.security.SecurityContext; +import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.typedef.G; import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.plugin.security.AuthenticationContext; @@ -556,7 +556,7 @@ private void checkInvalidUsername(final String name) { /** Test the ability to obtain the security context ot an authenticated user on the remote server node. */ @Test public void testRemoteNodeSecurityContext() throws Exception { - try (OperationSecurityContext ignored = grid(CLI_NODE).context().security().withContext(secCtxDflt)) { + try (Scope ignored = grid(CLI_NODE).context().security().withContext(secCtxDflt)) { grid(CLI_NODE).context().security().createUser("test", "pwd".toCharArray()); } @@ -565,7 +565,7 @@ public void testRemoteNodeSecurityContext() throws Exception { for (int i = 1; i < NODES_COUNT; i++) { IgniteSecurity security = ignite(i).context().security(); - try (OperationSecurityContext ignored = security.withContext(subj.id())) { + try (Scope ignored = security.withContext(subj.id())) { SecuritySubject rmtSubj = security.securityContext().subject(); assertEquals(subj.id(), rmtSubj.id()); @@ -646,14 +646,14 @@ public static SecurityContext authenticate(IgniteEx ignite, String login, String * @return Holder of current security contexts. If closed, all security context will bew restored. */ public static AutoCloseable withSecurityContextOnAllNodes(SecurityContext ctx) { - List oldSecCtxs = new ArrayList<>(); + List oldSecCtxs = new ArrayList<>(); for (Ignite node : G.allGrids()) oldSecCtxs.add(((IgniteEx)node).context().security().withContext(ctx)); return new AutoCloseable() { - @Override public void close() throws Exception { - oldSecCtxs.forEach(OperationSecurityContext::close); + @Override public void close() { + oldSecCtxs.forEach(Scope::close); } }; } diff --git a/modules/core/src/test/java/org/apache/ignite/internal/thread/context/ThreadContextAttributesTest.java b/modules/core/src/test/java/org/apache/ignite/internal/thread/context/ThreadContextAttributesTest.java new file mode 100644 index 0000000000000..619131203ad0b --- /dev/null +++ b/modules/core/src/test/java/org/apache/ignite/internal/thread/context/ThreadContextAttributesTest.java @@ -0,0 +1,390 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.thread.context; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.Callable; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.LinkedBlockingQueue; +import org.apache.ignite.internal.managers.communication.GridIoPolicy; +import org.apache.ignite.internal.thread.context.pool.ThreadContextAwareStripedExecutor; +import org.apache.ignite.internal.thread.context.pool.ThreadContextAwareStripedThreadPoolExecutor; +import org.apache.ignite.internal.thread.context.pool.ThreadContextAwareThreadPoolExecutor; +import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; +import org.junit.Test; + +import static java.util.concurrent.TimeUnit.MILLISECONDS; + +/** */ +public class ThreadContextAttributesTest extends GridCommonAbstractTest { + /** */ + private static final String DFLT_STR_VAL = null; + + /** */ + private static final Integer DFLT_INT_VAL = 0; + + /** */ + private static final ThreadContextAttribute STR_ATTR = ThreadContextAttributeRegistry.instance().register(); + + /** */ + private static final ThreadContextAttribute INT_ATTR = ThreadContextAttributeRegistry.instance().register(DFLT_INT_VAL); + + /** */ + private ExecutorService poolToShutdownAfterTest; + + /** {@inheritDoc} */ + @Override protected void beforeTest() throws Exception { + super.beforeTest(); + + AttributeValueChecker.CHECKS.clear(); + } + + /** {@inheritDoc} */ + @Override protected void afterTest() throws Exception { + super.afterTest(); + + if (poolToShutdownAfterTest != null) + poolToShutdownAfterTest.shutdownNow(); + } + + /** */ + @Test + public void testThreadScopeAttributes() { + String strAttrVal = "test"; + int intAttrVal = 1; + + checkAttributeValues(DFLT_STR_VAL, DFLT_INT_VAL); + + try (Scope ignored0 = ThreadContext.withAttribute(STR_ATTR, DFLT_STR_VAL).withAttribute(INT_ATTR, DFLT_INT_VAL)) { + checkAttributeValues(DFLT_STR_VAL, DFLT_INT_VAL); + + try (Scope ignored1 = ThreadContext.withAttribute(STR_ATTR, strAttrVal)) { + checkAttributeValues(strAttrVal, DFLT_INT_VAL); + + try (Scope ignored2 = ThreadContext.withAttribute(INT_ATTR, intAttrVal)) { + checkAttributeValues(strAttrVal, intAttrVal); + + try (Scope ignored3 = ThreadContext.withAttribute(STR_ATTR, DFLT_STR_VAL)) { + checkAttributeValues(DFLT_STR_VAL, intAttrVal); + } + + checkAttributeValues(strAttrVal, intAttrVal); + } + + checkAttributeValues(strAttrVal, DFLT_INT_VAL); + } + + checkAttributeValues(DFLT_STR_VAL, DFLT_INT_VAL); + } + + checkAttributeValues(DFLT_STR_VAL, DFLT_INT_VAL); + } + + /** */ + @Test + public void testScopeAttributeValueOverwrite() { + try (Scope ignored0 = ThreadContext.withAttribute(STR_ATTR, "test").withAttribute(INT_ATTR, 3)) { + checkAttributeValues("test", 3); + + try (Scope ignored1 = ThreadContext.withAttribute(INT_ATTR, 1).withAttribute(INT_ATTR, 2)) { + checkAttributeValues("test", 2); + } + + checkAttributeValues("test", 3); + } + } + + /** */ + @Test + public void testThreadContextSnapshot() { + List checkers = new ArrayList<>(); + + checkers.add(ThreadContextSnapshotChecker.create()); + + try (Scope ignored0 = ThreadContext.withAttribute(STR_ATTR, DFLT_STR_VAL).withAttribute(INT_ATTR, DFLT_INT_VAL)) { + checkers.add(ThreadContextSnapshotChecker.create()); + + try (Scope ignored1 = ThreadContext.withAttribute(STR_ATTR, "test")) { + checkers.add(ThreadContextSnapshotChecker.create()); + + try (Scope ignored2 = ThreadContext.withAttribute(INT_ATTR, 1)) { + checkers.add(ThreadContextSnapshotChecker.create()); + + try (Scope ignored3 = ThreadContext.withAttribute(STR_ATTR, DFLT_STR_VAL)) { + checkers.add(ThreadContextSnapshotChecker.create()); + } + + checkers.add(ThreadContextSnapshotChecker.create()); + } + + checkers.add(ThreadContextSnapshotChecker.create()); + } + + checkers.add(ThreadContextSnapshotChecker.create()); + } + + checkers.add(ThreadContextSnapshotChecker.create()); + + checkers.forEach(ThreadContextSnapshotChecker::check); + } + + /** */ + @Test + public void testRuntimeAttributeRegistration() { + // Initializes the Context Data for the current thread to check the growth of the array containing attribute values. + assertEquals(DFLT_INT_VAL, ThreadContext.get(INT_ATTR)); + + ThreadContextAttribute attr = ThreadContextAttributeRegistry.instance().register(); + + assertEquals(null, ThreadContext.get(attr)); + + try (Scope ignored0 = ThreadContext.withAttribute(attr, "test")) { + assertEquals("test", ThreadContext.get(attr)); + } + + assertEquals(null, ThreadContext.get(attr)); + } + + /** */ + @Test + public void testThreadContextAwareThreadPool() throws Exception { + ThreadContextAwareThreadPoolExecutor pool = deferShutdown(new ThreadContextAwareThreadPoolExecutor( + "test", + null, + 1, + 1, + Long.MAX_VALUE, + new LinkedBlockingQueue<>(), + GridIoPolicy.UNDEFINED, + null)); + + doThreadContextAwareExecutorServiceTest(pool); + } + + /** */ + @Test + public void testThreadContextAwareStripedThreadPoolExecutor() throws Exception { + ThreadContextAwareStripedThreadPoolExecutor pool = deferShutdown(new ThreadContextAwareStripedThreadPoolExecutor( + 2, + getTestIgniteInstanceName(0), + "", + (t, e) -> log.error("", e), + false, + 0 + )); + + BiConsumerX checks = (s, i) -> pool.execute(new AttributeValueChecker(s, i), 1); + + createAttributeChecks(checks); + + AttributeValueChecker.assertAllCreatedChecksPassed(); + } + + /** */ + @Test + public void testThreadContextAwareStripedExecutor() throws Exception { + ThreadContextAwareStripedExecutor pool = deferShutdown(new ThreadContextAwareStripedExecutor( + 2, + getTestIgniteInstanceName(0), + "", + log, + e -> {}, + false, + null, + getTestTimeout() + )); + + BiConsumerX checks = (s, i) -> { + pool.execute( new AttributeValueChecker(s, i)); + pool.execute(1, new AttributeValueChecker(s, i)); + }; + + createAttributeChecks(checks); + + AttributeValueChecker.assertAllCreatedChecksPassed(); + } + + /** */ + private void doThreadContextAwareExecutorServiceTest(ExecutorService pool) throws Exception { + CountDownLatch poolUnblockedLatch = blockPool(pool); + + BiConsumerX asyncChecks = (s, i) -> { + pool.submit((Runnable)new AttributeValueChecker(s, i)); + pool.submit(new AttributeValueChecker(s, i), 0); + pool.submit((Callable)new AttributeValueChecker(s, i)); + }; + + BiConsumerX syncChecks = (s, i) -> { + pool.invokeAny(List.of((Callable)new AttributeValueChecker(s, i))); + pool.invokeAny(List.of((Callable)new AttributeValueChecker(s, i)), 1000, MILLISECONDS); + pool.invokeAll(List.of((Callable)new AttributeValueChecker(s, i))); + pool.invokeAll(List.of((Callable)new AttributeValueChecker(s, i)), 1000, MILLISECONDS); + }; + + createAttributeChecks(asyncChecks); + + poolUnblockedLatch.countDown(); + + createAttributeChecks(syncChecks); + + AttributeValueChecker.assertAllCreatedChecksPassed(); + } + + /** */ + private CountDownLatch blockPool(ExecutorService pool) { + CountDownLatch latch = new CountDownLatch(1); + + pool.submit(() -> { + try { + latch.await(); + } + catch (InterruptedException e) { + throw new RuntimeException(e); + } + }); + + return latch; + } + + /** */ + private T deferShutdown(T pool) { + poolToShutdownAfterTest = pool; + + return pool; + } + + /** */ + private void createAttributeChecks(BiConsumerX checkGenerator) throws Exception { + try (Scope ignored = ThreadContext.withAttribute(STR_ATTR, "test0").withAttribute(INT_ATTR, 1)) { + checkGenerator.accept("test0", 1); + } + + try (Scope ignored = ThreadContext.withAttribute(STR_ATTR, "test1").withAttribute(INT_ATTR, 2)) { + checkGenerator.accept("test1", 2); + } + + checkGenerator.accept(DFLT_STR_VAL, DFLT_INT_VAL); + } + + /** */ + private static void checkAttributeValues(String strAttrVal, Integer intAttrVal) { + assertEquals(intAttrVal, ThreadContext.get(INT_ATTR)); + assertEquals(strAttrVal, ThreadContext.get(STR_ATTR)); + } + + /** */ + private static class ThreadContextSnapshotChecker { + /** */ + private final ThreadContextSnapshot snapshot; + + /** */ + private final String strAttrVal; + + /** */ + private final Integer intAttrVal; + + /** */ + private ThreadContextSnapshotChecker(ThreadContextSnapshot snapshot, String strAttrVal, Integer intAttrVal) { + this.snapshot = snapshot; + this.strAttrVal = strAttrVal; + this.intAttrVal = intAttrVal; + } + + /** */ + public void check() { + checkAttributeValues(DFLT_STR_VAL, DFLT_INT_VAL); + + // Checks that snapshot are restored correctly for attributes with both initialized and initial values. + try (Scope ignored0 = ThreadContext.withAttribute(STR_ATTR, "test")) { + checkAttributeValues("test", DFLT_INT_VAL); + + try (Scope ignored1 = ThreadContext.withSnapshot(snapshot)) { + checkAttributeValues(strAttrVal, intAttrVal); + } + + checkAttributeValues("test", DFLT_INT_VAL); + } + + checkAttributeValues(DFLT_STR_VAL, DFLT_INT_VAL); + } + + /** */ + public static ThreadContextSnapshotChecker create() { + return new ThreadContextSnapshotChecker( + ThreadContext.createSnapshot(), + ThreadContext.get(STR_ATTR), + ThreadContext.get(INT_ATTR) + ); + } + } + + /** */ + private static class AttributeValueChecker extends CompletableFuture implements Runnable, Callable { + /** */ + static final List CHECKS = new ArrayList<>(); + + /** */ + private final String strAttrVal; + + /** */ + private final Integer intAttrVal; + + /** */ + public AttributeValueChecker(String strAttrVal, Integer intAttrVal) { + this.strAttrVal = strAttrVal; + this.intAttrVal = intAttrVal; + + CHECKS.add(this); + } + + /** {@inheritDoc} */ + @Override public void run() { + try { + checkAttributeValues(strAttrVal, intAttrVal); + + complete(null); + } + catch (Throwable e) { + completeExceptionally(e); + } + } + + /** {@inheritDoc} */ + @Override public Integer call() { + run(); + + return 0; + } + + /** */ + static void assertAllCreatedChecksPassed() throws Exception { + for (AttributeValueChecker check : CHECKS) { + check.get(1000, MILLISECONDS); + } + } + } + + /** */ + private interface BiConsumerX { + /** */ + void accept(T t, U u) throws Exception; + } +} diff --git a/modules/core/src/test/java/org/apache/ignite/testsuites/SecurityTestSuite.java b/modules/core/src/test/java/org/apache/ignite/testsuites/SecurityTestSuite.java index da3e8c262ae26..229fd2757ba84 100644 --- a/modules/core/src/test/java/org/apache/ignite/testsuites/SecurityTestSuite.java +++ b/modules/core/src/test/java/org/apache/ignite/testsuites/SecurityTestSuite.java @@ -72,6 +72,7 @@ import org.apache.ignite.internal.processors.security.service.ServiceAuthorizationTest; import org.apache.ignite.internal.processors.security.service.ServiceStaticConfigTest; import org.apache.ignite.internal.processors.security.snapshot.SnapshotPermissionCheckTest; +import org.apache.ignite.internal.thread.context.ThreadContextAttributesTest; import org.apache.ignite.ssl.MultipleSSLContextsTest; import org.apache.ignite.tools.junit.JUnitTeamcityReporter; import org.junit.BeforeClass; @@ -143,6 +144,7 @@ NodeJoinPermissionsTest.class, ActivationOnJoinWithoutPermissionsWithPersistenceTest.class, SecurityContextInternalFuturePropagationTest.class, + ThreadContextAttributesTest.class, }) public class SecurityTestSuite { /** */ From 8e857404abcd74eb8aaec0329c93961c7550c569 Mon Sep 17 00:00:00 2001 From: Mikhail Petrov Date: Tue, 30 Sep 2025 16:56:12 +0300 Subject: [PATCH 2/5] IGNITE-26787 --- .../exec/task/QueryBlockingTaskExecutor.java | 2 +- .../exec/task/StripedQueryTaskExecutor.java | 2 +- .../exec/rel/AbstractExecutionTest.java | 3 ++- .../calcite/planner/PlanExecutionTest.java | 2 +- .../store/jdbc/CacheAbstractJdbcStore.java | 2 +- .../cache/query/index/IndexProcessor.java | 2 +- .../IndexingDefragmentation.java | 2 +- .../jdbc/thin/JdbcThinConnection.java | 2 +- .../managers/communication/GridIoManager.java | 2 +- .../discovery/GridDiscoveryManager.java | 2 +- .../IgniteAuthenticationProcessor.java | 2 +- .../processors/cache/GridCacheAdapter.java | 2 +- .../processors/cache/WalStateManager.java | 2 +- .../dht/topology/PartitionsEvictManager.java | 2 +- .../checkpoint/CheckpointContextImpl.java | 2 +- .../checkpoint/CheckpointWorkflow.java | 2 +- .../persistence/checkpoint/Checkpointer.java | 2 +- .../CachePartitionDefragmentationManager.java | 2 +- .../persistence/pagemem/PageMemoryImpl.java | 2 +- .../CacheContinuousQueryHandler.java | 2 +- .../continuous/GridContinuousProcessor.java | 2 +- .../datastreamer/DataStreamProcessor.java | 2 +- .../metric/PushMetricsExporterAdapter.java | 2 +- .../processors/pool/PoolProcessor.java | 6 ++--- .../processors/query/stat/BusyExecutor.java | 2 +- .../stat/IgniteGlobalStatisticsManager.java | 2 +- .../IgniteStatisticsConfigurationManager.java | 2 +- .../stat/IgniteStatisticsManagerImpl.java | 2 +- .../query/stat/StatisticsProcessor.java | 3 +-- .../service/IgniteServiceProcessor.java | 4 ++-- .../IgniteStripedThreadPoolExecutor.java | 2 +- .../thread/IgniteThreadFactory.java | 3 ++- .../thread/IgniteThreadPoolExecutor.java | 2 +- .../thread/OomExceptionHandler.java | 2 +- .../thread/SameThreadExecutor.java | 2 +- ...ContextAwareStripedThreadPoolExecutor.java | 2 +- .../ThreadContextAwareThreadPoolExecutor.java | 2 +- .../ignite/internal/util/IgniteUtils.java | 2 +- .../tcp/internal/ConnectionClientPool.java | 2 +- .../tcp/internal/GridNioServerWrapper.java | 2 +- .../ignite/spi/discovery/tcp/ClientImpl.java | 2 +- .../ignite/spi/discovery/tcp/ServerImpl.java | 2 +- .../apache/ignite/thread/package-info.java | 23 ------------------- ...TransactionsSystemUserTimeMetricsTest.java | 2 +- .../distributed/CacheExchangeMergeTest.java | 2 +- ...GridThreadPoolExecutorServiceSelfTest.java | 2 +- .../{ => internal}/thread/GridThreadTest.java | 3 ++- .../thread/IgniteThreadPoolSizeTest.java | 2 +- .../thread/ThreadPoolMetricsTest.java | 2 +- .../internal/util/IgniteUtilsSelfTest.java | 2 +- .../future/GridFutureAdapterSelfTest.java | 2 +- .../GridMarshallerResourceBean.java | 2 +- .../junits/IgniteTestResources.java | 2 +- .../testsuites/IgniteUtilSelfTestSuite.java | 8 +++---- .../query/stat/BusyExecutorTest.java | 2 +- .../query/stat/StatisticsAbstractTest.java | 2 +- .../zk/internal/ZookeeperDiscoveryImpl.java | 2 +- 57 files changed, 65 insertions(+), 86 deletions(-) rename modules/core/src/main/java/org/apache/ignite/{ => internal}/thread/IgniteStripedThreadPoolExecutor.java (99%) rename modules/core/src/main/java/org/apache/ignite/{ => internal}/thread/IgniteThreadFactory.java (97%) rename modules/core/src/main/java/org/apache/ignite/{ => internal}/thread/IgniteThreadPoolExecutor.java (99%) rename modules/core/src/main/java/org/apache/ignite/{ => internal}/thread/OomExceptionHandler.java (97%) rename modules/core/src/main/java/org/apache/ignite/{ => internal}/thread/SameThreadExecutor.java (96%) delete mode 100644 modules/core/src/main/java/org/apache/ignite/thread/package-info.java rename modules/core/src/test/java/org/apache/ignite/{ => internal}/thread/GridThreadPoolExecutorServiceSelfTest.java (99%) rename modules/core/src/test/java/org/apache/ignite/{ => internal}/thread/GridThreadTest.java (95%) rename modules/core/src/test/java/org/apache/ignite/{ => internal}/thread/IgniteThreadPoolSizeTest.java (98%) rename modules/core/src/test/java/org/apache/ignite/{ => internal}/thread/ThreadPoolMetricsTest.java (99%) diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/task/QueryBlockingTaskExecutor.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/task/QueryBlockingTaskExecutor.java index c4feb74b8e99d..d20883b16414d 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/task/QueryBlockingTaskExecutor.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/task/QueryBlockingTaskExecutor.java @@ -22,9 +22,9 @@ import org.apache.ignite.internal.GridKernalContext; import org.apache.ignite.internal.managers.communication.GridIoPolicy; import org.apache.ignite.internal.processors.security.SecurityContext; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.typedef.internal.S; import org.apache.ignite.internal.util.typedef.internal.U; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import static org.apache.ignite.internal.processors.metric.impl.MetricUtils.metricName; import static org.apache.ignite.internal.processors.pool.PoolProcessor.THREAD_POOLS; diff --git a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/task/StripedQueryTaskExecutor.java b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/task/StripedQueryTaskExecutor.java index d1023f543f3c9..d4b783e1406db 100644 --- a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/task/StripedQueryTaskExecutor.java +++ b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/exec/task/StripedQueryTaskExecutor.java @@ -20,8 +20,8 @@ import java.util.UUID; import org.apache.ignite.internal.GridKernalContext; import org.apache.ignite.internal.processors.security.SecurityContext; +import org.apache.ignite.internal.thread.IgniteStripedThreadPoolExecutor; import org.apache.ignite.internal.util.typedef.internal.U; -import org.apache.ignite.thread.IgniteStripedThreadPoolExecutor; import static org.apache.ignite.internal.processors.metric.impl.MetricUtils.metricName; import static org.apache.ignite.internal.processors.pool.PoolProcessor.THREAD_POOLS; diff --git a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/exec/rel/AbstractExecutionTest.java b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/exec/rel/AbstractExecutionTest.java index b38043b404ba4..b840c9743e858 100644 --- a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/exec/rel/AbstractExecutionTest.java +++ b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/exec/rel/AbstractExecutionTest.java @@ -61,6 +61,7 @@ import org.apache.ignite.internal.processors.query.calcite.prepare.BaseQueryContext; import org.apache.ignite.internal.processors.security.NoOpIgniteSecurityProcessor; import org.apache.ignite.internal.processors.timeout.GridTimeoutProcessor; +import org.apache.ignite.internal.thread.IgniteStripedThreadPoolExecutor; import org.apache.ignite.internal.util.typedef.T2; import org.apache.ignite.plugin.extensions.communication.Message; import org.apache.ignite.testframework.GridTestUtils; @@ -247,7 +248,7 @@ public void setup() throws Exception { } /** Task reordering executor. */ - private static class IgniteTestStripedThreadPoolExecutor extends org.apache.ignite.thread.IgniteStripedThreadPoolExecutor { + private static class IgniteTestStripedThreadPoolExecutor extends IgniteStripedThreadPoolExecutor { /** */ final Deque> tasks = new ArrayDeque<>(); diff --git a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/planner/PlanExecutionTest.java b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/planner/PlanExecutionTest.java index 40a803dc19b9c..e2ff17f5e391b 100644 --- a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/planner/PlanExecutionTest.java +++ b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/planner/PlanExecutionTest.java @@ -61,9 +61,9 @@ import org.apache.ignite.internal.processors.query.calcite.type.IgniteTypeSystem; import org.apache.ignite.internal.processors.query.calcite.util.Commons; import org.apache.ignite.internal.processors.security.NoOpIgniteSecurityProcessor; +import org.apache.ignite.internal.thread.IgniteStripedThreadPoolExecutor; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.testframework.junits.GridTestKernalContext; -import org.apache.ignite.thread.IgniteStripedThreadPoolExecutor; import org.junit.Assert; import org.junit.Test; diff --git a/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheAbstractJdbcStore.java b/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheAbstractJdbcStore.java index f322f93111f98..9d59c9ea29a63 100644 --- a/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheAbstractJdbcStore.java +++ b/modules/core/src/main/java/org/apache/ignite/cache/store/jdbc/CacheAbstractJdbcStore.java @@ -61,6 +61,7 @@ import org.apache.ignite.cache.store.jdbc.dialect.SQLServerDialect; import org.apache.ignite.internal.binary.BinaryObjectEx; import org.apache.ignite.internal.binary.BinaryUtils; +import org.apache.ignite.internal.thread.IgniteThreadFactory; import org.apache.ignite.internal.util.tostring.GridToStringExclude; import org.apache.ignite.internal.util.typedef.C1; import org.apache.ignite.internal.util.typedef.F; @@ -71,7 +72,6 @@ import org.apache.ignite.resources.CacheStoreSessionResource; import org.apache.ignite.resources.IgniteInstanceResource; import org.apache.ignite.resources.LoggerResource; -import org.apache.ignite.thread.IgniteThreadFactory; import org.apache.ignite.transactions.Transaction; import org.jetbrains.annotations.Nullable; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexProcessor.java index 35ae189f8e7f1..f1a79809681c7 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexProcessor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/IndexProcessor.java @@ -64,13 +64,13 @@ import org.apache.ignite.internal.processors.query.QueryUtils; import org.apache.ignite.internal.processors.query.schema.IndexRebuildCancelToken; import org.apache.ignite.internal.processors.query.schema.SchemaIndexCacheVisitor; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.GridAtomicLong; import org.apache.ignite.internal.util.collection.IntMap; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.X; import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.spi.IgniteSpiException; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import org.jetbrains.annotations.Nullable; /** diff --git a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/defragmentation/IndexingDefragmentation.java b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/defragmentation/IndexingDefragmentation.java index 6269b7ab90ec5..0a268962f4d19 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/defragmentation/IndexingDefragmentation.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/cache/query/index/sorted/defragmentation/IndexingDefragmentation.java @@ -42,9 +42,9 @@ import org.apache.ignite.internal.processors.cache.persistence.defragmentation.TreeIterator; import org.apache.ignite.internal.processors.cache.persistence.pagemem.PageMemoryEx; import org.apache.ignite.internal.processors.cache.persistence.tree.io.BPlusIO; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.IgniteUtils; import org.apache.ignite.internal.util.collection.IntMap; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import org.jetbrains.annotations.Nullable; import static org.apache.ignite.failure.FailureType.CRITICAL_ERROR; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/jdbc/thin/JdbcThinConnection.java b/modules/core/src/main/java/org/apache/ignite/internal/jdbc/thin/JdbcThinConnection.java index 1ce478c7c8649..f9dc1588012b8 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/jdbc/thin/JdbcThinConnection.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/jdbc/thin/JdbcThinConnection.java @@ -119,6 +119,7 @@ import org.apache.ignite.internal.sql.command.SqlSetStreamingCommand; import org.apache.ignite.internal.sql.optimizer.affinity.PartitionClientContext; import org.apache.ignite.internal.sql.optimizer.affinity.PartitionResult; +import org.apache.ignite.internal.thread.IgniteThreadFactory; import org.apache.ignite.internal.util.HostAndPortRange; import org.apache.ignite.internal.util.future.GridFutureAdapter; import org.apache.ignite.internal.util.typedef.internal.U; @@ -128,7 +129,6 @@ import org.apache.ignite.marshaller.MarshallerContext; import org.apache.ignite.marshaller.Marshallers; import org.apache.ignite.marshaller.jdk.JdkMarshaller; -import org.apache.ignite.thread.IgniteThreadFactory; import org.apache.ignite.transactions.TransactionIsolation; import org.jetbrains.annotations.Nullable; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/managers/communication/GridIoManager.java b/modules/core/src/main/java/org/apache/ignite/internal/managers/communication/GridIoManager.java index dd0d95352c787..4457bb0773086 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/managers/communication/GridIoManager.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/managers/communication/GridIoManager.java @@ -104,6 +104,7 @@ import org.apache.ignite.internal.processors.tracing.MTC.TraceSurroundings; import org.apache.ignite.internal.processors.tracing.Span; import org.apache.ignite.internal.processors.tracing.SpanTags; +import org.apache.ignite.internal.thread.IgniteThreadFactory; import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.GridBoundedConcurrentLinkedHashSet; import org.apache.ignite.internal.util.IgniteUtils; @@ -140,7 +141,6 @@ import org.apache.ignite.spi.communication.tcp.internal.ConnectionRequestor; import org.apache.ignite.spi.communication.tcp.internal.TcpConnectionRequestDiscoveryMessage; import org.apache.ignite.spi.communication.tcp.internal.TcpInverseConnectionResponseMessage; -import org.apache.ignite.thread.IgniteThreadFactory; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java b/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java index 01cf695732d3d..4f222c255b70b 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/managers/discovery/GridDiscoveryManager.java @@ -95,6 +95,7 @@ import org.apache.ignite.internal.processors.security.IgniteSecurity; import org.apache.ignite.internal.processors.security.SecurityContext; import org.apache.ignite.internal.processors.tracing.messages.SpanContainer; +import org.apache.ignite.internal.thread.OomExceptionHandler; import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.GridAtomicLong; import org.apache.ignite.internal.util.GridBoundedConcurrentLinkedHashMap; @@ -144,7 +145,6 @@ import org.apache.ignite.spi.systemview.view.NodeAttributeView; import org.apache.ignite.spi.systemview.view.NodeMetricsView; import org.apache.ignite.thread.IgniteThread; -import org.apache.ignite.thread.OomExceptionHandler; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/authentication/IgniteAuthenticationProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/authentication/IgniteAuthenticationProcessor.java index 22139ca73078d..3a73a1b025c01 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/authentication/IgniteAuthenticationProcessor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/authentication/IgniteAuthenticationProcessor.java @@ -57,6 +57,7 @@ import org.apache.ignite.internal.processors.security.GridSecurityProcessor; import org.apache.ignite.internal.processors.security.IgniteSecurityProcessor; import org.apache.ignite.internal.processors.security.SecurityContext; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.future.GridFutureAdapter; import org.apache.ignite.internal.util.tostring.GridToStringExclude; import org.apache.ignite.internal.util.tostring.GridToStringInclude; @@ -77,7 +78,6 @@ import org.apache.ignite.spi.discovery.DiscoveryDataBag; import org.apache.ignite.spi.discovery.DiscoverySpi; import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import org.jetbrains.annotations.Nullable; import static org.apache.ignite.events.EventType.EVT_NODE_FAILED; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java index f6a8cee0b6039..0bdcaaceb0192 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheAdapter.java @@ -114,6 +114,7 @@ import org.apache.ignite.internal.processors.platform.client.cache.ImmutableArraySet; import org.apache.ignite.internal.processors.security.SecurityContext; import org.apache.ignite.internal.processors.task.GridInternal; +import org.apache.ignite.internal.thread.IgniteThreadFactory; import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.transactions.IgniteTxHeuristicCheckedException; import org.apache.ignite.internal.transactions.IgniteTxRollbackCheckedException; @@ -152,7 +153,6 @@ import org.apache.ignite.resources.IgniteInstanceResource; import org.apache.ignite.resources.JobContextResource; import org.apache.ignite.resources.LoggerResource; -import org.apache.ignite.thread.IgniteThreadFactory; import org.apache.ignite.transactions.Transaction; import org.apache.ignite.transactions.TransactionConcurrency; import org.apache.ignite.transactions.TransactionIsolation; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/WalStateManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/WalStateManager.java index 6a64035b7c94f..8e66f3d76ecb5 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/WalStateManager.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/WalStateManager.java @@ -47,6 +47,7 @@ import org.apache.ignite.internal.processors.cache.persistence.metastorage.MetastorageLifecycleListener; import org.apache.ignite.internal.processors.cache.persistence.metastorage.ReadOnlyMetastorage; import org.apache.ignite.internal.processors.cache.persistence.metastorage.ReadWriteMetastorage; +import org.apache.ignite.internal.thread.OomExceptionHandler; import org.apache.ignite.internal.util.GridBoundedConcurrentLinkedHashSet; import org.apache.ignite.internal.util.future.GridFinishedFuture; import org.apache.ignite.internal.util.future.GridFutureAdapter; @@ -61,7 +62,6 @@ import org.apache.ignite.lang.IgniteRunnable; import org.apache.ignite.lang.IgniteUuid; import org.apache.ignite.thread.IgniteThread; -import org.apache.ignite.thread.OomExceptionHandler; import org.jetbrains.annotations.Nullable; import static org.apache.ignite.IgniteSystemProperties.IGNITE_DISABLE_WAL_DURING_REBALANCING; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/topology/PartitionsEvictManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/topology/PartitionsEvictManager.java index f4e2bb1a24b91..b0289a9d42bec 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/topology/PartitionsEvictManager.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/topology/PartitionsEvictManager.java @@ -41,12 +41,12 @@ import org.apache.ignite.internal.processors.cache.CacheStoppedException; import org.apache.ignite.internal.processors.cache.GridCacheContext; import org.apache.ignite.internal.processors.cache.GridCacheSharedManagerAdapter; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.future.GridFinishedFuture; import org.apache.ignite.internal.util.future.GridFutureAdapter; import org.apache.ignite.internal.util.typedef.internal.LT; import org.apache.ignite.internal.util.typedef.internal.S; import org.apache.ignite.internal.util.typedef.internal.U; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import static java.util.Objects.nonNull; import static org.apache.ignite.IgniteSystemProperties.getLong; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointContextImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointContextImpl.java index ea9d933b700d5..934c37b818fb6 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointContextImpl.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointContextImpl.java @@ -22,11 +22,11 @@ import org.apache.ignite.IgniteCheckedException; import org.apache.ignite.internal.IgniteInternalFuture; import org.apache.ignite.internal.processors.cache.persistence.partstate.PartitionAllocationMap; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.future.GridCompoundFuture; import org.apache.ignite.internal.util.future.GridFutureAdapter; import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.internal.util.worker.WorkProgressDispatcher; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import org.jetbrains.annotations.Nullable; import static org.apache.ignite.internal.processors.cache.persistence.CheckpointState.FINISHED; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointWorkflow.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointWorkflow.java index ef369d24a0b59..9fb267fb26afb 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointWorkflow.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointWorkflow.java @@ -62,6 +62,7 @@ import org.apache.ignite.internal.processors.cache.persistence.pagemem.PageMemoryEx; import org.apache.ignite.internal.processors.cache.persistence.partstate.PartitionAllocationMap; import org.apache.ignite.internal.processors.cache.persistence.wal.WALPointer; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.GridConcurrentHashSet; import org.apache.ignite.internal.util.GridConcurrentMultiPairQueue; import org.apache.ignite.internal.util.GridMultiCollectionWrapper; @@ -72,7 +73,6 @@ import org.apache.ignite.internal.util.typedef.T2; import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.internal.util.worker.WorkProgressDispatcher; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import org.jetbrains.annotations.Nullable; import org.jsr166.ConcurrentLinkedHashMap; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/Checkpointer.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/Checkpointer.java index e371ea0ca520f..523ca94c96e79 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/Checkpointer.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/Checkpointer.java @@ -56,6 +56,7 @@ import org.apache.ignite.internal.processors.cache.persistence.wal.WALPointer; import org.apache.ignite.internal.processors.failure.FailureProcessor; import org.apache.ignite.internal.processors.performancestatistics.PerformanceStatisticsProcessor; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.GridConcurrentMultiPairQueue; import org.apache.ignite.internal.util.StripedExecutor; import org.apache.ignite.internal.util.future.CountDownFuture; @@ -67,7 +68,6 @@ import org.apache.ignite.internal.worker.WorkersRegistry; import org.apache.ignite.lang.IgniteBiTuple; import org.apache.ignite.lang.IgniteInClosure; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import org.jetbrains.annotations.Nullable; import org.jsr166.ConcurrentLinkedHashMap; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/defragmentation/CachePartitionDefragmentationManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/defragmentation/CachePartitionDefragmentationManager.java index 23f7ee9d98865..c163ddb7c862e 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/defragmentation/CachePartitionDefragmentationManager.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/defragmentation/CachePartitionDefragmentationManager.java @@ -71,6 +71,7 @@ import org.apache.ignite.internal.processors.cache.tree.PendingEntriesTree; import org.apache.ignite.internal.processors.cache.tree.PendingRow; import org.apache.ignite.internal.processors.query.GridQueryProcessor; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.GridAtomicLong; import org.apache.ignite.internal.util.IgniteUtils; import org.apache.ignite.internal.util.collection.IntHashMap; @@ -85,7 +86,6 @@ import org.apache.ignite.lang.IgniteInClosure; import org.apache.ignite.lang.IgniteOutClosure; import org.apache.ignite.maintenance.MaintenanceRegistry; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import static java.util.Comparator.comparing; import static java.util.stream.StreamSupport.stream; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/pagemem/PageMemoryImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/pagemem/PageMemoryImpl.java index b37f287ad9ec5..82a026085c795 100755 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/pagemem/PageMemoryImpl.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/pagemem/PageMemoryImpl.java @@ -76,6 +76,7 @@ import org.apache.ignite.internal.processors.cache.persistence.wal.crc.IgniteDataIntegrityViolationException; import org.apache.ignite.internal.processors.compress.CompressionProcessor; import org.apache.ignite.internal.processors.query.GridQueryRowCacheCleaner; +import org.apache.ignite.internal.thread.IgniteThreadFactory; import org.apache.ignite.internal.util.GridConcurrentHashSet; import org.apache.ignite.internal.util.GridLongList; import org.apache.ignite.internal.util.GridMultiCollectionWrapper; @@ -89,7 +90,6 @@ import org.apache.ignite.lang.IgniteBiTuple; import org.apache.ignite.lang.IgniteOutClosure; import org.apache.ignite.spi.encryption.noop.NoopEncryptionSpi; -import org.apache.ignite.thread.IgniteThreadFactory; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.TestOnly; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/query/continuous/CacheContinuousQueryHandler.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/query/continuous/CacheContinuousQueryHandler.java index 665cf6cc029fc..fbcf9711cba44 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/query/continuous/CacheContinuousQueryHandler.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/query/continuous/CacheContinuousQueryHandler.java @@ -69,6 +69,7 @@ import org.apache.ignite.internal.processors.continuous.GridContinuousHandler; import org.apache.ignite.internal.processors.continuous.GridContinuousQueryBatch; import org.apache.ignite.internal.processors.platform.cache.query.PlatformContinuousQueryFilter; +import org.apache.ignite.internal.thread.IgniteStripedThreadPoolExecutor; import org.apache.ignite.internal.util.future.GridFinishedFuture; import org.apache.ignite.internal.util.future.GridFutureAdapter; import org.apache.ignite.internal.util.lang.GridPlainRunnable; @@ -81,7 +82,6 @@ import org.apache.ignite.lang.IgniteAsyncCallback; import org.apache.ignite.lang.IgniteBiTuple; import org.apache.ignite.lang.IgniteClosure; -import org.apache.ignite.thread.IgniteStripedThreadPoolExecutor; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/continuous/GridContinuousProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/continuous/GridContinuousProcessor.java index df98fc299d4c8..29cb108157eee 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/continuous/GridContinuousProcessor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/continuous/GridContinuousProcessor.java @@ -74,6 +74,7 @@ import org.apache.ignite.internal.processors.cache.distributed.dht.preloader.CachePartitionPartialCountersMap; import org.apache.ignite.internal.processors.cache.query.continuous.CacheContinuousQueryHandler; import org.apache.ignite.internal.processors.timeout.GridTimeoutObject; +import org.apache.ignite.internal.thread.OomExceptionHandler; import org.apache.ignite.internal.util.future.GridFinishedFuture; import org.apache.ignite.internal.util.future.GridFutureAdapter; import org.apache.ignite.internal.util.lang.GridPlainRunnable; @@ -98,7 +99,6 @@ import org.apache.ignite.spi.discovery.DiscoveryDataBag.JoiningNodeDiscoveryData; import org.apache.ignite.spi.systemview.view.ContinuousQueryView; import org.apache.ignite.thread.IgniteThread; -import org.apache.ignite.thread.OomExceptionHandler; import org.jetbrains.annotations.Nullable; import static org.apache.ignite.events.EventType.EVT_NODE_FAILED; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastreamer/DataStreamProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastreamer/DataStreamProcessor.java index 65f225b22a923..9c618242e3bd4 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/datastreamer/DataStreamProcessor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/datastreamer/DataStreamProcessor.java @@ -34,6 +34,7 @@ import org.apache.ignite.internal.processors.cache.GridCacheAdapter; import org.apache.ignite.internal.processors.cache.GridCacheContext; import org.apache.ignite.internal.processors.cache.distributed.dht.GridDhtTopologyFuture; +import org.apache.ignite.internal.thread.OomExceptionHandler; import org.apache.ignite.internal.util.GridConcurrentHashSet; import org.apache.ignite.internal.util.GridSpinBusyLock; import org.apache.ignite.internal.util.future.GridFutureAdapter; @@ -47,7 +48,6 @@ import org.apache.ignite.lang.IgniteInClosure; import org.apache.ignite.marshaller.Marshaller; import org.apache.ignite.stream.StreamReceiver; -import org.apache.ignite.thread.OomExceptionHandler; import org.jetbrains.annotations.Nullable; import static org.apache.ignite.internal.GridTopic.TOPIC_DATASTREAM; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/metric/PushMetricsExporterAdapter.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/metric/PushMetricsExporterAdapter.java index 8a58cdfe1d267..bb12490060af1 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/metric/PushMetricsExporterAdapter.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/metric/PushMetricsExporterAdapter.java @@ -21,13 +21,13 @@ import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledFuture; import java.util.function.Predicate; +import org.apache.ignite.internal.thread.IgniteThreadFactory; import org.apache.ignite.spi.IgniteSpiAdapter; import org.apache.ignite.spi.IgniteSpiContext; import org.apache.ignite.spi.IgniteSpiException; import org.apache.ignite.spi.metric.MetricExporterSpi; import org.apache.ignite.spi.metric.ReadOnlyMetricManager; import org.apache.ignite.spi.metric.ReadOnlyMetricRegistry; -import org.apache.ignite.thread.IgniteThreadFactory; import org.jetbrains.annotations.Nullable; import static java.util.concurrent.TimeUnit.MILLISECONDS; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java index 32082268ce1dc..01b612b06dbb9 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java @@ -45,6 +45,9 @@ import org.apache.ignite.internal.processors.plugin.IgnitePluginProcessor; import org.apache.ignite.internal.processors.security.IgniteSecurity; import org.apache.ignite.internal.processors.timeout.GridTimeoutProcessor; +import org.apache.ignite.internal.thread.IgniteStripedThreadPoolExecutor; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; +import org.apache.ignite.internal.thread.SameThreadExecutor; import org.apache.ignite.internal.thread.context.pool.ThreadContextAwareIoPool; import org.apache.ignite.internal.thread.context.pool.ThreadContextAwareStripedExecutor; import org.apache.ignite.internal.thread.context.pool.ThreadContextAwareStripedThreadPoolExecutor; @@ -61,9 +64,6 @@ import org.apache.ignite.metric.MetricRegistry; import org.apache.ignite.plugin.extensions.communication.IoPool; import org.apache.ignite.spi.systemview.view.StripedExecutorTaskView; -import org.apache.ignite.thread.IgniteStripedThreadPoolExecutor; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; -import org.apache.ignite.thread.SameThreadExecutor; import org.jetbrains.annotations.Nullable; import static org.apache.ignite.IgniteSystemProperties.IGNITE_STARVATION_CHECK_INTERVAL; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/BusyExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/BusyExecutor.java index 8881640d57022..726edc4aee0f6 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/BusyExecutor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/BusyExecutor.java @@ -21,9 +21,9 @@ import java.util.function.Function; import java.util.function.Supplier; import org.apache.ignite.IgniteLogger; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.GridBusyLock; import org.apache.ignite.internal.util.GridConcurrentHashSet; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; /** * Executor with busy run support. diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/IgniteGlobalStatisticsManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/IgniteGlobalStatisticsManager.java index 2c67c172e6164..e1ac526bd6075 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/IgniteGlobalStatisticsManager.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/IgniteGlobalStatisticsManager.java @@ -58,9 +58,9 @@ import org.apache.ignite.internal.processors.query.stat.messages.StatisticsResponse; import org.apache.ignite.internal.processors.query.stat.view.StatisticsColumnConfigurationView; import org.apache.ignite.internal.processors.query.stat.view.StatisticsColumnGlobalDataView; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.IgniteUtils; import org.apache.ignite.internal.util.typedef.F; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; /** * Global statistics manager. Cache global statistics and collect it. diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/IgniteStatisticsConfigurationManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/IgniteStatisticsConfigurationManager.java index 2ad221bea92bd..d689d9996329e 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/IgniteStatisticsConfigurationManager.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/IgniteStatisticsConfigurationManager.java @@ -58,13 +58,13 @@ import org.apache.ignite.internal.processors.query.stat.config.StatisticsObjectConfiguration; import org.apache.ignite.internal.processors.query.stat.view.ColumnConfigurationViewSupplier; import org.apache.ignite.internal.processors.subscription.GridInternalSubscriptionProcessor; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.future.GridCompoundFuture; import org.apache.ignite.internal.util.future.GridFinishedFuture; import org.apache.ignite.internal.util.future.GridFutureAdapter; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.X; import org.apache.ignite.internal.util.typedef.internal.CU; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import org.jetbrains.annotations.NotNull; /** diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/IgniteStatisticsManagerImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/IgniteStatisticsManagerImpl.java index a9bd0df82e3b0..7cb59633fc6b1 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/IgniteStatisticsManagerImpl.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/IgniteStatisticsManagerImpl.java @@ -41,9 +41,9 @@ import org.apache.ignite.internal.processors.query.schema.management.TableDescriptor; import org.apache.ignite.internal.processors.query.stat.config.StatisticsObjectConfiguration; import org.apache.ignite.internal.processors.timeout.GridTimeoutProcessor; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.collection.IntMap; import org.apache.ignite.internal.util.typedef.F; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import static org.apache.ignite.internal.processors.query.stat.StatisticsUsageState.NO_UPDATE; import static org.apache.ignite.internal.processors.query.stat.StatisticsUsageState.OFF; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/StatisticsProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/StatisticsProcessor.java index 10c146cdbd1ab..3f2fc1b9bdd1a 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/StatisticsProcessor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/query/stat/StatisticsProcessor.java @@ -26,13 +26,12 @@ import java.util.concurrent.ConcurrentMap; import java.util.function.Function; import java.util.function.Supplier; - import org.apache.ignite.IgniteLogger; import org.apache.ignite.internal.NodeStoppingException; import org.apache.ignite.internal.processors.query.stat.config.StatisticsColumnConfiguration; import org.apache.ignite.internal.processors.query.stat.config.StatisticsObjectConfiguration; import org.apache.ignite.internal.processors.query.stat.task.GatherPartitionStatistics; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; /** * Process all tasks, related to statistics repository. Mostly - statistics collection, diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/service/IgniteServiceProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/service/IgniteServiceProcessor.java index ee6da263d37ee..bf891bce6ffde 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/service/IgniteServiceProcessor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/service/IgniteServiceProcessor.java @@ -72,6 +72,8 @@ import org.apache.ignite.internal.processors.platform.services.PlatformService; import org.apache.ignite.internal.processors.platform.services.PlatformServiceConfiguration; import org.apache.ignite.internal.processors.security.SecurityContext; +import org.apache.ignite.internal.thread.IgniteThreadFactory; +import org.apache.ignite.internal.thread.OomExceptionHandler; import org.apache.ignite.internal.thread.context.Scope; import org.apache.ignite.internal.util.future.GridCompoundFuture; import org.apache.ignite.internal.util.future.GridFinishedFuture; @@ -97,8 +99,6 @@ import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi; import org.apache.ignite.spi.metric.ReadOnlyMetricRegistry; import org.apache.ignite.spi.systemview.view.ServiceView; -import org.apache.ignite.thread.IgniteThreadFactory; -import org.apache.ignite.thread.OomExceptionHandler; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; diff --git a/modules/core/src/main/java/org/apache/ignite/thread/IgniteStripedThreadPoolExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/IgniteStripedThreadPoolExecutor.java similarity index 99% rename from modules/core/src/main/java/org/apache/ignite/thread/IgniteStripedThreadPoolExecutor.java rename to modules/core/src/main/java/org/apache/ignite/internal/thread/IgniteStripedThreadPoolExecutor.java index 9509e9d87b00b..86332bac992fc 100644 --- a/modules/core/src/main/java/org/apache/ignite/thread/IgniteStripedThreadPoolExecutor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/IgniteStripedThreadPoolExecutor.java @@ -15,7 +15,7 @@ * limitations under the License. */ -package org.apache.ignite.thread; +package org.apache.ignite.internal.thread; import java.lang.Thread.UncaughtExceptionHandler; import java.util.ArrayList; diff --git a/modules/core/src/main/java/org/apache/ignite/thread/IgniteThreadFactory.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/IgniteThreadFactory.java similarity index 97% rename from modules/core/src/main/java/org/apache/ignite/thread/IgniteThreadFactory.java rename to modules/core/src/main/java/org/apache/ignite/internal/thread/IgniteThreadFactory.java index 23bf14df1b685..ee09c0b92c350 100644 --- a/modules/core/src/main/java/org/apache/ignite/thread/IgniteThreadFactory.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/IgniteThreadFactory.java @@ -15,13 +15,14 @@ * limitations under the License. */ -package org.apache.ignite.thread; +package org.apache.ignite.internal.thread; import java.lang.Thread.UncaughtExceptionHandler; import java.util.concurrent.ThreadFactory; import java.util.concurrent.atomic.AtomicInteger; import org.apache.ignite.internal.managers.communication.GridIoPolicy; import org.apache.ignite.internal.util.typedef.internal.S; +import org.apache.ignite.thread.IgniteThread; import org.jetbrains.annotations.NotNull; /** diff --git a/modules/core/src/main/java/org/apache/ignite/thread/IgniteThreadPoolExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/IgniteThreadPoolExecutor.java similarity index 99% rename from modules/core/src/main/java/org/apache/ignite/thread/IgniteThreadPoolExecutor.java rename to modules/core/src/main/java/org/apache/ignite/internal/thread/IgniteThreadPoolExecutor.java index 823076ef6f4e8..ad1b762b2cc37 100644 --- a/modules/core/src/main/java/org/apache/ignite/thread/IgniteThreadPoolExecutor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/IgniteThreadPoolExecutor.java @@ -15,7 +15,7 @@ * limitations under the License. */ -package org.apache.ignite.thread; +package org.apache.ignite.internal.thread; import java.lang.Thread.UncaughtExceptionHandler; import java.util.concurrent.BlockingQueue; diff --git a/modules/core/src/main/java/org/apache/ignite/thread/OomExceptionHandler.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/OomExceptionHandler.java similarity index 97% rename from modules/core/src/main/java/org/apache/ignite/thread/OomExceptionHandler.java rename to modules/core/src/main/java/org/apache/ignite/internal/thread/OomExceptionHandler.java index 3a62ad87e5de9..d8b7454268685 100644 --- a/modules/core/src/main/java/org/apache/ignite/thread/OomExceptionHandler.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/OomExceptionHandler.java @@ -15,7 +15,7 @@ * limitations under the License. */ -package org.apache.ignite.thread; +package org.apache.ignite.internal.thread; import org.apache.ignite.failure.FailureContext; import org.apache.ignite.failure.FailureType; diff --git a/modules/core/src/main/java/org/apache/ignite/thread/SameThreadExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/SameThreadExecutor.java similarity index 96% rename from modules/core/src/main/java/org/apache/ignite/thread/SameThreadExecutor.java rename to modules/core/src/main/java/org/apache/ignite/internal/thread/SameThreadExecutor.java index ff3ca127dca96..f53490965e7a3 100644 --- a/modules/core/src/main/java/org/apache/ignite/thread/SameThreadExecutor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/SameThreadExecutor.java @@ -15,7 +15,7 @@ * limitations under the License. */ -package org.apache.ignite.thread; +package org.apache.ignite.internal.thread; import java.util.concurrent.Executor; import org.jetbrains.annotations.NotNull; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedThreadPoolExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedThreadPoolExecutor.java index 300dc6eb1df6e..253d6745c642e 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedThreadPoolExecutor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedThreadPoolExecutor.java @@ -17,8 +17,8 @@ package org.apache.ignite.internal.thread.context.pool; +import org.apache.ignite.internal.thread.IgniteStripedThreadPoolExecutor; import org.apache.ignite.internal.thread.context.function.ThreadContextAwareRunnable; -import org.apache.ignite.thread.IgniteStripedThreadPoolExecutor; /** */ public class ThreadContextAwareStripedThreadPoolExecutor extends IgniteStripedThreadPoolExecutor { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareThreadPoolExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareThreadPoolExecutor.java index afc6f614678a8..858b1ca2f6e9b 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareThreadPoolExecutor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareThreadPoolExecutor.java @@ -25,9 +25,9 @@ import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.thread.context.function.ThreadContextAwareCallable; import org.apache.ignite.internal.thread.context.function.ThreadContextAwareRunnable; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import org.jetbrains.annotations.NotNull; /** */ diff --git a/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java b/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java index 32e7c4da1adce..c13587dd81baf 100755 --- a/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java @@ -191,6 +191,7 @@ import org.apache.ignite.internal.processors.cache.CacheObjectContext; import org.apache.ignite.internal.processors.cache.GridCacheSharedContext; import org.apache.ignite.internal.processors.cache.IgnitePeerToPeerClassLoadingException; +import org.apache.ignite.internal.thread.IgniteThreadFactory; import org.apache.ignite.internal.transactions.IgniteTxHeuristicCheckedException; import org.apache.ignite.internal.transactions.IgniteTxOptimisticCheckedException; import org.apache.ignite.internal.transactions.IgniteTxRollbackCheckedException; @@ -230,7 +231,6 @@ import org.apache.ignite.spi.discovery.DiscoverySpiOrderSupport; import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi; import org.apache.ignite.thread.IgniteThread; -import org.apache.ignite.thread.IgniteThreadFactory; import org.apache.ignite.transactions.TransactionDeadlockException; import org.apache.ignite.transactions.TransactionHeuristicException; import org.apache.ignite.transactions.TransactionOptimisticException; diff --git a/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/ConnectionClientPool.java b/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/ConnectionClientPool.java index 9ae4b8d3b438b..95896bb30e363 100644 --- a/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/ConnectionClientPool.java +++ b/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/ConnectionClientPool.java @@ -42,6 +42,7 @@ import org.apache.ignite.internal.cluster.ClusterTopologyCheckedException; import org.apache.ignite.internal.processors.metric.GridMetricManager; import org.apache.ignite.internal.processors.metric.MetricRegistryImpl; +import org.apache.ignite.internal.thread.IgniteThreadFactory; import org.apache.ignite.internal.util.GridConcurrentFactory; import org.apache.ignite.internal.util.future.GridFutureAdapter; import org.apache.ignite.internal.util.nio.GridCommunicationClient; @@ -55,7 +56,6 @@ import org.apache.ignite.spi.communication.tcp.TcpCommunicationMetricsListener; import org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi; import org.apache.ignite.spi.discovery.IgniteDiscoveryThread; -import org.apache.ignite.thread.IgniteThreadFactory; import org.jetbrains.annotations.Nullable; import static java.util.Objects.nonNull; diff --git a/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/GridNioServerWrapper.java b/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/GridNioServerWrapper.java index c88a9ba00a88c..6df86fec882fb 100644 --- a/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/GridNioServerWrapper.java +++ b/modules/core/src/main/java/org/apache/ignite/spi/communication/tcp/internal/GridNioServerWrapper.java @@ -56,6 +56,7 @@ import org.apache.ignite.internal.managers.tracing.GridTracingManager; import org.apache.ignite.internal.processors.metric.GridMetricManager; import org.apache.ignite.internal.processors.tracing.Tracing; +import org.apache.ignite.internal.thread.IgniteThreadFactory; import org.apache.ignite.internal.util.GridConcurrentFactory; import org.apache.ignite.internal.util.IgniteExceptionRegistry; import org.apache.ignite.internal.util.function.ThrowableBiFunction; @@ -100,7 +101,6 @@ import org.apache.ignite.spi.communication.tcp.messages.NodeIdMessage; import org.apache.ignite.spi.communication.tcp.messages.RecoveryLastReceivedMessage; import org.apache.ignite.spi.discovery.IgniteDiscoveryThread; -import org.apache.ignite.thread.IgniteThreadFactory; import org.jetbrains.annotations.Nullable; import static java.util.concurrent.Executors.newSingleThreadScheduledExecutor; diff --git a/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ClientImpl.java b/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ClientImpl.java index 643d4d3fb25f1..73b0fc017a505 100644 --- a/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ClientImpl.java +++ b/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ClientImpl.java @@ -75,6 +75,7 @@ import org.apache.ignite.internal.processors.tracing.messages.SpanContainer; import org.apache.ignite.internal.processors.tracing.messages.TraceableMessage; import org.apache.ignite.internal.processors.tracing.messages.TraceableMessagesTable; +import org.apache.ignite.internal.thread.IgniteThreadFactory; import org.apache.ignite.internal.util.future.GridFutureAdapter; import org.apache.ignite.internal.util.tostring.GridToStringExclude; import org.apache.ignite.internal.util.typedef.F; @@ -121,7 +122,6 @@ import org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryPingResponse; import org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryRingLatencyCheckMessage; import org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryServerOnlyCustomEventMessage; -import org.apache.ignite.thread.IgniteThreadFactory; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; diff --git a/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ServerImpl.java b/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ServerImpl.java index 7905a5a8ac02b..9449e4ff9eb3c 100644 --- a/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ServerImpl.java +++ b/modules/core/src/main/java/org/apache/ignite/spi/discovery/tcp/ServerImpl.java @@ -92,6 +92,7 @@ import org.apache.ignite.internal.processors.tracing.messages.SpanContainer; import org.apache.ignite.internal.processors.tracing.messages.TraceableMessage; import org.apache.ignite.internal.processors.tracing.messages.TraceableMessagesTable; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.GridBoundedLinkedHashSet; import org.apache.ignite.internal.util.GridConcurrentHashSet; import org.apache.ignite.internal.util.IgniteUtils; @@ -159,7 +160,6 @@ import org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryServerOnlyCustomEventMessage; import org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryStatusCheckMessage; import org.apache.ignite.spi.tracing.SpanStatus; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import org.jetbrains.annotations.Nullable; import static org.apache.ignite.IgniteSystemProperties.IGNITE_BINARY_MARSHALLER_USE_STRING_SERIALIZATION_VER_2; diff --git a/modules/core/src/main/java/org/apache/ignite/thread/package-info.java b/modules/core/src/main/java/org/apache/ignite/thread/package-info.java deleted file mode 100644 index e602abe206bd4..0000000000000 --- a/modules/core/src/main/java/org/apache/ignite/thread/package-info.java +++ /dev/null @@ -1,23 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/** - * - * Contains threads-related utility classes. - */ - -package org.apache.ignite.thread; diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridTransactionsSystemUserTimeMetricsTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridTransactionsSystemUserTimeMetricsTest.java index 495e926e75fec..d288d1b73f2e0 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridTransactionsSystemUserTimeMetricsTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridTransactionsSystemUserTimeMetricsTest.java @@ -43,6 +43,7 @@ import org.apache.ignite.internal.processors.cache.distributed.near.GridNearLockRequest; import org.apache.ignite.internal.processors.cache.distributed.near.GridNearTxPrepareRequest; import org.apache.ignite.internal.processors.cache.transactions.IgniteTxAdapter; +import org.apache.ignite.internal.thread.IgniteThreadFactory; import org.apache.ignite.lang.IgniteInClosure; import org.apache.ignite.mxbean.TransactionsMXBean; import org.apache.ignite.plugin.extensions.communication.Message; @@ -54,7 +55,6 @@ import org.apache.ignite.testframework.MessageOrderLogListener; import org.apache.ignite.testframework.junits.WithSystemProperty; import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; -import org.apache.ignite.thread.IgniteThreadFactory; import org.apache.ignite.transactions.Transaction; import org.junit.Test; diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CacheExchangeMergeTest.java b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CacheExchangeMergeTest.java index 1eaf377918fbc..8b5c4b92ee827 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CacheExchangeMergeTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/distributed/CacheExchangeMergeTest.java @@ -65,6 +65,7 @@ import org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsExchangeFuture; import org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsFullMessage; import org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsSingleRequest; +import org.apache.ignite.internal.thread.IgniteThreadFactory; import org.apache.ignite.internal.util.GridConcurrentHashSet; import org.apache.ignite.internal.util.future.GridCompoundFuture; import org.apache.ignite.internal.util.typedef.F; @@ -78,7 +79,6 @@ import org.apache.ignite.testframework.ListeningTestLogger; import org.apache.ignite.testframework.LogListener; import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; -import org.apache.ignite.thread.IgniteThreadFactory; import org.apache.ignite.transactions.Transaction; import org.apache.ignite.transactions.TransactionConcurrency; import org.apache.ignite.transactions.TransactionIsolation; diff --git a/modules/core/src/test/java/org/apache/ignite/thread/GridThreadPoolExecutorServiceSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/thread/GridThreadPoolExecutorServiceSelfTest.java similarity index 99% rename from modules/core/src/test/java/org/apache/ignite/thread/GridThreadPoolExecutorServiceSelfTest.java rename to modules/core/src/test/java/org/apache/ignite/internal/thread/GridThreadPoolExecutorServiceSelfTest.java index d9a59f5e0bcaa..77379a7fad346 100644 --- a/modules/core/src/test/java/org/apache/ignite/thread/GridThreadPoolExecutorServiceSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/thread/GridThreadPoolExecutorServiceSelfTest.java @@ -15,7 +15,7 @@ * limitations under the License. */ -package org.apache.ignite.thread; +package org.apache.ignite.internal.thread; import java.util.concurrent.Callable; import java.util.concurrent.CountDownLatch; diff --git a/modules/core/src/test/java/org/apache/ignite/thread/GridThreadTest.java b/modules/core/src/test/java/org/apache/ignite/internal/thread/GridThreadTest.java similarity index 95% rename from modules/core/src/test/java/org/apache/ignite/thread/GridThreadTest.java rename to modules/core/src/test/java/org/apache/ignite/internal/thread/GridThreadTest.java index 8903c3fa70310..e7bde81a11640 100644 --- a/modules/core/src/test/java/org/apache/ignite/thread/GridThreadTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/thread/GridThreadTest.java @@ -15,12 +15,13 @@ * limitations under the License. */ -package org.apache.ignite.thread; +package org.apache.ignite.internal.thread; import java.util.ArrayList; import java.util.Collection; import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; import org.apache.ignite.testframework.junits.common.GridCommonTest; +import org.apache.ignite.thread.IgniteThread; import org.junit.Test; /** diff --git a/modules/core/src/test/java/org/apache/ignite/thread/IgniteThreadPoolSizeTest.java b/modules/core/src/test/java/org/apache/ignite/internal/thread/IgniteThreadPoolSizeTest.java similarity index 98% rename from modules/core/src/test/java/org/apache/ignite/thread/IgniteThreadPoolSizeTest.java rename to modules/core/src/test/java/org/apache/ignite/internal/thread/IgniteThreadPoolSizeTest.java index 21b0fa740ad46..77931326c28af 100644 --- a/modules/core/src/test/java/org/apache/ignite/thread/IgniteThreadPoolSizeTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/thread/IgniteThreadPoolSizeTest.java @@ -15,7 +15,7 @@ * limitations under the License. */ -package org.apache.ignite.thread; +package org.apache.ignite.internal.thread; import org.apache.ignite.IgniteCheckedException; import org.apache.ignite.IgniteException; diff --git a/modules/core/src/test/java/org/apache/ignite/thread/ThreadPoolMetricsTest.java b/modules/core/src/test/java/org/apache/ignite/internal/thread/ThreadPoolMetricsTest.java similarity index 99% rename from modules/core/src/test/java/org/apache/ignite/thread/ThreadPoolMetricsTest.java rename to modules/core/src/test/java/org/apache/ignite/internal/thread/ThreadPoolMetricsTest.java index dc955ae3a951e..fa49967b6350a 100644 --- a/modules/core/src/test/java/org/apache/ignite/thread/ThreadPoolMetricsTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/thread/ThreadPoolMetricsTest.java @@ -15,7 +15,7 @@ * limitations under the License. */ -package org.apache.ignite.thread; +package org.apache.ignite.internal.thread; import java.util.ArrayList; import java.util.Arrays; diff --git a/modules/core/src/test/java/org/apache/ignite/internal/util/IgniteUtilsSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/util/IgniteUtilsSelfTest.java index 406f9321f006f..19f6ad17c38d8 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/util/IgniteUtilsSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/util/IgniteUtilsSelfTest.java @@ -68,6 +68,7 @@ import org.apache.ignite.compute.ComputeJob; import org.apache.ignite.compute.ComputeJobAdapter; import org.apache.ignite.internal.IgniteInterruptedCheckedException; +import org.apache.ignite.internal.thread.IgniteThreadFactory; import org.apache.ignite.internal.util.future.GridFutureAdapter; import org.apache.ignite.internal.util.lang.ConsumerX; import org.apache.ignite.internal.util.lang.GridPeerDeployAware; @@ -84,7 +85,6 @@ import org.apache.ignite.testframework.junits.WithSystemProperty; import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; import org.apache.ignite.testframework.junits.common.GridCommonTest; -import org.apache.ignite.thread.IgniteThreadFactory; import org.jetbrains.annotations.Nullable; import org.junit.Assert; import org.junit.Test; diff --git a/modules/core/src/test/java/org/apache/ignite/internal/util/future/GridFutureAdapterSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/util/future/GridFutureAdapterSelfTest.java index cbafbfddbd9a5..b2eaaf07aeb58 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/util/future/GridFutureAdapterSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/util/future/GridFutureAdapterSelfTest.java @@ -32,12 +32,12 @@ import org.apache.ignite.internal.processors.closure.GridClosureProcessor; import org.apache.ignite.internal.processors.pool.PoolProcessor; import org.apache.ignite.internal.processors.security.NoOpIgniteSecurityProcessor; +import org.apache.ignite.internal.thread.IgniteThreadFactory; import org.apache.ignite.internal.util.typedef.CI1; import org.apache.ignite.internal.util.typedef.CX1; import org.apache.ignite.lang.IgniteClosure; import org.apache.ignite.testframework.junits.GridTestKernalContext; import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; -import org.apache.ignite.thread.IgniteThreadFactory; import org.junit.Test; import static org.apache.ignite.testframework.GridTestUtils.assertThrows; diff --git a/modules/core/src/test/java/org/apache/ignite/marshaller/GridMarshallerResourceBean.java b/modules/core/src/test/java/org/apache/ignite/marshaller/GridMarshallerResourceBean.java index 20d01aeaa33eb..6becc86396293 100644 --- a/modules/core/src/test/java/org/apache/ignite/marshaller/GridMarshallerResourceBean.java +++ b/modules/core/src/test/java/org/apache/ignite/marshaller/GridMarshallerResourceBean.java @@ -32,8 +32,8 @@ import org.apache.ignite.compute.ComputeLoadBalancer; import org.apache.ignite.compute.ComputeTaskSession; import org.apache.ignite.internal.managers.loadbalancer.GridLoadBalancerAdapter; +import org.apache.ignite.internal.thread.IgniteThreadFactory; import org.apache.ignite.logger.java.JavaLogger; -import org.apache.ignite.thread.IgniteThreadFactory; import org.springframework.context.ApplicationContext; import org.springframework.context.support.GenericApplicationContext; diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/IgniteTestResources.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/IgniteTestResources.java index ea9585dcc23f8..bef3aa0c27c63 100644 --- a/modules/core/src/test/java/org/apache/ignite/testframework/junits/IgniteTestResources.java +++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/IgniteTestResources.java @@ -30,13 +30,13 @@ import org.apache.ignite.internal.SensitiveInfoTestLoggerProxy; import org.apache.ignite.internal.binary.BinaryMarshaller; import org.apache.ignite.internal.processors.resource.GridResourceProcessor; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.marshaller.Marshaller; import org.apache.ignite.marshaller.MarshallerContextTestImpl; import org.apache.ignite.resources.IgniteInstanceResource; import org.apache.ignite.resources.LoggerResource; import org.apache.ignite.testframework.junits.logger.GridTestLog4jLogger; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import org.jetbrains.annotations.Nullable; /** diff --git a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteUtilSelfTestSuite.java b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteUtilSelfTestSuite.java index abacbcaa46ccb..9984d7c5067f9 100644 --- a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteUtilSelfTestSuite.java +++ b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteUtilSelfTestSuite.java @@ -20,6 +20,10 @@ import org.apache.ignite.internal.IgniteVersionUtilsSelfTest; import org.apache.ignite.internal.management.api.CommandUtilsSelfTest; import org.apache.ignite.internal.pagemem.impl.PageIdUtilsSelfTest; +import org.apache.ignite.internal.thread.GridThreadPoolExecutorServiceSelfTest; +import org.apache.ignite.internal.thread.GridThreadTest; +import org.apache.ignite.internal.thread.IgniteThreadPoolSizeTest; +import org.apache.ignite.internal.thread.ThreadPoolMetricsTest; import org.apache.ignite.internal.util.BasicRateLimiterTest; import org.apache.ignite.internal.util.DistributedProcessClientAwaitTest; import org.apache.ignite.internal.util.DistributedProcessCoordinatorLeftTest; @@ -52,10 +56,6 @@ import org.apache.ignite.spi.discovery.ClusterMetricsSnapshotSerializeCompatibilityTest; import org.apache.ignite.spi.discovery.ClusterMetricsSnapshotSerializeSelfTest; import org.apache.ignite.spi.discovery.ClusterRebalancedMetricTest; -import org.apache.ignite.thread.GridThreadPoolExecutorServiceSelfTest; -import org.apache.ignite.thread.GridThreadTest; -import org.apache.ignite.thread.IgniteThreadPoolSizeTest; -import org.apache.ignite.thread.ThreadPoolMetricsTest; import org.apache.ignite.util.GridConcurrentLinkedDequeMultiThreadedTest; import org.apache.ignite.util.GridIntListSelfTest; import org.apache.ignite.util.GridLogThrottleTest; diff --git a/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/stat/BusyExecutorTest.java b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/stat/BusyExecutorTest.java index e4c25c7e8055a..e95b93702ec3b 100644 --- a/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/stat/BusyExecutorTest.java +++ b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/stat/BusyExecutorTest.java @@ -26,10 +26,10 @@ import org.apache.ignite.configuration.IgniteConfiguration; import org.apache.ignite.internal.IgniteInternalFuture; import org.apache.ignite.internal.managers.communication.GridIoPolicy; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.GridConcurrentHashSet; import org.apache.ignite.testframework.GridTestUtils; import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import org.junit.After; import org.junit.Before; import org.junit.Test; diff --git a/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/stat/StatisticsAbstractTest.java b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/stat/StatisticsAbstractTest.java index a631e99723730..6eb7c9137ff0d 100644 --- a/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/stat/StatisticsAbstractTest.java +++ b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/query/stat/StatisticsAbstractTest.java @@ -46,12 +46,12 @@ import org.apache.ignite.internal.processors.query.GridQueryProcessor; import org.apache.ignite.internal.processors.query.stat.config.StatisticsColumnConfiguration; import org.apache.ignite.internal.processors.query.stat.config.StatisticsObjectConfiguration; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.G; import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.testframework.GridTestUtils; import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import org.jetbrains.annotations.NotNull; import static org.apache.ignite.internal.processors.query.stat.IgniteStatisticsHelper.buildDefaultConfigurations; diff --git a/modules/zookeeper/src/main/java/org/apache/ignite/spi/discovery/zk/internal/ZookeeperDiscoveryImpl.java b/modules/zookeeper/src/main/java/org/apache/ignite/spi/discovery/zk/internal/ZookeeperDiscoveryImpl.java index 37039dd028b32..029ce1ef97cce 100644 --- a/modules/zookeeper/src/main/java/org/apache/ignite/spi/discovery/zk/internal/ZookeeperDiscoveryImpl.java +++ b/modules/zookeeper/src/main/java/org/apache/ignite/spi/discovery/zk/internal/ZookeeperDiscoveryImpl.java @@ -63,6 +63,7 @@ import org.apache.ignite.internal.cluster.ClusterTopologyCheckedException; import org.apache.ignite.internal.events.DiscoveryCustomEvent; import org.apache.ignite.internal.processors.security.SecurityContext; +import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.GridLongList; import org.apache.ignite.internal.util.GridSpinBusyLock; import org.apache.ignite.internal.util.IgniteUtils; @@ -87,7 +88,6 @@ import org.apache.ignite.spi.discovery.DiscoverySpiListener; import org.apache.ignite.spi.discovery.DiscoverySpiNodeAuthenticator; import org.apache.ignite.spi.discovery.zk.ZookeeperDiscoverySpi; -import org.apache.ignite.thread.IgniteThreadPoolExecutor; import org.apache.zookeeper.AsyncCallback; import org.apache.zookeeper.CreateMode; import org.apache.zookeeper.KeeperException; From a267f94d6866551cd07db1808917efe02257ab23 Mon Sep 17 00:00:00 2001 From: Mikhail Petrov Date: Tue, 21 Oct 2025 11:52:02 +0300 Subject: [PATCH 3/5] IGNITE-26788 --- .../ignite/util/SystemViewCommandTest.java | 4 +- .../apache/ignite/IgniteSystemProperties.java | 2 +- .../apache/ignite/internal/IgniteKernal.java | 6 +-- .../plugin/IgniteLogInfoProviderImpl.java | 6 +-- .../persistence/CacheStripedExecutor.java | 12 +++--- .../GridCacheDatabaseSharedManager.java | 4 +- .../checkpoint/CheckpointManager.java | 4 +- .../checkpoint/CheckpointWorkflow.java | 6 +-- .../persistence/checkpoint/Checkpointer.java | 4 +- .../LightweightCheckpointManager.java | 4 +- .../processors/pool/PoolProcessor.java | 40 +++++++++++-------- .../IgniteStripedExecutor.java} | 11 ++--- .../ThreadContextAwareStripedExecutor.java | 4 +- .../view/StripedExecutorTaskView.java | 6 +-- .../internal/metric/JmxExporterSpiTest.java | 4 +- .../internal/metric/SystemViewSelfTest.java | 4 +- .../IgniteStripedExecutorTest.java} | 8 ++-- .../thread/ThreadPoolMetricsTest.java | 3 +- .../IgniteComputeGridTestSuite.java | 4 +- .../cache/metric/SqlViewExporterSpiTest.java | 4 +- 20 files changed, 74 insertions(+), 66 deletions(-) rename modules/core/src/main/java/org/apache/ignite/internal/{util/StripedExecutor.java => thread/IgniteStripedExecutor.java} (98%) rename modules/core/src/test/java/org/apache/ignite/internal/{util/StripedExecutorTest.java => thread/IgniteStripedExecutorTest.java} (95%) diff --git a/modules/control-utility/src/test/java/org/apache/ignite/util/SystemViewCommandTest.java b/modules/control-utility/src/test/java/org/apache/ignite/util/SystemViewCommandTest.java index 8f980bc9c4af1..1062d832de30b 100644 --- a/modules/control-utility/src/test/java/org/apache/ignite/util/SystemViewCommandTest.java +++ b/modules/control-utility/src/test/java/org/apache/ignite/util/SystemViewCommandTest.java @@ -71,7 +71,7 @@ import org.apache.ignite.internal.processors.cache.persistence.IgniteCacheDatabaseSharedManager; import org.apache.ignite.internal.processors.metastorage.DistributedMetaStorage; import org.apache.ignite.internal.processors.service.DummyService; -import org.apache.ignite.internal.util.StripedExecutor; +import org.apache.ignite.internal.thread.IgniteStripedExecutor; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.G; import org.apache.ignite.internal.util.typedef.internal.U; @@ -833,7 +833,7 @@ public void testStreamerExecutor() throws Exception { * @param view System view name. * @param poolName Executor name. */ - private void checkStripeExecutorView(StripedExecutor execSvc, String view, String poolName) throws Exception { + private void checkStripeExecutorView(IgniteStripedExecutor execSvc, String view, String poolName) throws Exception { CountDownLatch latch = new CountDownLatch(1); execSvc.execute(0, new TestRunnable(latch, 0)); diff --git a/modules/core/src/main/java/org/apache/ignite/IgniteSystemProperties.java b/modules/core/src/main/java/org/apache/ignite/IgniteSystemProperties.java index e0d75bafded1a..3fbea5a452293 100644 --- a/modules/core/src/main/java/org/apache/ignite/IgniteSystemProperties.java +++ b/modules/core/src/main/java/org/apache/ignite/IgniteSystemProperties.java @@ -130,10 +130,10 @@ import static org.apache.ignite.internal.processors.rest.GridRestProcessor.DFLT_SES_TIMEOUT; import static org.apache.ignite.internal.processors.rest.GridRestProcessor.DFLT_SES_TOKEN_INVALIDATE_INTERVAL; import static org.apache.ignite.internal.processors.rest.handlers.task.GridTaskCommandHandler.DFLT_MAX_TASK_RESULTS; +import static org.apache.ignite.internal.thread.IgniteStripedExecutor.DFLT_DATA_STREAMING_EXECUTOR_SERVICE_TASKS_STEALING_THRESHOLD; import static org.apache.ignite.internal.util.GridReflectionCache.DFLT_REFLECTION_CACHE_SIZE; import static org.apache.ignite.internal.util.IgniteExceptionRegistry.DEFAULT_QUEUE_SIZE; import static org.apache.ignite.internal.util.IgniteUtils.DFLT_MBEAN_APPEND_CLASS_LOADER_ID; -import static org.apache.ignite.internal.util.StripedExecutor.DFLT_DATA_STREAMING_EXECUTOR_SERVICE_TASKS_STEALING_THRESHOLD; import static org.apache.ignite.internal.util.nio.GridNioRecoveryDescriptor.DFLT_NIO_RECOVERY_DESCRIPTOR_RESERVATION_TIMEOUT; import static org.apache.ignite.internal.util.nio.GridNioServer.DFLT_IO_BALANCE_PERIOD; import static org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi.DFLT_DISCOVERY_CLIENT_RECONNECT_HISTORY_SIZE; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java b/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java index a3e0ac10b61ec..a342a78095ed4 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java @@ -173,7 +173,7 @@ import org.apache.ignite.internal.suggestions.GridPerformanceSuggestions; import org.apache.ignite.internal.suggestions.JvmConfigurationSuggestions; import org.apache.ignite.internal.suggestions.OsConfigurationSuggestions; -import org.apache.ignite.internal.util.StripedExecutor; +import org.apache.ignite.internal.thread.IgniteStripedExecutor; import org.apache.ignite.internal.util.TimeBag; import org.apache.ignite.internal.util.future.GridCompoundFuture; import org.apache.ignite.internal.util.future.GridFinishedFuture; @@ -1335,8 +1335,8 @@ private String createExecutorDescription(String execSvcName, ExecutorService exe poolActiveThreads = Math.min(poolSize, exec.getActiveCount()); poolQSize = exec.getQueue().size(); } - else if (execSvc instanceof StripedExecutor) { - StripedExecutor exec = (StripedExecutor)execSvc; + else if (execSvc instanceof IgniteStripedExecutor) { + IgniteStripedExecutor exec = (IgniteStripedExecutor)execSvc; poolSize = exec.stripesCount(); poolActiveThreads = exec.activeStripesCount(); diff --git a/modules/core/src/main/java/org/apache/ignite/internal/plugin/IgniteLogInfoProviderImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/plugin/IgniteLogInfoProviderImpl.java index 5eb870e2e8bff..a7637037055b7 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/plugin/IgniteLogInfoProviderImpl.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/plugin/IgniteLogInfoProviderImpl.java @@ -56,7 +56,7 @@ import org.apache.ignite.internal.processors.cache.persistence.DataRegion; import org.apache.ignite.internal.processors.cache.persistence.IgniteCacheDatabaseSharedManager; import org.apache.ignite.internal.processors.port.GridPortRecord; -import org.apache.ignite.internal.util.StripedExecutor; +import org.apache.ignite.internal.thread.IgniteStripedExecutor; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.internal.CU; import org.apache.ignite.internal.util.typedef.internal.S; @@ -785,8 +785,8 @@ String createExecutorDescription(String execSvcName, ExecutorService execSvc) { poolActiveThreads = Math.min(poolSize, exec.getActiveCount()); poolQSize = exec.getQueue().size(); } - else if (execSvc instanceof StripedExecutor) { - StripedExecutor exec = (StripedExecutor)execSvc; + else if (execSvc instanceof IgniteStripedExecutor) { + IgniteStripedExecutor exec = (IgniteStripedExecutor)execSvc; poolSize = exec.stripesCount(); poolActiveThreads = exec.activeStripesCount(); diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/CacheStripedExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/CacheStripedExecutor.java index e735fc0fe72a0..68eb6ff41d845 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/CacheStripedExecutor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/CacheStripedExecutor.java @@ -21,26 +21,26 @@ import java.util.concurrent.atomic.AtomicReference; import org.apache.ignite.IgniteCheckedException; import org.apache.ignite.IgniteInterruptedException; -import org.apache.ignite.internal.util.StripedExecutor; +import org.apache.ignite.internal.thread.IgniteStripedExecutor; import org.apache.ignite.internal.util.typedef.internal.U; import static org.apache.ignite.IgniteSystemProperties.IGNITE_RECOVERY_SEMAPHORE_PERMITS; import static org.apache.ignite.IgniteSystemProperties.getInteger; import static org.apache.ignite.internal.processors.cache.persistence.checkpoint.CheckpointReadWriteLock.CHECKPOINT_LOCK_HOLD_COUNT; -/** Wrapper over {@link StripedExecutor}, that groups submitted tasks by cache group and partition. */ +/** Wrapper over {@link IgniteStripedExecutor}, that groups submitted tasks by cache group and partition. */ public class CacheStripedExecutor { /** Error appeared during submitted task execution. */ private final AtomicReference error = new AtomicReference<>(); /** Delegate striped executor. */ - private final StripedExecutor exec; + private final IgniteStripedExecutor exec; /** Limit number of concurrent tasks submitted to the executor. Helps to avoid OOM error. */ private final Semaphore semaphore; /** */ - public CacheStripedExecutor(StripedExecutor exec) { + public CacheStripedExecutor(IgniteStripedExecutor exec) { this.exec = exec; semaphore = new Semaphore(semaphorePermits(exec)); @@ -117,7 +117,7 @@ public void onError(IgniteCheckedException e) { } /** @return Underlying striped executor. */ - public StripedExecutor executor() { + public IgniteStripedExecutor executor() { return exec; } @@ -127,7 +127,7 @@ public StripedExecutor executor() { * @param exec Striped executor. * @return Number of permits. */ - private int semaphorePermits(StripedExecutor exec) { + private int semaphorePermits(IgniteStripedExecutor exec) { // 4 task per-stripe by default. int permits = exec.stripesCount() * 4; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheDatabaseSharedManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheDatabaseSharedManager.java index f3cf2b9ab261d..f80d9c2c2f9a8 100755 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheDatabaseSharedManager.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/GridCacheDatabaseSharedManager.java @@ -137,10 +137,10 @@ import org.apache.ignite.internal.processors.configuration.distributed.SimpleDistributedProperty; import org.apache.ignite.internal.processors.port.GridPortRecord; import org.apache.ignite.internal.processors.query.GridQueryProcessor; +import org.apache.ignite.internal.thread.IgniteStripedExecutor; import org.apache.ignite.internal.util.GridConcurrentHashSet; import org.apache.ignite.internal.util.GridCountDownCallback; import org.apache.ignite.internal.util.IgniteUtils; -import org.apache.ignite.internal.util.StripedExecutor; import org.apache.ignite.internal.util.TimeBag; import org.apache.ignite.internal.util.future.CountDownFuture; import org.apache.ignite.internal.util.future.GridFutureAdapter; @@ -2911,7 +2911,7 @@ private void finalizeCheckpointOnRecovery( long cpTs, UUID cpId, WALPointer walPtr, - StripedExecutor exec + IgniteStripedExecutor exec ) throws IgniteCheckedException { assert checkpointManager != null : "Checkpoint is null"; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointManager.java index 11273a6d00220..2d2cec18a2edd 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointManager.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointManager.java @@ -44,7 +44,7 @@ import org.apache.ignite.internal.processors.cache.persistence.pagemem.PageMemoryImpl; import org.apache.ignite.internal.processors.cache.persistence.wal.WALPointer; import org.apache.ignite.internal.processors.failure.FailureProcessor; -import org.apache.ignite.internal.util.StripedExecutor; +import org.apache.ignite.internal.thread.IgniteStripedExecutor; import org.apache.ignite.internal.util.lang.IgniteThrowableBiPredicate; import org.apache.ignite.internal.util.lang.IgniteThrowableFunction; import org.apache.ignite.internal.worker.WorkersRegistry; @@ -381,7 +381,7 @@ public void finalizeCheckpointOnRecovery( long ts, UUID id, WALPointer ptr, - StripedExecutor exec + IgniteStripedExecutor exec ) throws IgniteCheckedException { assert checkpointer != null : "Checkpointer hasn't initialized yet"; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointWorkflow.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointWorkflow.java index 9fb267fb26afb..4ebc3b5fc8fa5 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointWorkflow.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/CheckpointWorkflow.java @@ -62,11 +62,11 @@ import org.apache.ignite.internal.processors.cache.persistence.pagemem.PageMemoryEx; import org.apache.ignite.internal.processors.cache.persistence.partstate.PartitionAllocationMap; import org.apache.ignite.internal.processors.cache.persistence.wal.WALPointer; +import org.apache.ignite.internal.thread.IgniteStripedExecutor; import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.GridConcurrentHashSet; import org.apache.ignite.internal.util.GridConcurrentMultiPairQueue; import org.apache.ignite.internal.util.GridMultiCollectionWrapper; -import org.apache.ignite.internal.util.StripedExecutor; import org.apache.ignite.internal.util.function.ThrowableSupplier; import org.apache.ignite.internal.util.future.GridCompoundFuture; import org.apache.ignite.internal.util.future.GridFutureAdapter; @@ -619,7 +619,7 @@ public void finalizeCheckpointOnRecovery( long cpTs, UUID cpId, WALPointer walPtr, - StripedExecutor exec, + IgniteStripedExecutor exec, CheckpointPagesWriterFactory checkpointPagesWriterFactory ) throws IgniteCheckedException { assert cpTs != 0; @@ -682,7 +682,7 @@ public void finalizeCheckpointOnRecovery( * @param applyError Check error reference. */ private void awaitApplyComplete( - StripedExecutor exec, + IgniteStripedExecutor exec, AtomicReference applyError ) throws IgniteCheckedException { try { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/Checkpointer.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/Checkpointer.java index 523ca94c96e79..f22d60f015e13 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/Checkpointer.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/Checkpointer.java @@ -56,9 +56,9 @@ import org.apache.ignite.internal.processors.cache.persistence.wal.WALPointer; import org.apache.ignite.internal.processors.failure.FailureProcessor; import org.apache.ignite.internal.processors.performancestatistics.PerformanceStatisticsProcessor; +import org.apache.ignite.internal.thread.IgniteStripedExecutor; import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.util.GridConcurrentMultiPairQueue; -import org.apache.ignite.internal.util.StripedExecutor; import org.apache.ignite.internal.util.future.CountDownFuture; import org.apache.ignite.internal.util.future.GridFutureAdapter; import org.apache.ignite.internal.util.typedef.internal.LT; @@ -1085,7 +1085,7 @@ public void finalizeCheckpointOnRecovery( long cpTs, UUID cpId, WALPointer walPtr, - StripedExecutor exec + IgniteStripedExecutor exec ) throws IgniteCheckedException { checkpointWorkflow.finalizeCheckpointOnRecovery(cpTs, cpId, walPtr, exec, checkpointPagesWriterFactory); } diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/LightweightCheckpointManager.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/LightweightCheckpointManager.java index 6f427b716c64c..15c2196185296 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/LightweightCheckpointManager.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/persistence/checkpoint/LightweightCheckpointManager.java @@ -38,7 +38,7 @@ import org.apache.ignite.internal.processors.cache.persistence.pagemem.PageMemoryImpl; import org.apache.ignite.internal.processors.cache.persistence.wal.WALPointer; import org.apache.ignite.internal.processors.failure.FailureProcessor; -import org.apache.ignite.internal.util.StripedExecutor; +import org.apache.ignite.internal.thread.IgniteStripedExecutor; import org.apache.ignite.internal.util.lang.IgniteThrowableFunction; import org.apache.ignite.internal.worker.WorkersRegistry; import org.apache.ignite.lang.IgniteInClosure; @@ -267,7 +267,7 @@ public void finalizeCheckpointOnRecovery( long ts, UUID id, WALPointer ptr, - StripedExecutor exec + IgniteStripedExecutor exec ) throws IgniteCheckedException { assert checkpointer != null : "Checkpointer hasn't initialized yet"; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java b/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java index 01b612b06dbb9..481087d405765 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/pool/PoolProcessor.java @@ -45,6 +45,7 @@ import org.apache.ignite.internal.processors.plugin.IgnitePluginProcessor; import org.apache.ignite.internal.processors.security.IgniteSecurity; import org.apache.ignite.internal.processors.timeout.GridTimeoutProcessor; +import org.apache.ignite.internal.thread.IgniteStripedExecutor; import org.apache.ignite.internal.thread.IgniteStripedThreadPoolExecutor; import org.apache.ignite.internal.thread.IgniteThreadPoolExecutor; import org.apache.ignite.internal.thread.SameThreadExecutor; @@ -52,7 +53,6 @@ import org.apache.ignite.internal.thread.context.pool.ThreadContextAwareStripedExecutor; import org.apache.ignite.internal.thread.context.pool.ThreadContextAwareStripedThreadPoolExecutor; import org.apache.ignite.internal.thread.context.pool.ThreadContextAwareThreadPoolExecutor; -import org.apache.ignite.internal.util.StripedExecutor; import org.apache.ignite.internal.util.tostring.GridToStringExclude; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.internal.CU; @@ -125,16 +125,16 @@ public class PoolProcessor extends GridProcessorAdapter { /** Task execution time metric description. */ public static final String TASK_EXEC_TIME_DESC = "Tasks execution times as histogram (milliseconds)."; - /** Name of the system view for a data streamer {@link StripedExecutor} queue view. */ + /** Name of the system view for a data streamer {@link IgniteStripedExecutor} queue view. */ public static final String STREAM_POOL_QUEUE_VIEW = metricName("datastream", "threadpool", "queue"); - /** Description of the system view for a data streamer {@link StripedExecutor} queue view. */ + /** Description of the system view for a data streamer {@link IgniteStripedExecutor} queue view. */ public static final String STREAM_POOL_QUEUE_VIEW_DESC = "Datastream thread pool task queue"; - /** Name of the system view for a system {@link StripedExecutor} queue view. */ + /** Name of the system view for a system {@link IgniteStripedExecutor} queue view. */ public static final String SYS_POOL_QUEUE_VIEW = metricName("striped", "threadpool", "queue"); - /** Description of the system view for a system {@link StripedExecutor} queue view. */ + /** Description of the system view for a system {@link IgniteStripedExecutor} queue view. */ public static final String SYS_POOL_QUEUE_VIEW_DESC = "Striped thread pool task queue"; /** Group for a thread pools. */ @@ -165,7 +165,7 @@ public class PoolProcessor extends GridProcessorAdapter { /** */ @GridToStringExclude - private StripedExecutor stripedExecSvc; + private IgniteStripedExecutor stripedExecSvc; /** Management executor service. */ @GridToStringExclude @@ -177,7 +177,7 @@ public class PoolProcessor extends GridProcessorAdapter { /** Data streamer executor service. */ @GridToStringExclude - private StripedExecutor dataStreamerExecSvc; + private IgniteStripedExecutor dataStreamerExecSvc; /** REST requests executor service. */ @GridToStringExclude @@ -661,13 +661,13 @@ public void registerMetrics() { ctx.systemView().registerInnerCollectionView(SYS_POOL_QUEUE_VIEW, SYS_POOL_QUEUE_VIEW_DESC, new StripedExecutorTaskViewWalker(), Arrays.asList(stripedExecSvc.stripes()), - StripedExecutor.Stripe::queue, + IgniteStripedExecutor.Stripe::queue, StripedExecutorTaskView::new); ctx.systemView().registerInnerCollectionView(STREAM_POOL_QUEUE_VIEW, STREAM_POOL_QUEUE_VIEW_DESC, new StripedExecutorTaskViewWalker(), Arrays.asList(dataStreamerExecSvc.stripes()), - StripedExecutor.Stripe::queue, + IgniteStripedExecutor.Stripe::queue, StripedExecutorTaskView::new); } @@ -709,8 +709,8 @@ public void registerMetrics() { checkPoolStarvation(name, exec0.completedTaskCount(), exec0.poolSize(), exec0.activeCount(), exec0.queueEmpty()); } - else if (exec instanceof StripedExecutor) - ((StripedExecutor)exec).detectStarvation(); + else if (exec instanceof IgniteStripedExecutor) + ((IgniteStripedExecutor)exec).detectStarvation(); } } @@ -890,7 +890,7 @@ public ExecutorService getSystemExecutorService() { * * @return Thread pool implementation to be used in grid for internal system messages. */ - public StripedExecutor getStripedExecutorService() { + public IgniteStripedExecutor getStripedExecutorService() { return stripedExecSvc; } @@ -918,7 +918,7 @@ public ExecutorService getPeerClassLoadingExecutorService() { * * @return Thread pool implementation to be used for data stream messages. */ - public StripedExecutor getDataStreamerExecutorService() { + public IgniteStripedExecutor getDataStreamerExecutorService() { return dataStreamerExecSvc; } @@ -1232,8 +1232,8 @@ private IgniteStripedThreadPoolExecutor createStripedThreadPoolExecutor( keepAliveTime); } - /** Creates instance {@link StripedExecutor} with a notion of whether {@link IgniteSecurity} is enabled. */ - private StripedExecutor createStripedExecutor( + /** Creates instance {@link IgniteStripedExecutor} with a notion of whether {@link IgniteSecurity} is enabled. */ + private IgniteStripedExecutor createStripedExecutor( int cnt, String igniteInstanceName, String poolName, @@ -1253,7 +1253,15 @@ private StripedExecutor createStripedExecutor( stealTasks, gridWorkerLsnr, failureDetectionTimeout) - : new StripedExecutor(cnt, igniteInstanceName, poolName, log, errHnd, stealTasks, gridWorkerLsnr, failureDetectionTimeout); + : new IgniteStripedExecutor( + cnt, + igniteInstanceName, + poolName, + log, + errHnd, + stealTasks, + gridWorkerLsnr, + failureDetectionTimeout); } /** Creates instance {@link IgniteThreadPoolExecutor} with a notion of whether {@link IgniteSecurity} is enabled. */ diff --git a/modules/core/src/main/java/org/apache/ignite/internal/util/StripedExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/IgniteStripedExecutor.java similarity index 98% rename from modules/core/src/main/java/org/apache/ignite/internal/util/StripedExecutor.java rename to modules/core/src/main/java/org/apache/ignite/internal/thread/IgniteStripedExecutor.java index 20ab0de292bc9..46ef9ff4ee068 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/util/StripedExecutor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/IgniteStripedExecutor.java @@ -15,7 +15,7 @@ * limitations under the License. */ -package org.apache.ignite.internal.util; +package org.apache.ignite.internal.thread; import java.util.Arrays; import java.util.Collection; @@ -40,6 +40,7 @@ import org.apache.ignite.internal.processors.metric.MetricRegistryImpl; import org.apache.ignite.internal.processors.metric.impl.HistogramMetricImpl; import org.apache.ignite.internal.processors.pool.MetricsAwareExecutorService; +import org.apache.ignite.internal.util.GridStringBuilder; import org.apache.ignite.internal.util.tostring.GridToStringExclude; import org.apache.ignite.internal.util.typedef.internal.A; import org.apache.ignite.internal.util.typedef.internal.S; @@ -62,7 +63,7 @@ /** * Striped executor. */ -public class StripedExecutor implements ExecutorService, MetricsAwareExecutorService { +public class IgniteStripedExecutor implements ExecutorService, MetricsAwareExecutorService { /** @see IgniteSystemProperties#IGNITE_DATA_STREAMING_EXECUTOR_SERVICE_TASKS_STEALING_THRESHOLD */ public static final int DFLT_DATA_STREAMING_EXECUTOR_SERVICE_TASKS_STEALING_THRESHOLD = 4; @@ -87,7 +88,7 @@ public class StripedExecutor implements ExecutorService, MetricsAwareExecutorSer * @param errHnd Critical failure handler. * @param gridWorkerLsnr Listener to link with every stripe worker. */ - public StripedExecutor( + public IgniteStripedExecutor( int cnt, String igniteInstanceName, String poolName, @@ -108,7 +109,7 @@ public StripedExecutor( * @param stealTasks {@code True} to steal tasks. * @param gridWorkerLsnr listener to link with every stripe worker. */ - public StripedExecutor( + public IgniteStripedExecutor( int cnt, String igniteInstanceName, String poolName, @@ -535,7 +536,7 @@ public void awaitComplete(int... stripes) throws InterruptedException { /** {@inheritDoc} */ @Override public String toString() { - return S.toString(StripedExecutor.class, this); + return S.toString(IgniteStripedExecutor.class, this); } /** diff --git a/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedExecutor.java b/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedExecutor.java index daeaf001026e9..095cda4949869 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedExecutor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedExecutor.java @@ -18,14 +18,14 @@ package org.apache.ignite.internal.thread.context.pool; import org.apache.ignite.IgniteLogger; +import org.apache.ignite.internal.thread.IgniteStripedExecutor; import org.apache.ignite.internal.thread.context.function.ThreadContextAwareRunnable; -import org.apache.ignite.internal.util.StripedExecutor; import org.apache.ignite.internal.util.worker.GridWorkerListener; import org.apache.ignite.lang.IgniteInClosure; import org.jetbrains.annotations.NotNull; /** */ -public class ThreadContextAwareStripedExecutor extends StripedExecutor { +public class ThreadContextAwareStripedExecutor extends IgniteStripedExecutor { /** */ public ThreadContextAwareStripedExecutor( int cnt, diff --git a/modules/core/src/main/java/org/apache/ignite/spi/systemview/view/StripedExecutorTaskView.java b/modules/core/src/main/java/org/apache/ignite/spi/systemview/view/StripedExecutorTaskView.java index 51f3979fc2258..bde1f64eee177 100644 --- a/modules/core/src/main/java/org/apache/ignite/spi/systemview/view/StripedExecutorTaskView.java +++ b/modules/core/src/main/java/org/apache/ignite/spi/systemview/view/StripedExecutorTaskView.java @@ -18,13 +18,13 @@ package org.apache.ignite.spi.systemview.view; import org.apache.ignite.internal.managers.systemview.walker.Order; -import org.apache.ignite.internal.util.StripedExecutor; -import org.apache.ignite.internal.util.StripedExecutor.Stripe; +import org.apache.ignite.internal.thread.IgniteStripedExecutor; +import org.apache.ignite.internal.thread.IgniteStripedExecutor.Stripe; import static org.apache.ignite.internal.util.IgniteUtils.toStringSafe; /** - * {@link StripedExecutor} task representation for a {@link SystemView}. + * {@link IgniteStripedExecutor} task representation for a {@link SystemView}. */ public class StripedExecutorTaskView { /** Stripe. */ diff --git a/modules/core/src/test/java/org/apache/ignite/internal/metric/JmxExporterSpiTest.java b/modules/core/src/test/java/org/apache/ignite/internal/metric/JmxExporterSpiTest.java index d01649ea29a28..e97fd61f8bb9d 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/metric/JmxExporterSpiTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/metric/JmxExporterSpiTest.java @@ -77,7 +77,7 @@ import org.apache.ignite.internal.processors.metric.impl.MetricUtils; import org.apache.ignite.internal.processors.odbc.jdbc.JdbcConnectionContext; import org.apache.ignite.internal.processors.service.DummyService; -import org.apache.ignite.internal.util.StripedExecutor; +import org.apache.ignite.internal.thread.IgniteStripedExecutor; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.G; import org.apache.ignite.internal.util.typedef.internal.U; @@ -1081,7 +1081,7 @@ private IgniteConfiguration startDedicatedNode(@Nullable IgniteConfiguration cfg * @param viewName System view. * @param poolName Executor name. */ - private void checkStripeExecutorView(StripedExecutor execSvc, String viewName, String poolName) throws Exception { + private void checkStripeExecutorView(IgniteStripedExecutor execSvc, String viewName, String poolName) throws Exception { CountDownLatch latch = new CountDownLatch(1); execSvc.execute(0, new TestRunnable(latch, 0)); diff --git a/modules/core/src/test/java/org/apache/ignite/internal/metric/SystemViewSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/metric/SystemViewSelfTest.java index 80f022dd81fd2..eb2dbd7d99a71 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/metric/SystemViewSelfTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/metric/SystemViewSelfTest.java @@ -94,8 +94,8 @@ import org.apache.ignite.internal.processors.odbc.jdbc.JdbcConnectionContext; import org.apache.ignite.internal.processors.service.DummyService; import org.apache.ignite.internal.processors.task.GridInternal; +import org.apache.ignite.internal.thread.IgniteStripedExecutor; import org.apache.ignite.internal.util.GridTestClockTimer; -import org.apache.ignite.internal.util.StripedExecutor; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.T2; import org.apache.ignite.internal.util.typedef.internal.CU; @@ -1924,7 +1924,7 @@ public void testStripedExecutors() throws Exception { * @param view System view. * @param poolName Executor name. */ - private void checkStripeExecutorView(StripedExecutor execSvc, SystemView view, + private void checkStripeExecutorView(IgniteStripedExecutor execSvc, SystemView view, String poolName) throws Exception { CountDownLatch latch = new CountDownLatch(1); diff --git a/modules/core/src/test/java/org/apache/ignite/internal/util/StripedExecutorTest.java b/modules/core/src/test/java/org/apache/ignite/internal/thread/IgniteStripedExecutorTest.java similarity index 95% rename from modules/core/src/test/java/org/apache/ignite/internal/util/StripedExecutorTest.java rename to modules/core/src/test/java/org/apache/ignite/internal/thread/IgniteStripedExecutorTest.java index de15555177d18..e4462b5f2a329 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/util/StripedExecutorTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/thread/IgniteStripedExecutorTest.java @@ -15,7 +15,7 @@ * limitations under the License. */ -package org.apache.ignite.internal.util; +package org.apache.ignite.internal.thread; import org.apache.ignite.lang.IgniteInClosure; import org.apache.ignite.logger.java.JavaLogger; @@ -26,13 +26,13 @@ /** * */ -public class StripedExecutorTest extends GridCommonAbstractTest { +public class IgniteStripedExecutorTest extends GridCommonAbstractTest { /** */ - private StripedExecutor stripedExecSvc; + private IgniteStripedExecutor stripedExecSvc; /** {@inheritDoc} */ @Override public void beforeTest() { - stripedExecSvc = new StripedExecutor(3, "foo name", "pool name", new JavaLogger(), + stripedExecSvc = new IgniteStripedExecutor(3, "foo name", "pool name", new JavaLogger(), new IgniteInClosure() { @Override public void apply(Throwable throwable) {} }, null, 2000); diff --git a/modules/core/src/test/java/org/apache/ignite/internal/thread/ThreadPoolMetricsTest.java b/modules/core/src/test/java/org/apache/ignite/internal/thread/ThreadPoolMetricsTest.java index fa49967b6350a..3299cce52b831 100644 --- a/modules/core/src/test/java/org/apache/ignite/internal/thread/ThreadPoolMetricsTest.java +++ b/modules/core/src/test/java/org/apache/ignite/internal/thread/ThreadPoolMetricsTest.java @@ -38,7 +38,6 @@ import org.apache.ignite.internal.IgniteEx; import org.apache.ignite.internal.IgniteInternalFuture; import org.apache.ignite.internal.processors.pool.PoolProcessor; -import org.apache.ignite.internal.util.StripedExecutor; import org.apache.ignite.internal.util.lang.RunnableX; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.internal.U; @@ -211,7 +210,7 @@ public void testThreadPoolMetrics() throws Exception { ExecutorService execSvc = entry.getValue().apply(poolProc); MetricRegistry mreg = ignite.context().metric().registry(metricsName); HistogramMetric execTimeMetric = mreg.findMetric(PoolProcessor.TASK_EXEC_TIME); - boolean stripedExecutor = execSvc instanceof StripedExecutor; + boolean stripedExecutor = execSvc instanceof IgniteStripedExecutor; // Ensure that the execution time histogram can be reset. execTimeMetric.reset(); diff --git a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteComputeGridTestSuite.java b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteComputeGridTestSuite.java index 922325aff538b..2b9c98c2d6ac5 100644 --- a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteComputeGridTestSuite.java +++ b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteComputeGridTestSuite.java @@ -88,7 +88,7 @@ import org.apache.ignite.internal.processors.compute.InterruptComputeJobTest; import org.apache.ignite.internal.processors.compute.PublicThreadpoolStarvationTest; import org.apache.ignite.internal.processors.compute.TaskOptionsPropagationTest; -import org.apache.ignite.internal.util.StripedExecutorTest; +import org.apache.ignite.internal.thread.IgniteStripedExecutorTest; import org.apache.ignite.p2p.GridMultinodeRedeployContinuousModeSelfTest; import org.apache.ignite.p2p.GridMultinodeRedeployIsolatedModeSelfTest; import org.apache.ignite.p2p.GridMultinodeRedeployPrivateModeSelfTest; @@ -169,7 +169,7 @@ TaskNodeRestartTest.class, IgniteRoundRobinErrorAfterClientReconnectTest.class, PublicThreadpoolStarvationTest.class, - StripedExecutorTest.class, + IgniteStripedExecutorTest.class, GridJobServicesAddNodeTest.class, GridCollisionManagerLoggingSelfTest.class, diff --git a/modules/indexing/src/test/java/org/apache/ignite/internal/processors/cache/metric/SqlViewExporterSpiTest.java b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/cache/metric/SqlViewExporterSpiTest.java index 118a67c7720c8..c6b2f81884556 100644 --- a/modules/indexing/src/test/java/org/apache/ignite/internal/processors/cache/metric/SqlViewExporterSpiTest.java +++ b/modules/indexing/src/test/java/org/apache/ignite/internal/processors/cache/metric/SqlViewExporterSpiTest.java @@ -72,7 +72,7 @@ import org.apache.ignite.internal.processors.cache.persistence.IgniteCacheDatabaseSharedManager; import org.apache.ignite.internal.processors.metastorage.DistributedMetaStorage; import org.apache.ignite.internal.processors.service.DummyService; -import org.apache.ignite.internal.util.StripedExecutor; +import org.apache.ignite.internal.thread.IgniteStripedExecutor; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.G; import org.apache.ignite.internal.util.typedef.internal.U; @@ -846,7 +846,7 @@ public void testStreamerExecutor() throws Exception { * @param view System view name. * @param poolName Executor name. */ - private void checkStripeExecutorView(StripedExecutor execSvc, String view, String poolName) throws Exception { + private void checkStripeExecutorView(IgniteStripedExecutor execSvc, String view, String poolName) throws Exception { CountDownLatch latch = new CountDownLatch(1); execSvc.execute(0, new TestRunnable(latch, 0)); From aae0b59cb16feb96014f60995482931887c4b23c Mon Sep 17 00:00:00 2001 From: Mikhail Petrov Date: Tue, 21 Oct 2025 13:28:28 +0300 Subject: [PATCH 4/5] IGNITE-26775 --- checkstyle/checkstyle.xml | 33 +++ .../checkstyle/ClassUsageRestrictionRule.java | 235 ++++++++++++++++++ .../ThreadContextAwareExecutorService.java | 118 +++++++++ ...dContextAwareScheduledExecutorService.java | 65 +++++ .../store/jdbc/CacheAbstractJdbcStore.java | 5 +- .../internal/GridKernalContextImpl.java | 4 +- .../apache/ignite/internal/IgniteKernal.java | 6 +- .../apache/ignite/internal/IgnitionEx.java | 4 +- .../ignite/internal/jdbc2/JdbcQueryTask.java | 5 +- ...dAndDeleteGarbageInPersistenceClosure.java | 8 +- .../cache/ValidateIndexesClosure.java | 7 +- .../cache/VerifyBackupPartitionsTask.java | 9 +- .../consistency/ConsistencyRepairTask.java | 4 +- .../managers/communication/GridIoManager.java | 9 +- .../plugin/IgniteLogInfoProviderImpl.java | 6 +- .../processors/cache/GridCacheAdapter.java | 6 +- .../checkpoint/CheckpointWorkflow.java | 12 +- .../persistence/pagemem/PageMemoryImpl.java | 16 +- .../metric/PushMetricsExporterAdapter.java | 6 +- .../processors/pool/PoolProcessor.java | 175 +++---------- .../service/IgniteServiceProcessor.java | 5 +- .../internal/thread/IgniteForkJoinPool.java | 57 +++++ .../IgniteScheduledThreadPoolExecutor.java | 140 +++++++++++ .../thread/IgniteStripedExecutor.java | 3 +- .../thread/IgniteThreadPoolExecutor.java | 155 ++++++++++-- .../ThreadContextAwareIoPool.java | 3 +- .../ThreadContextAwareStripedExecutor.java | 52 ---- ...ContextAwareStripedThreadPoolExecutor.java | 41 --- .../ThreadContextAwareThreadPoolExecutor.java | 94 ------- .../ignite/internal/util/IgniteUtils.java | 6 +- .../tcp/internal/ConnectionClientPool.java | 7 +- .../tcp/internal/GridNioServerWrapper.java | 7 +- .../isolated/IsolatedDiscoverySpi.java | 13 +- .../ignite/spi/discovery/tcp/ClientImpl.java | 6 +- .../ignite/startup/BasicWarmupClosure.java | 8 +- .../context/ThreadContextAttributesTest.java | 49 +++- .../junits/IgniteTestResources.java | 12 +- 37 files changed, 961 insertions(+), 430 deletions(-) create mode 100644 modules/checkstyle/src/main/java/org/apache/ignite/tools/checkstyle/ClassUsageRestrictionRule.java create mode 100644 modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/ThreadContextAwareExecutorService.java create mode 100644 modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/ThreadContextAwareScheduledExecutorService.java create mode 100644 modules/core/src/main/java/org/apache/ignite/internal/thread/IgniteForkJoinPool.java create mode 100644 modules/core/src/main/java/org/apache/ignite/internal/thread/IgniteScheduledThreadPoolExecutor.java rename modules/core/src/main/java/org/apache/ignite/internal/thread/context/{pool => concurrent}/ThreadContextAwareIoPool.java (91%) delete mode 100644 modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedExecutor.java delete mode 100644 modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareStripedThreadPoolExecutor.java delete mode 100644 modules/core/src/main/java/org/apache/ignite/internal/thread/context/pool/ThreadContextAwareThreadPoolExecutor.java diff --git a/checkstyle/checkstyle.xml b/checkstyle/checkstyle.xml index b64eba3540dcb..1e67813d7674d 100644 --- a/checkstyle/checkstyle.xml +++ b/checkstyle/checkstyle.xml @@ -194,6 +194,39 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +