timoninmaxim commented on code in PR #11866:
URL: https://github.com/apache/ignite/pull/11866#discussion_r1954065558
##########
modules/core/src/main/java/org/apache/ignite/internal/management/cache/IdleVerifyResult.java:
##########
@@ -414,4 +405,128 @@ private void printConflicts(Consumer<String> printer) {
@Override public String toString() {
return S.toString(IdleVerifyResult.class, this);
}
+
+ /** */
+ public static IdleVerifyResult ofErrors(Map<ClusterNode, Exception>
exceptions) {
+ return new IdleVerifyResult(exceptions);
+ }
+
+ /** @return A fresh result builder. */
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ /** Builder of {@link IdleVerifyResult}. Is not thread-safe. */
+ public static final class Builder {
+ /** */
+ private @Nullable Map<PartitionKey, List<PartitionHashRecord>>
partHashes;
+
+ /** */
+ private @Nullable List<List<TransactionsHashRecord>> txHashConflicts;
+
+ /** */
+ private @Nullable Map<ClusterNode, Collection<GridCacheVersion>>
partiallyCommittedTxs;
+
+ /** */
+ private Map<ClusterNode, Exception> exceptions;
+
+ /** */
+ private Builder() {
+ // No-op.
+ }
+
+ /** Build the final result. */
+ public IdleVerifyResult build() {
+ if (partHashes == null)
+ partHashes = Collections.emptyMap();
+
+ if (exceptions == null)
+ exceptions = Collections.emptyMap();
+
+ return new IdleVerifyResult(partHashes, txHashConflicts,
partiallyCommittedTxs, exceptions);
+ }
+
+ /** Stores an exception if none is assigned for {@code node}. */
+ public Builder addException(ClusterNode node, Exception e) {
+ assert e != null;
+
+ if (exceptions == null)
+ exceptions = new HashMap<>();
+
+ exceptions.putIfAbsent(node, e);
+
+ return this;
+ }
+
+ /** Stores a collection of partition hashes for partition key {@code
key}. */
+ private Builder addPartitionHashes(PartitionKey key,
Collection<PartitionHashRecord> newHashes) {
+ if (partHashes == null)
+ partHashes = new HashMap<>();
+
+ partHashes.compute(key, (key0, hashes0) -> {
+ if (hashes0 == null)
+ hashes0 = new ArrayList<>();
+
+ hashes0.addAll(newHashes);
+
+ return hashes0;
+ });
+
+ return this;
+ }
+
+ /** Stores a partition hashes map. */
+ public void addPartitionHashes(Map<PartitionKey, PartitionHashRecord>
newHashes) {
+ newHashes.forEach((key, hash) -> addPartitionHashes(key,
Collections.singletonList(hash)));
+ }
+
+ /** Stores a single partition hash for partition key {@code key}. */
+ public Builder addPartitionHash(PartitionKey key, PartitionHashRecord
newHash) {
+ addPartitionHashes(key, Collections.singletonList(newHash));
+
+ return this;
+ }
+
+ /** Sets partition hashes. */
+ public Builder partitionHashes(Map<PartitionKey,
List<PartitionHashRecord>> partHashes) {
Review Comment:
This method isn't used
##########
modules/core/src/main/java/org/apache/ignite/internal/management/cache/IdleVerifyResult.java:
##########
@@ -83,35 +83,24 @@ public class IdleVerifyResult extends
VisorDataTransferObject {
* Default constructor for Externalizable.
*/
public IdleVerifyResult() {
+ // No-op.
}
/**
- * @param exceptions Occurred exceptions.
+ * @see #ofErrors(Map)
+ * @see Builder
*/
- public IdleVerifyResult(Map<ClusterNode, Exception> exceptions) {
+ private IdleVerifyResult(Map<ClusterNode, Exception> exceptions) {
this.exceptions = exceptions;
}
/**
- * @param txHashConflicts Transaction hashes conflicts.
+ * @see Builder
*/
public IdleVerifyResult(
Review Comment:
private
##########
modules/core/src/main/java/org/apache/ignite/internal/management/cache/IdleVerifyResult.java:
##########
@@ -53,104 +55,70 @@ public class IdleVerifyResult extends
VisorDataTransferObject {
/** Counter conflicts. */
@GridToStringInclude
- private Map<PartitionKey, List<PartitionHashRecord>> cntrConflicts = new
HashMap<>();
+ private Map<PartitionKey, List<PartitionHashRecord>> cntrConflicts;
/** Hash conflicts. */
@GridToStringInclude
- private Map<PartitionKey, List<PartitionHashRecord>> hashConflicts = new
HashMap<>();
+ private Map<PartitionKey, List<PartitionHashRecord>> hashConflicts;
/** Moving partitions. */
@GridToStringInclude
- private Map<PartitionKey, List<PartitionHashRecord>> movingPartitions =
new HashMap<>();
+ private Map<PartitionKey, List<PartitionHashRecord>> movingPartitions;
/** Lost partitions. */
@GridToStringInclude
- private Map<PartitionKey, List<PartitionHashRecord>> lostPartitions = new
HashMap<>();
+ private Map<PartitionKey, List<PartitionHashRecord>> lostPartitions;
/** Transaction hashes conflicts. */
@GridToStringInclude
- private @Nullable List<List<TransactionsHashRecord>> txHashConflicts;
+ private List<List<TransactionsHashRecord>> txHashConflicts;
/** Partial committed transactions. */
@GridToStringInclude
- private @Nullable Map<ClusterNode, Collection<GridCacheVersion>>
partiallyCommittedTxs;
+ private Map<ClusterNode, Collection<GridCacheVersion>>
partiallyCommittedTxs;
/** Exceptions. */
@GridToStringInclude
private Map<ClusterNode, Exception> exceptions;
/**
- * Default constructor for Externalizable.
+ * Default public constructor for {@link Externalizable} only.
+ *
+ * @see #builder()
+ * @see #ofErrors(Map)
*/
public IdleVerifyResult() {
+ this(null, null, null, null, null, null, null);
}
/**
- * @param exceptions Occurred exceptions.
+ * @see #ofErrors(Map)
+ * @see #builder()
*/
- public IdleVerifyResult(Map<ClusterNode, Exception> exceptions) {
- this.exceptions = exceptions;
+ private IdleVerifyResult(Map<ClusterNode, Exception> exceptions) {
Review Comment:
Used only once, can be removed
##########
modules/core/src/main/java/org/apache/ignite/internal/management/cache/IdleVerifyResult.java:
##########
@@ -414,4 +379,212 @@ private void printConflicts(Consumer<String> printer) {
@Override public String toString() {
return S.toString(IdleVerifyResult.class, this);
}
+
+ /** */
+ private static <K, V> Map<K, V> notNullFinalMap(@Nullable Map<K, V> map) {
+ return map == null ? Collections.emptyMap() :
Collections.unmodifiableMap(map);
+ }
+
+ /** */
+ private static <V> List<V> notNullFinalList(@Nullable List<V> lst) {
+ return lst == null ? Collections.emptyList() :
Collections.unmodifiableList(lst);
+ }
+
+ /**
+ * Builds result holding errors only.
+ *
+ * @see #builder()
+ */
+ public static IdleVerifyResult ofErrors(Map<ClusterNode, Exception>
exceptions) {
+ return new IdleVerifyResult(exceptions);
+ }
+
+ /** @return A fresh result builder. */
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ /** Builder of {@link IdleVerifyResult}. Is not thread-safe. */
+ public static final class Builder {
+ /** */
+ private @Nullable Map<PartitionKey, List<PartitionHashRecord>>
partHashes;
+
+ /** */
+ private @Nullable List<List<TransactionsHashRecord>> txHashConflicts;
+
+ /** */
+ private @Nullable Map<ClusterNode, Collection<GridCacheVersion>>
partCommitTxs;
+
+ /** Incremental snapshot transactions records per consistent id. */
+ private @Nullable Map<Object, Map<Object, TransactionsHashRecord>>
incrTxHashRecords;
+
+ /** */
+ private @Nullable Map<ClusterNode, Exception> errs;
+
+ /** */
+ private Builder() {
+ // No-op.
+ }
+
+ /** Builds final {@link IdleVerifyResult}. */
+ public IdleVerifyResult build() {
+ // Add all missed incremental pairs to the conflicts.
+ if (!F.isEmpty(incrTxHashRecords))
+ incrTxHashRecords.values().stream().flatMap(e ->
e.values().stream()).forEach(e -> addTxConflicts(F.asList(e, null)));
+
+ if (F.isEmpty(partHashes))
+ return new IdleVerifyResult(null, null, null, null,
txHashConflicts, partCommitTxs, errs);
+
+ Map<PartitionKey, List<PartitionHashRecord>> cntrConflicts = null;
+ Map<PartitionKey, List<PartitionHashRecord>> hashConflicts = null;
+ Map<PartitionKey, List<PartitionHashRecord>> movingPartitions =
null;
+ Map<PartitionKey, List<PartitionHashRecord>> lostPartitions = null;
+
+ for (Map.Entry<PartitionKey, List<PartitionHashRecord>> e :
partHashes.entrySet()) {
+ Integer partHash = null;
+ Integer partVerHash = null;
+ Object updateCntr = null;
+
+ for (PartitionHashRecord record : e.getValue()) {
+ if (record.partitionState() ==
PartitionHashRecord.PartitionState.MOVING) {
+ if (movingPartitions == null)
+ movingPartitions = new HashMap<>();
+
+ movingPartitions.computeIfAbsent(e.getKey(), k -> new
ArrayList<>()).add(record);
+
+ continue;
+ }
+
+ if (record.partitionState() ==
PartitionHashRecord.PartitionState.LOST) {
+ if (lostPartitions == null)
+ lostPartitions = new HashMap<>();
+
+ lostPartitions.computeIfAbsent(e.getKey(), k -> new
ArrayList<>())
+ .add(record);
+
+ continue;
+ }
+
+ if (partHash == null) {
+ partHash = record.partitionHash();
+ partVerHash = record.partitionVersionsHash();
+
+ updateCntr = record.updateCounter();
+ }
+ else {
+ if (!Objects.equals(record.updateCounter(),
updateCntr)) {
+ if (cntrConflicts == null)
+ cntrConflicts = new HashMap<>();
+
+ cntrConflicts.putIfAbsent(e.getKey(),
e.getValue());
+ }
+
+ if (record.partitionHash() != partHash ||
record.partitionVersionsHash() != partVerHash) {
+ if (hashConflicts == null)
+ hashConflicts = new HashMap<>();
+
+ hashConflicts.putIfAbsent(e.getKey(),
e.getValue());
+ }
+ }
+ }
+ }
+
+ return new IdleVerifyResult(cntrConflicts, hashConflicts,
movingPartitions, lostPartitions, txHashConflicts,
+ partCommitTxs, errs);
+ }
+
+ /** Stores an exception if none is aready set for certain node. */
+ public Builder addException(ClusterNode node, Exception e) {
+ assert e != null;
+
+ if (errs == null)
+ errs = new HashMap<>();
+
+ errs.putIfAbsent(node, e);
+
+ return this;
+ }
+
+ /** Stores collection of partition hashes related to certain partition
key. */
+ private Builder addPartitionHashes(PartitionKey key,
Collection<PartitionHashRecord> newHashes) {
Review Comment:
can be inlined
##########
modules/core/src/main/java/org/apache/ignite/internal/management/cache/IdleVerifyResult.java:
##########
@@ -414,4 +405,128 @@ private void printConflicts(Consumer<String> printer) {
@Override public String toString() {
return S.toString(IdleVerifyResult.class, this);
}
+
+ /** */
+ public static IdleVerifyResult ofErrors(Map<ClusterNode, Exception>
exceptions) {
+ return new IdleVerifyResult(exceptions);
+ }
+
+ /** @return A fresh result builder. */
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ /** Builder of {@link IdleVerifyResult}. Is not thread-safe. */
+ public static final class Builder {
+ /** */
+ private @Nullable Map<PartitionKey, List<PartitionHashRecord>>
partHashes;
+
+ /** */
+ private @Nullable List<List<TransactionsHashRecord>> txHashConflicts;
+
+ /** */
+ private @Nullable Map<ClusterNode, Collection<GridCacheVersion>>
partiallyCommittedTxs;
+
+ /** */
+ private Map<ClusterNode, Exception> exceptions;
+
+ /** */
+ private Builder() {
+ // No-op.
+ }
+
+ /** Build the final result. */
+ public IdleVerifyResult build() {
+ if (partHashes == null)
+ partHashes = Collections.emptyMap();
+
+ if (exceptions == null)
+ exceptions = Collections.emptyMap();
+
+ return new IdleVerifyResult(partHashes, txHashConflicts,
partiallyCommittedTxs, exceptions);
+ }
+
+ /** Stores an exception if none is assigned for {@code node}. */
+ public Builder addException(ClusterNode node, Exception e) {
+ assert e != null;
+
+ if (exceptions == null)
+ exceptions = new HashMap<>();
+
+ exceptions.putIfAbsent(node, e);
+
+ return this;
+ }
+
+ /** Stores a collection of partition hashes for partition key {@code
key}. */
+ private Builder addPartitionHashes(PartitionKey key,
Collection<PartitionHashRecord> newHashes) {
+ if (partHashes == null)
+ partHashes = new HashMap<>();
+
+ partHashes.compute(key, (key0, hashes0) -> {
+ if (hashes0 == null)
+ hashes0 = new ArrayList<>();
+
+ hashes0.addAll(newHashes);
+
+ return hashes0;
+ });
+
+ return this;
+ }
+
+ /** Stores a partition hashes map. */
+ public void addPartitionHashes(Map<PartitionKey, PartitionHashRecord>
newHashes) {
+ newHashes.forEach((key, hash) -> addPartitionHashes(key,
Collections.singletonList(hash)));
+ }
+
+ /** Stores a single partition hash for partition key {@code key}. */
+ public Builder addPartitionHash(PartitionKey key, PartitionHashRecord
newHash) {
Review Comment:
This method isn't used
##########
modules/core/src/main/java/org/apache/ignite/internal/management/cache/IdleVerifyResult.java:
##########
@@ -414,4 +405,128 @@ private void printConflicts(Consumer<String> printer) {
@Override public String toString() {
return S.toString(IdleVerifyResult.class, this);
}
+
+ /** */
+ public static IdleVerifyResult ofErrors(Map<ClusterNode, Exception>
exceptions) {
+ return new IdleVerifyResult(exceptions);
+ }
+
+ /** @return A fresh result builder. */
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ /** Builder of {@link IdleVerifyResult}. Is not thread-safe. */
+ public static final class Builder {
+ /** */
+ private @Nullable Map<PartitionKey, List<PartitionHashRecord>>
partHashes;
+
+ /** */
+ private @Nullable List<List<TransactionsHashRecord>> txHashConflicts;
+
+ /** */
+ private @Nullable Map<ClusterNode, Collection<GridCacheVersion>>
partiallyCommittedTxs;
+
+ /** */
+ private Map<ClusterNode, Exception> exceptions;
+
+ /** */
+ private Builder() {
+ // No-op.
+ }
+
+ /** Build the final result. */
+ public IdleVerifyResult build() {
+ if (partHashes == null)
+ partHashes = Collections.emptyMap();
+
+ if (exceptions == null)
+ exceptions = Collections.emptyMap();
+
+ return new IdleVerifyResult(partHashes, txHashConflicts,
partiallyCommittedTxs, exceptions);
+ }
+
+ /** Stores an exception if none is assigned for {@code node}. */
+ public Builder addException(ClusterNode node, Exception e) {
+ assert e != null;
+
+ if (exceptions == null)
+ exceptions = new HashMap<>();
+
+ exceptions.putIfAbsent(node, e);
+
+ return this;
+ }
+
+ /** Stores a collection of partition hashes for partition key {@code
key}. */
+ private Builder addPartitionHashes(PartitionKey key,
Collection<PartitionHashRecord> newHashes) {
+ if (partHashes == null)
+ partHashes = new HashMap<>();
+
+ partHashes.compute(key, (key0, hashes0) -> {
+ if (hashes0 == null)
+ hashes0 = new ArrayList<>();
+
+ hashes0.addAll(newHashes);
+
+ return hashes0;
+ });
+
+ return this;
+ }
+
+ /** Stores a partition hashes map. */
+ public void addPartitionHashes(Map<PartitionKey, PartitionHashRecord>
newHashes) {
+ newHashes.forEach((key, hash) -> addPartitionHashes(key,
Collections.singletonList(hash)));
+ }
+
+ /** Stores a single partition hash for partition key {@code key}. */
+ public Builder addPartitionHash(PartitionKey key, PartitionHashRecord
newHash) {
+ addPartitionHashes(key, Collections.singletonList(newHash));
+
+ return this;
+ }
+
+ /** Sets partition hashes. */
+ public Builder partitionHashes(Map<PartitionKey,
List<PartitionHashRecord>> partHashes) {
+ assert F.isEmpty(this.partHashes) : "Partition hashes are already
set.";
+ assert partHashes != null;
+
+ this.partHashes = partHashes;
+
+ return this;
+ }
+
+ /** Adds transaction conflicts. */
+ public Builder addTxConflicts(List<TransactionsHashRecord>
newTxConflicts) {
+ if (txHashConflicts == null)
+ txHashConflicts = new ArrayList<>();
+
+ txHashConflicts.add(newTxConflicts);
+
+ return this;
+ }
+
+ /** Adds partially commited transactions. */
+ public Builder addPartiallyCommited(ClusterNode node,
Collection<GridCacheVersion> newVerisons) {
+ if (partiallyCommittedTxs == null)
+ partiallyCommittedTxs = new HashMap<>();
+
+ partiallyCommittedTxs.compute(node, (node0, versions0) -> {
+ if (versions0 == null)
+ versions0 = new ArrayList<>();
+
+ versions0.addAll(newVerisons);
+
+ return versions0;
+ });
+
+ return this;
+ }
+
+ /** @return {@code True} if any error is stopre. {@code False}
otherwise. */
+ public boolean hasErrors() {
Review Comment:
This method must be in IdleVerifyResult, not builder
##########
modules/core/src/main/java/org/apache/ignite/internal/management/cache/IdleVerifyResult.java:
##########
@@ -414,4 +379,212 @@ private void printConflicts(Consumer<String> printer) {
@Override public String toString() {
return S.toString(IdleVerifyResult.class, this);
}
+
+ /** */
+ private static <K, V> Map<K, V> notNullFinalMap(@Nullable Map<K, V> map) {
+ return map == null ? Collections.emptyMap() :
Collections.unmodifiableMap(map);
+ }
+
+ /** */
+ private static <V> List<V> notNullFinalList(@Nullable List<V> lst) {
+ return lst == null ? Collections.emptyList() :
Collections.unmodifiableList(lst);
+ }
+
+ /**
+ * Builds result holding errors only.
+ *
+ * @see #builder()
+ */
+ public static IdleVerifyResult ofErrors(Map<ClusterNode, Exception>
exceptions) {
+ return new IdleVerifyResult(exceptions);
+ }
+
+ /** @return A fresh result builder. */
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ /** Builder of {@link IdleVerifyResult}. Is not thread-safe. */
+ public static final class Builder {
+ /** */
+ private @Nullable Map<PartitionKey, List<PartitionHashRecord>>
partHashes;
Review Comment:
Why do you need this intermediate collection? Let's fill all required
collections incrementally in public Builder methods.
##########
modules/core/src/main/java/org/apache/ignite/internal/management/cache/IdleVerifyResult.java:
##########
@@ -414,4 +379,212 @@ private void printConflicts(Consumer<String> printer) {
@Override public String toString() {
return S.toString(IdleVerifyResult.class, this);
}
+
+ /** */
+ private static <K, V> Map<K, V> notNullFinalMap(@Nullable Map<K, V> map) {
+ return map == null ? Collections.emptyMap() :
Collections.unmodifiableMap(map);
+ }
+
+ /** */
+ private static <V> List<V> notNullFinalList(@Nullable List<V> lst) {
+ return lst == null ? Collections.emptyList() :
Collections.unmodifiableList(lst);
+ }
+
+ /**
+ * Builds result holding errors only.
+ *
+ * @see #builder()
+ */
+ public static IdleVerifyResult ofErrors(Map<ClusterNode, Exception>
exceptions) {
+ return new IdleVerifyResult(exceptions);
+ }
+
+ /** @return A fresh result builder. */
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ /** Builder of {@link IdleVerifyResult}. Is not thread-safe. */
+ public static final class Builder {
+ /** */
+ private @Nullable Map<PartitionKey, List<PartitionHashRecord>>
partHashes;
+
+ /** */
+ private @Nullable List<List<TransactionsHashRecord>> txHashConflicts;
+
+ /** */
+ private @Nullable Map<ClusterNode, Collection<GridCacheVersion>>
partCommitTxs;
+
+ /** Incremental snapshot transactions records per consistent id. */
+ private @Nullable Map<Object, Map<Object, TransactionsHashRecord>>
incrTxHashRecords;
+
+ /** */
+ private @Nullable Map<ClusterNode, Exception> errs;
+
+ /** */
+ private Builder() {
+ // No-op.
+ }
+
+ /** Builds final {@link IdleVerifyResult}. */
+ public IdleVerifyResult build() {
+ // Add all missed incremental pairs to the conflicts.
+ if (!F.isEmpty(incrTxHashRecords))
+ incrTxHashRecords.values().stream().flatMap(e ->
e.values().stream()).forEach(e -> addTxConflicts(F.asList(e, null)));
+
+ if (F.isEmpty(partHashes))
+ return new IdleVerifyResult(null, null, null, null,
txHashConflicts, partCommitTxs, errs);
+
+ Map<PartitionKey, List<PartitionHashRecord>> cntrConflicts = null;
+ Map<PartitionKey, List<PartitionHashRecord>> hashConflicts = null;
+ Map<PartitionKey, List<PartitionHashRecord>> movingPartitions =
null;
+ Map<PartitionKey, List<PartitionHashRecord>> lostPartitions = null;
+
+ for (Map.Entry<PartitionKey, List<PartitionHashRecord>> e :
partHashes.entrySet()) {
+ Integer partHash = null;
+ Integer partVerHash = null;
+ Object updateCntr = null;
+
+ for (PartitionHashRecord record : e.getValue()) {
+ if (record.partitionState() ==
PartitionHashRecord.PartitionState.MOVING) {
+ if (movingPartitions == null)
+ movingPartitions = new HashMap<>();
+
+ movingPartitions.computeIfAbsent(e.getKey(), k -> new
ArrayList<>()).add(record);
+
+ continue;
+ }
+
+ if (record.partitionState() ==
PartitionHashRecord.PartitionState.LOST) {
+ if (lostPartitions == null)
+ lostPartitions = new HashMap<>();
+
+ lostPartitions.computeIfAbsent(e.getKey(), k -> new
ArrayList<>())
+ .add(record);
+
+ continue;
+ }
+
+ if (partHash == null) {
+ partHash = record.partitionHash();
+ partVerHash = record.partitionVersionsHash();
+
+ updateCntr = record.updateCounter();
+ }
+ else {
+ if (!Objects.equals(record.updateCounter(),
updateCntr)) {
+ if (cntrConflicts == null)
+ cntrConflicts = new HashMap<>();
+
+ cntrConflicts.putIfAbsent(e.getKey(),
e.getValue());
+ }
+
+ if (record.partitionHash() != partHash ||
record.partitionVersionsHash() != partVerHash) {
+ if (hashConflicts == null)
+ hashConflicts = new HashMap<>();
+
+ hashConflicts.putIfAbsent(e.getKey(),
e.getValue());
+ }
+ }
+ }
+ }
+
+ return new IdleVerifyResult(cntrConflicts, hashConflicts,
movingPartitions, lostPartitions, txHashConflicts,
+ partCommitTxs, errs);
+ }
+
+ /** Stores an exception if none is aready set for certain node. */
+ public Builder addException(ClusterNode node, Exception e) {
+ assert e != null;
+
+ if (errs == null)
+ errs = new HashMap<>();
+
+ errs.putIfAbsent(node, e);
+
+ return this;
+ }
+
+ /** Stores collection of partition hashes related to certain partition
key. */
+ private Builder addPartitionHashes(PartitionKey key,
Collection<PartitionHashRecord> newHashes) {
+ if (partHashes == null)
+ partHashes = new HashMap<>();
+
+ partHashes.compute(key, (key0, hashes0) -> {
+ if (hashes0 == null)
+ hashes0 = new ArrayList<>();
+
+ hashes0.addAll(newHashes);
+
+ return hashes0;
+ });
+
+ return this;
+ }
+
+ /** Stores map of partition hashes per partition key. */
+ public void addPartitionHashes(Map<PartitionKey, PartitionHashRecord>
newHashes) {
+ newHashes.forEach((key, hash) -> addPartitionHashes(key,
Collections.singletonList(hash)));
Review Comment:
Do we need singletonList here? Looks like this is the only entrypoint for
adding partition hash record.
##########
modules/core/src/main/java/org/apache/ignite/internal/management/cache/IdleVerifyResult.java:
##########
@@ -414,4 +379,212 @@ private void printConflicts(Consumer<String> printer) {
@Override public String toString() {
return S.toString(IdleVerifyResult.class, this);
}
+
+ /** */
+ private static <K, V> Map<K, V> notNullFinalMap(@Nullable Map<K, V> map) {
+ return map == null ? Collections.emptyMap() :
Collections.unmodifiableMap(map);
+ }
+
+ /** */
+ private static <V> List<V> notNullFinalList(@Nullable List<V> lst) {
+ return lst == null ? Collections.emptyList() :
Collections.unmodifiableList(lst);
+ }
+
+ /**
+ * Builds result holding errors only.
+ *
+ * @see #builder()
+ */
+ public static IdleVerifyResult ofErrors(Map<ClusterNode, Exception>
exceptions) {
+ return new IdleVerifyResult(exceptions);
+ }
+
+ /** @return A fresh result builder. */
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ /** Builder of {@link IdleVerifyResult}. Is not thread-safe. */
+ public static final class Builder {
+ /** */
+ private @Nullable Map<PartitionKey, List<PartitionHashRecord>>
partHashes;
+
+ /** */
+ private @Nullable List<List<TransactionsHashRecord>> txHashConflicts;
+
+ /** */
+ private @Nullable Map<ClusterNode, Collection<GridCacheVersion>>
partCommitTxs;
+
+ /** Incremental snapshot transactions records per consistent id. */
+ private @Nullable Map<Object, Map<Object, TransactionsHashRecord>>
incrTxHashRecords;
+
+ /** */
+ private @Nullable Map<ClusterNode, Exception> errs;
+
+ /** */
+ private Builder() {
+ // No-op.
+ }
+
+ /** Builds final {@link IdleVerifyResult}. */
+ public IdleVerifyResult build() {
+ // Add all missed incremental pairs to the conflicts.
+ if (!F.isEmpty(incrTxHashRecords))
+ incrTxHashRecords.values().stream().flatMap(e ->
e.values().stream()).forEach(e -> addTxConflicts(F.asList(e, null)));
+
+ if (F.isEmpty(partHashes))
+ return new IdleVerifyResult(null, null, null, null,
txHashConflicts, partCommitTxs, errs);
+
+ Map<PartitionKey, List<PartitionHashRecord>> cntrConflicts = null;
+ Map<PartitionKey, List<PartitionHashRecord>> hashConflicts = null;
+ Map<PartitionKey, List<PartitionHashRecord>> movingPartitions =
null;
+ Map<PartitionKey, List<PartitionHashRecord>> lostPartitions = null;
+
+ for (Map.Entry<PartitionKey, List<PartitionHashRecord>> e :
partHashes.entrySet()) {
+ Integer partHash = null;
+ Integer partVerHash = null;
+ Object updateCntr = null;
+
+ for (PartitionHashRecord record : e.getValue()) {
+ if (record.partitionState() ==
PartitionHashRecord.PartitionState.MOVING) {
+ if (movingPartitions == null)
+ movingPartitions = new HashMap<>();
+
+ movingPartitions.computeIfAbsent(e.getKey(), k -> new
ArrayList<>()).add(record);
+
+ continue;
+ }
+
+ if (record.partitionState() ==
PartitionHashRecord.PartitionState.LOST) {
+ if (lostPartitions == null)
+ lostPartitions = new HashMap<>();
+
+ lostPartitions.computeIfAbsent(e.getKey(), k -> new
ArrayList<>())
+ .add(record);
+
+ continue;
+ }
+
+ if (partHash == null) {
+ partHash = record.partitionHash();
+ partVerHash = record.partitionVersionsHash();
+
+ updateCntr = record.updateCounter();
+ }
+ else {
+ if (!Objects.equals(record.updateCounter(),
updateCntr)) {
+ if (cntrConflicts == null)
+ cntrConflicts = new HashMap<>();
+
+ cntrConflicts.putIfAbsent(e.getKey(),
e.getValue());
+ }
+
+ if (record.partitionHash() != partHash ||
record.partitionVersionsHash() != partVerHash) {
+ if (hashConflicts == null)
+ hashConflicts = new HashMap<>();
+
+ hashConflicts.putIfAbsent(e.getKey(),
e.getValue());
+ }
+ }
+ }
+ }
+
+ return new IdleVerifyResult(cntrConflicts, hashConflicts,
movingPartitions, lostPartitions, txHashConflicts,
+ partCommitTxs, errs);
+ }
+
+ /** Stores an exception if none is aready set for certain node. */
+ public Builder addException(ClusterNode node, Exception e) {
+ assert e != null;
+
+ if (errs == null)
+ errs = new HashMap<>();
+
+ errs.putIfAbsent(node, e);
+
+ return this;
+ }
+
+ /** Stores collection of partition hashes related to certain partition
key. */
+ private Builder addPartitionHashes(PartitionKey key,
Collection<PartitionHashRecord> newHashes) {
+ if (partHashes == null)
+ partHashes = new HashMap<>();
+
+ partHashes.compute(key, (key0, hashes0) -> {
+ if (hashes0 == null)
+ hashes0 = new ArrayList<>();
+
+ hashes0.addAll(newHashes);
+
+ return hashes0;
+ });
+
+ return this;
+ }
+
+ /** Stores map of partition hashes per partition key. */
+ public void addPartitionHashes(Map<PartitionKey, PartitionHashRecord>
newHashes) {
+ newHashes.forEach((key, hash) -> addPartitionHashes(key,
Collections.singletonList(hash)));
+ }
+
+ /** Stores incremental snapshot transaction hash records of a certain
node. */
+ public void addIncrementalHashRecords(ClusterNode node, Map<Object,
TransactionsHashRecord> res) {
+ if (incrTxHashRecords == null)
+ incrTxHashRecords = new HashMap<>();
+
+ assert incrTxHashRecords.get(node.consistentId()) == null;
+
+ incrTxHashRecords.put(node.consistentId(), res);
+
+ Iterator<Map.Entry<Object, TransactionsHashRecord>> resIt =
res.entrySet().iterator();
+
+ while (resIt.hasNext()) {
+ Map.Entry<Object, TransactionsHashRecord> nodeTxHash =
resIt.next();
+
+ Map<Object, TransactionsHashRecord> prevNodeTxHash =
incrTxHashRecords.get(nodeTxHash.getKey());
+
+ if (prevNodeTxHash != null) {
+ TransactionsHashRecord hash = nodeTxHash.getValue();
+ TransactionsHashRecord prevHash =
prevNodeTxHash.remove(hash.localConsistentId());
+
+ if (prevHash == null || prevHash.transactionHash() !=
hash.transactionHash())
+ addTxConflicts(F.asList(hash, prevHash));
+
+ resIt.remove();
+ }
+ }
+ }
+
+ /** Stores transaction conflicts. */
+ public Builder addTxConflicts(List<TransactionsHashRecord>
newTxConflicts) {
Review Comment:
private
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: notifications-unsubscr...@ignite.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
