diff --git a/.github/workflows/check-protected-classes.yml b/.github/workflows/check-protected-classes.yml index 72edb90498837..4167e9ae0c8b5 100644 --- a/.github/workflows/check-protected-classes.yml +++ b/.github/workflows/check-protected-classes.yml @@ -13,11 +13,11 @@ # See the License for the specific language governing permissions and # limitations under the License. -name: Protected Classes +name: Message Table Compatibility # pull_request_target for the write token needed to comment/label the PR. The fork's changes are -# read through the API as data and never checked out or executed, so no allow-unsafe-pr-checkout and -# no working copy of the PR code on the runner. Do not add a step that builds or runs the PR code. +# checked only through GitHub metadata and never checked out or executed, so no allow-unsafe-pr-checkout +# and no working copy of the PR code on the runner. Do not add a step that builds or runs the PR code. on: pull_request_target concurrency: @@ -25,7 +25,7 @@ concurrency: cancel-in-progress: true jobs: - check-protected-classes: + check-message-table: runs-on: ubuntu-latest name: Rolling Upgrade check permissions: @@ -33,85 +33,48 @@ jobs: pull-requests: write checks: write steps: - - name: Detect protected class changes and report + - name: Detect message table changes and report uses: actions/github-script@v8 with: script: | - const ORDER_USE = '@Order('; - const ORDER_IMPORT = 'import org.apache.ignite.internal.Order;'; - const ORDER_PKG = 'package org.apache.ignite.internal;'; + const MESSAGE_TABLE = 'modules/compatibility-check/src/main/resources/messages/table.xml'; const MARKER = ''; const { owner, repo } = context.repo; const pr = context.payload.pull_request; - const baseSha = pr.base.sha; const headSha = pr.head.sha; - // Changed files are read from the API as data; the fork's code is never checked out or executed. + // Changed file names are read from the API as data; the fork's code is never checked out or executed. const files = await github.paginate(github.rest.pulls.listFiles, { owner, repo, pull_number: pr.number, per_page: 100, }); - // Reproduce `git diff --no-renames --diff-filter=ADM`: a rename is a delete(old)+add(new) pair. - // A protected class carries the @Order annotation; an added file is defined by the head revision, - // a deleted/modified one by the base. - const revisions = []; - for (const f of files) { - if (f.status === 'added' || f.status === 'copied') - revisions.push([f.filename, headSha]); - else if (f.status === 'removed' || f.status === 'modified' || f.status === 'changed') - revisions.push([f.filename, baseSha]); - else if (f.status === 'renamed') { - revisions.push([f.previous_filename, baseSha]); - revisions.push([f.filename, headSha]); - } - } + const messageTableChanged = files.some(f => + f.filename === MESSAGE_TABLE || f.previous_filename === MESSAGE_TABLE); - const isProtected = async (path, ref) => { - let meta; - try { - ({ data: meta } = await github.rest.repos.getContent({ owner, repo, path, ref })); - } catch (e) { - if (e.status === 404) return false; - throw e; - } - if (Array.isArray(meta) || meta.type !== 'file') return false; - let content = meta.content ? Buffer.from(meta.content, 'base64').toString('utf8') : ''; - if (!content && meta.sha) { - const { data: blob } = await github.rest.git.getBlob({ owner, repo, file_sha: meta.sha }); - content = Buffer.from(blob.content, blob.encoding).toString('utf8'); - } - const lines = content.split(/\r?\n/); + const comments = await github.paginate(github.rest.issues.listComments, { + owner, repo, issue_number: pr.number, + }); + const existing = comments.find(c => c.body && c.body.includes(MARKER)); - return content.includes(ORDER_USE) - && (lines.includes(ORDER_IMPORT) || lines.includes(ORDER_PKG)); - }; + if (!messageTableChanged) { + if (existing) + await github.rest.issues.deleteComment({ owner, repo, comment_id: existing.id }); - const hits = []; - for (const [path, ref] of revisions) { - if (path.endsWith('.java') - && !path.startsWith('modules/core/src/test/resources/codegen/') - && await isProtected(path, ref)) hits.push(path); + return; } - if (hits.length === 0) return; - - // File names come from the fork; render them as inert inline code so they cannot inject - // markdown (backticks, @mentions, links) into content posted under the bot's write token. - const safe = f => '`' + String(f).replace(/[`\r\n]/g, '') + '`'; - const list = hits.map(f => '- ' + safe(f)).join('\n'); + const safePath = '`' + MESSAGE_TABLE + '`'; const summary = [ - 'This PR modifies protected classes (with **Order** annotation).', - 'Changes to these classes can break rolling upgrade compatibility.', + 'This PR changes the generated communication message table.', + 'This does not mean that rolling upgrade compatibility is broken, but the diff needs a review.', '', - '**Affected files:**', - list, + '**Review target:**', + '- ' + safePath, + '', + 'Inspect the XML diff for changed message ids, classes, fields, types or serialization annotations.', ].join('\n'); - const body = MARKER + '\n## Possible compatibility issues. Please, check rolling upgrade cases\n\n' + summary + '\n'; + const body = MARKER + '\n## Message table changed. Please review rolling upgrade compatibility\n\n' + summary + '\n'; - const comments = await github.paginate(github.rest.issues.listComments, { - owner, repo, issue_number: pr.number, - }); - const existing = comments.find(c => c.body.includes(MARKER)); if (existing) { await github.rest.issues.deleteComment({ owner, repo, comment_id: existing.id }); } @@ -127,5 +90,5 @@ jobs: head_sha: headSha, status: 'completed', conclusion: 'neutral', - output: { title: 'Possible compatibility issues', summary }, + output: { title: 'Message table changed', summary }, }); diff --git a/.github/workflows/commit-check.yml b/.github/workflows/commit-check.yml index 8e90eb9ba7c0f..a2bd88fc8ebbd 100644 --- a/.github/workflows/commit-check.yml +++ b/.github/workflows/commit-check.yml @@ -105,7 +105,7 @@ jobs: run: | set -o pipefail rc=0 - ./mvnw test-compile -Pall-java,licenses,lgpl,checkstyle,examples,check-licenses -B -V -T 1C 2>&1 | tee mvn-codestyle.log || rc=$? + ./mvnw test-compile -Pall-java,licenses,lgpl,checkstyle,examples,check-licenses,message-table -B -V -T 1C 2>&1 | tee mvn-codestyle.log || rc=$? if [ "$rc" -ne 0 ] && grep -q "COMPILATION ERROR" mvn-codestyle.log; then echo "::error title=Compilation failed::Java compilation failed - this is a compile error, not a checkstyle violation. The flood of 'cannot find symbol' for generated *Walker/*Serializer/*Factory classes is a cascade: javac drops annotation-processor output when compilation fails. Fix the real error(s) listed in the build log group below first." echo "::group::Likely root-cause compile errors (generated-class cascade filtered out)" @@ -119,6 +119,13 @@ jobs: fi exit "$rc" + - name: Check message table is up to date + run: | + if ! git diff --exit-code -- modules/compatibility-check/src/main/resources/messages/table.xml; then + echo "::error title=Message table is outdated::Run the build with -Pmessage-table and commit the updated modules/compatibility-check/src/main/resources/messages/table.xml." + exit 1 + fi + - name: Run abandoned tests checks. # Reuse classes from the previous step; the differing profiles otherwise trigger a full reactor recompile. run : | diff --git a/modules/compatibility-check/README.md b/modules/compatibility-check/README.md new file mode 100644 index 0000000000000..482dc7298a9ab --- /dev/null +++ b/modules/compatibility-check/README.md @@ -0,0 +1,56 @@ +# Message table + +Exports registered Ignite messages to +[`src/main/resources/messages/table.xml`](src/main/resources/messages/table.xml) to control compatibility changes. +The table contains message IDs, classes, ordered wire fields and serialization annotations. +Logical `@Marshalled` fields are written separately from ordered wire fields. + +The table covers messages registered by +[`CoreMessagesProvider`](../core/src/main/java/org/apache/ignite/internal/CoreMessagesProvider.java), +[`GridH2ValueMessageFactory`](../indexing/src/main/java/org/apache/ignite/internal/processors/query/h2/twostep/msg/GridH2ValueMessageFactory.java), +[`CalciteMessageFactory`](../calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/message/CalciteMessageFactory.java) and +[`ZkMessageFactory`](../zookeeper/src/main/java/org/apache/ignite/spi/discovery/zk/internal/ZkMessageFactory.java). +Unregistered messages and third-party providers are out of scope. `CompressedMessage` is included +with an empty schema because it has a hand-written serializer. + +This module only generates the table. It does not compare revisions or decide whether a +change is compatible. + +Example: + +```xml + + + + byte[] + dataBytes + + + + + + value=dataBytes + + java.util.Map<java.lang.String,java.io.Serializable> + data + + + +``` + +## Generate + +Use JDK 17. Enable the `message-table` profile to update the table directly: + +```sh +./mvnw -pl modules/compatibility-check -Pmessage-table process-classes +``` + +Without the profile, the generation step does not run. Review the XML diff and +include it in the commit when message definitions change. + +After generation, CI can check that the committed table is up to date with: + +```sh +git diff --exit-code -- modules/compatibility-check/src/main/resources/messages/table.xml +``` diff --git a/modules/compatibility-check/pom.xml b/modules/compatibility-check/pom.xml new file mode 100644 index 0000000000000..da367d2161cd0 --- /dev/null +++ b/modules/compatibility-check/pom.xml @@ -0,0 +1,107 @@ + + + + 4.0.0 + + org.apache.ignite + ignite-parent-internal + ${revision} + ../../parent-internal/pom.xml + + ignite-compatibility-check + + true + + + + org.apache.ignite + ignite-codegen + + + org.apache.ignite + ignite-tools + test + + + org.apache.ignite + ignite-core + + + org.apache.ignite + ignite-indexing + + + org.apache.ignite + ignite-calcite + + + org.apache.ignite + ignite-zookeeper + + + junit + junit + 4.13.2 + test + + + + + + maven-surefire-plugin + + 1 + + + + maven-compiler-plugin + + none + + + + + + + message-table + + + + org.codehaus.mojo + exec-maven-plugin + + + generate-message-table + process-classes + + exec + + + ${java.home}/bin/java + + -cp + + org.apache.ignite.tools.compatibility.messages.MessageTable + ${project.basedir}/src/main/resources/messages/table.xml + + + + + + + + + + diff --git a/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/MessageSchemaReader.java b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/MessageSchemaReader.java new file mode 100644 index 0000000000000..36cebe0e3dd7b --- /dev/null +++ b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/MessageSchemaReader.java @@ -0,0 +1,157 @@ +/* + * 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.tools.compatibility.messages; + +import java.io.IOException; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.Deque; +import java.util.List; +import java.util.Locale; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.TypeKind; +import javax.lang.model.util.ElementFilter; +import javax.tools.JavaCompiler; +import javax.tools.StandardJavaFileManager; +import javax.tools.ToolProvider; +import com.sun.source.util.JavacTask; +import org.apache.ignite.internal.Compress; +import org.apache.ignite.internal.CustomMapper; +import org.apache.ignite.internal.JdkMarshalled; +import org.apache.ignite.internal.Marshalled; +import org.apache.ignite.internal.NioField; +import org.apache.ignite.internal.Order; +import org.apache.ignite.tools.compatibility.messages.dto.AnnotationRepresentation; +import org.apache.ignite.tools.compatibility.messages.dto.FieldRepresentation; +import org.apache.ignite.tools.compatibility.messages.dto.Schema; + +/** Reads CLASS-retained field annotations from compiled classes using the public JDK compiler API. */ +class MessageSchemaReader implements AutoCloseable { + /** Classpath reader, closed after exporting the table. */ + private final StandardJavaFileManager files; + + /** Compiler model of existing class files; no sources or processors are executed. */ + private final JavacTask task; + + /** Creates a reader for the same classpath as the registration providers. */ + MessageSchemaReader() { + JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); + + if (compiler == null) + throw new IllegalStateException("A full JDK is required to read message fields"); + + String classpath = System.getProperty("java.class.path"); + + List options = List.of("-proc:none", "-classpath", classpath); + + files = compiler.getStandardFileManager(null, Locale.ROOT, null); + + task = (JavacTask)compiler.getTask(null, files, null, options, null, List.of()); + } + + /** Returns a canonical field description, including inherited fields and marshalling annotations. */ + Schema read(Class cls) { + TypeElement msgType = task.getElements().getTypeElement(cls.getCanonicalName()); + + if (msgType == null) + throw new IllegalStateException("Message class is missing from compiler classpath: " + cls.getName()); + + Deque hierarchy = new ArrayDeque<>(); + + TypeElement curMsgType = msgType; + + while (curMsgType.getSuperclass().getKind() != TypeKind.NONE) { + hierarchy.addFirst(curMsgType); + + curMsgType = (TypeElement)task.getTypes().asElement(curMsgType.getSuperclass()); + } + + List schema = new ArrayList<>(); + + List clsAnnotations = new ArrayList<>(); + + if (hierarchy.stream().anyMatch(t -> t.getAnnotation(JdkMarshalled.class) != null)) + clsAnnotations.add(new AnnotationRepresentation(JdkMarshalled.class.getName(), null)); + + List marshalledFields = new ArrayList<>(); + + for (TypeElement t : hierarchy) { + List fields = new ArrayList<>(ElementFilter.fieldsIn(t.getEnclosedElements())); + + for (VariableElement field : fields) { + Marshalled ann = field.getAnnotation(Marshalled.class); + + if (ann != null) { + marshalledFields.add(new FieldRepresentation( + null, + field.asType().toString(), + field.getSimpleName().toString(), + List.of(new AnnotationRepresentation(Marshalled.class.getName(), marshalledValue(ann))) + )); + } + } + + fields.removeIf(f -> f.getAnnotation(Order.class) == null); + fields.sort(Comparator.comparingInt(f -> f.getAnnotation(Order.class).value())); + + int orderOffset = schema.size(); + + for (VariableElement field : fields) { + List annotations = new ArrayList<>(); + + if (field.getAnnotation(Compress.class) != null) + annotations.add(new AnnotationRepresentation(Compress.class.getName(), null)); + + if (field.getAnnotation(NioField.class) != null) + annotations.add(new AnnotationRepresentation(NioField.class.getName(), null)); + + CustomMapper mapper = field.getAnnotation(CustomMapper.class); + + if (mapper != null) + annotations.add(new AnnotationRepresentation(CustomMapper.class.getName(), mapper.value())); + + schema.add(new FieldRepresentation( + orderOffset + field.getAnnotation(Order.class).value(), + field.asType().toString(), + field.getSimpleName().toString(), + annotations + )); + } + } + + marshalledFields.sort(Comparator.comparing(FieldRepresentation::type) + .thenComparing(FieldRepresentation::name) + .thenComparing(field -> field.annotations().get(0).value())); + + schema.addAll(marshalledFields); + + return new Schema(clsAnnotations, schema); + } + + /** Returns a stable value for the {@link Marshalled} annotation. */ + private static String marshalledValue(Marshalled ann) { + return !ann.value().isEmpty() ? "value=" + ann.value() : "keys=" + ann.keys() + " values=" + ann.values(); + } + + /** {@inheritDoc} */ + @Override public void close() throws IOException { + files.close(); + } +} diff --git a/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/MessageTable.java b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/MessageTable.java new file mode 100644 index 0000000000000..989a49e738c99 --- /dev/null +++ b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/MessageTable.java @@ -0,0 +1,56 @@ +/* + * 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.tools.compatibility.messages; + +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import org.apache.ignite.internal.CoreMessagesProvider; +import org.apache.ignite.internal.processors.query.calcite.message.CalciteMessageFactory; +import org.apache.ignite.internal.processors.query.h2.twostep.msg.GridH2ValueMessageFactory; +import org.apache.ignite.plugin.extensions.communication.MessageFactoryProvider; +import org.apache.ignite.spi.discovery.zk.internal.ZkMessageFactory; +import org.apache.ignite.tools.compatibility.messages.dto.MessageRepresentation; + +/** Exports the actual production registrations and their compiled field descriptions. */ +public class MessageTable { + /** + * Exports the registered messages to an XML file. + * + * @param args Output file path. + * @throws Exception If the build is incomplete or the inputs cannot be read. + */ + public static void main(String[] args) throws Exception { + if (args.length != 1) + throw new IllegalArgumentException("Expected: output-file"); + + Path out = Path.of(args[0]).toAbsolutePath(); + MessageFactoryProvider[] providers = { + new CoreMessagesProvider(), + new GridH2ValueMessageFactory(), + new CalciteMessageFactory(), + new ZkMessageFactory() + }; + + List msgs = new MessageTableCollector(providers).collect(); + String table = new XmlTableWriter().toXml(msgs); + + Files.createDirectories(out.getParent()); + Files.writeString(out, table); + } +} diff --git a/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/MessageTableCollector.java b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/MessageTableCollector.java new file mode 100644 index 0000000000000..f93336478006d --- /dev/null +++ b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/MessageTableCollector.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.tools.compatibility.messages; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import org.apache.ignite.internal.managers.communication.IgniteMessageFactoryImpl; +import org.apache.ignite.plugin.extensions.communication.MessageFactoryProvider; +import org.apache.ignite.tools.compatibility.messages.dto.MessageRepresentation; + +/** Collects registered messages and their compiled schemas. */ +class MessageTableCollector { + /** Factory with the selected providers registered. */ + private final IgniteMessageFactoryImpl factory; + + /** @param providers Message registration providers. */ + MessageTableCollector(MessageFactoryProvider[] providers) { + factory = new IgniteMessageFactoryImpl<>(providers); + } + + /** + * @return Collected message table. + * @throws Exception If any registered message cannot be described. + */ + List collect() throws IOException { + short[] ids = factory.registeredDirectTypes(); + + Arrays.sort(ids); + + List msgs = new ArrayList<>(); + + try (MessageSchemaReader schemaReader = new MessageSchemaReader()) { + for (short id : ids) { + Class msgCls = factory.create(id).getClass(); + + msgs.add(new MessageRepresentation(id, msgCls.getName(), schemaReader.read(msgCls))); + } + } + + return msgs; + } +} diff --git a/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/XmlTableWriter.java b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/XmlTableWriter.java new file mode 100644 index 0000000000000..a01f7893ea241 --- /dev/null +++ b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/XmlTableWriter.java @@ -0,0 +1,205 @@ +/* + * 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.tools.compatibility.messages; + +import java.io.StringWriter; +import java.util.Comparator; +import java.util.List; +import javax.xml.stream.XMLOutputFactory; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamWriter; +import org.apache.ignite.internal.Marshalled; +import org.apache.ignite.tools.compatibility.messages.dto.AnnotationRepresentation; +import org.apache.ignite.tools.compatibility.messages.dto.FieldRepresentation; +import org.apache.ignite.tools.compatibility.messages.dto.MessageRepresentation; + +/** Writes collected message metadata as XML with fixed formatting. */ +class XmlTableWriter { + /** Apache license header for generated XML files. */ + private static final String LICENSE = "\n" + + " Licensed to the Apache Software Foundation (ASF) under one or more\n" + + " contributor license agreements. See the NOTICE file distributed with\n" + + " this work for additional information regarding copyright ownership.\n" + + " The ASF licenses this file to You under the Apache License, Version 2.0\n" + + " (the \"License\"); you may not use this file except in compliance with\n" + + " the License. You may obtain a copy of the License at\n" + + "\n" + + " http://www.apache.org/licenses/LICENSE-2.0\n" + + "\n" + + " Unless required by applicable law or agreed to in writing, software\n" + + " distributed under the License is distributed on an \"AS IS\" BASIS,\n" + + " WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n" + + " See the License for the specific language governing permissions and\n" + + " limitations under the License.\n"; + + /** + * Writes collected metadata without loading message classes. + * + * @param msgs Collected messages. + * @return XML table. + * @throws XMLStreamException If XML writing fails. + */ + String toXml(List msgs) throws XMLStreamException { + StringWriter out = new StringWriter(); + XMLStreamWriter xml = XMLOutputFactory.newDefaultFactory().createXMLStreamWriter(out); + + try { + xml.writeStartDocument("UTF-8", "1.0"); + xml.writeCharacters("\n"); + xml.writeComment(LICENSE); + xml.writeCharacters("\n"); + xml.writeStartElement("messageTable"); + xml.writeAttribute("formatVersion", "1"); + xml.writeCharacters("\n "); + + writeMessages(xml, msgs); + + xml.writeEndElement(); + xml.writeCharacters("\n"); + xml.writeEndDocument(); + } + finally { + xml.close(); + } + + return out.toString(); + } + + /** Writes the collected messages in their existing order. */ + private static void writeMessages(XMLStreamWriter xml, List msgs) throws XMLStreamException { + xml.writeStartElement("messages"); + + for (MessageRepresentation msg : msgs) + writeMessage(xml, msg); + + xml.writeCharacters("\n "); + xml.writeEndElement(); + xml.writeCharacters("\n"); + } + + /** Writes one message and its fields. */ + private static void writeMessage(XMLStreamWriter xml, MessageRepresentation msg) throws XMLStreamException { + xml.writeCharacters("\n "); + xml.writeStartElement("message"); + xml.writeAttribute("id", Short.toString(msg.id())); + xml.writeAttribute("class", msg.className()); + + writeAnnotations(xml, msg.schema().annotations(), " "); + + writeOrderedFields(xml, msg.schema().fields()); + writeMarshalledFields(xml, msg.schema().fields()); + + xml.writeCharacters("\n "); + xml.writeEndElement(); + } + + /** Writes ordered wire fields. */ + private static void writeOrderedFields(XMLStreamWriter xml, List fields) + throws XMLStreamException { + List orderedFields = fields.stream().filter(field -> !isMarshalled(field)).toList(); + + if (orderedFields.isEmpty()) + return; + + xml.writeCharacters("\n "); + xml.writeStartElement("orderedFields"); + + for (FieldRepresentation field : orderedFields) + writeField(xml, field, " "); + + xml.writeCharacters("\n "); + xml.writeEndElement(); + } + + /** Writes logical fields converted to ordered wire fields by the generated marshaller. */ + private static void writeMarshalledFields(XMLStreamWriter xml, List fields) + throws XMLStreamException { + List marshalledFields = fields.stream().filter(XmlTableWriter::isMarshalled).toList(); + + if (marshalledFields.isEmpty()) + return; + + xml.writeCharacters("\n "); + xml.writeStartElement("marshalledFields"); + + for (FieldRepresentation field : marshalledFields) + writeField(xml, field, " "); + + xml.writeCharacters("\n "); + xml.writeEndElement(); + } + + /** Writes one field using the given indentation. */ + private static void writeField(XMLStreamWriter xml, FieldRepresentation field, String indent) + throws XMLStreamException { + xml.writeCharacters("\n" + indent); + xml.writeStartElement("field"); + + if (field.order() != null) + xml.writeAttribute("order", Integer.toString(field.order())); + + writeAnnotations(xml, field.annotations(), indent + " "); + + xml.writeCharacters("\n" + indent + " "); + xml.writeStartElement("type"); + xml.writeCharacters(field.type()); + xml.writeEndElement(); + + xml.writeCharacters("\n" + indent + " "); + + xml.writeStartElement("name"); + xml.writeCharacters(field.name()); + xml.writeEndElement(); + + xml.writeCharacters("\n" + indent); + xml.writeEndElement(); + } + + /** Returns {@code true} if the field is a logical field converted by the generated marshaller. */ + private static boolean isMarshalled(FieldRepresentation field) { + return field.annotations().stream().anyMatch(a -> Marshalled.class.getName().equals(a.name())); + } + + /** Writes class or field annotations in name order using fixed indentation. */ + private static void writeAnnotations(XMLStreamWriter xml, List annotations, String indent) + throws XMLStreamException { + if (annotations.isEmpty()) + return; + + xml.writeCharacters("\n" + indent); + xml.writeStartElement("annotations"); + + List sorted = annotations.stream() + .sorted(Comparator.comparing(AnnotationRepresentation::name)).toList(); + + for (AnnotationRepresentation annotation : sorted) { + xml.writeCharacters("\n" + indent + " "); + + if (annotation.value() == null) + xml.writeEmptyElement(annotation.name()); + else { + xml.writeStartElement(annotation.name()); + xml.writeCharacters(annotation.value()); + xml.writeEndElement(); + } + } + + xml.writeCharacters("\n" + indent); + xml.writeEndElement(); + } +} diff --git a/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/dto/AnnotationRepresentation.java b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/dto/AnnotationRepresentation.java new file mode 100644 index 0000000000000..a50639ae0b744 --- /dev/null +++ b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/dto/AnnotationRepresentation.java @@ -0,0 +1,28 @@ +/* + * 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.tools.compatibility.messages.dto; + +/** + * Serialization annotation. + * + * @param name Annotation name. + * @param value Annotation value, or null for a marker. + */ +public record AnnotationRepresentation(String name, String value) { + // No-op. +} diff --git a/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/dto/FieldRepresentation.java b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/dto/FieldRepresentation.java new file mode 100644 index 0000000000000..674b755e019d1 --- /dev/null +++ b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/dto/FieldRepresentation.java @@ -0,0 +1,32 @@ +/* + * 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.tools.compatibility.messages.dto; + +import java.util.List; + +/** + * Field description. + * + * @param order Field order, or {@code null} for logical fields without a wire order. + * @param type Field type. + * @param name Field name. + * @param annotations Serialization annotations. + */ +public record FieldRepresentation(Integer order, String type, String name, List annotations) { + // No-op. +} diff --git a/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/dto/MessageRepresentation.java b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/dto/MessageRepresentation.java new file mode 100644 index 0000000000000..2a27e9cd66719 --- /dev/null +++ b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/dto/MessageRepresentation.java @@ -0,0 +1,29 @@ +/* + * 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.tools.compatibility.messages.dto; + +/** + * Registered message and its class schema. + * + * @param id Registered message ID. + * @param className Message class name. + * @param schema Class schema. + */ +public record MessageRepresentation(short id, String className, Schema schema) { + // No-op. +} diff --git a/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/dto/Schema.java b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/dto/Schema.java new file mode 100644 index 0000000000000..1543885a7131a --- /dev/null +++ b/modules/compatibility-check/src/main/java/org/apache/ignite/tools/compatibility/messages/dto/Schema.java @@ -0,0 +1,30 @@ +/* + * 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.tools.compatibility.messages.dto; + +import java.util.List; + +/** + * Class schema, independent of message registration and output format. + * + * @param annotations Class serialization annotations. + * @param fields Ordered wire fields and logical fields converted to ordered wire fields by the generated marshaller. + */ +public record Schema(List annotations, List fields) { + // No-op. +} diff --git a/modules/compatibility-check/src/main/resources/messages/table.xml b/modules/compatibility-check/src/main/resources/messages/table.xml new file mode 100644 index 0000000000000..254ed0dc15561 --- /dev/null +++ b/modules/compatibility-check/src/main/resources/messages/table.xml @@ -0,0 +1,10528 @@ + + + + + + + + long + reqId + + + long + updCnt + + + java.lang.String + err + + + byte[] + errKeysBytes + + + + + + + long + reqId + + + java.util.List<java.lang.Integer> + caches + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + int[] + qryParts + + + int + pageSize + + + java.lang.String + qry + + + byte + flags + + + int + timeout + + + byte[] + paramsBytes + + + java.lang.String + schemaName + + + boolean + explicitTimeout + + + java.lang.String + qryInitiatorId + + + + + + + java.lang.String + schema + + + java.lang.String + tbl + + + + + + + int + rangeId + + + org.apache.ignite.internal.processors.query.h2.twostep.msg.GridH2RowMessage + first + + + org.apache.ignite.internal.processors.query.h2.twostep.msg.GridH2RowMessage + last + + + + + + + int + rangeId + + + java.util.List<org.apache.ignite.internal.processors.query.h2.twostep.msg.GridH2RowMessage> + rows + + + byte + flags + + + + + + + long + reqId + + + java.util.List<java.lang.Integer> + caches + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + java.util.Map<java.util.UUID,int[]> + parts + + + int[] + qryParts + + + int + pageSize + + + java.util.List<org.apache.ignite.internal.processors.cache.query.GridCacheSqlQuery> + qrys + + + byte + flags + + + java.util.Collection<org.apache.ignite.internal.processors.query.h2.QueryTable> + tbls + + + int + timeout + + + byte[] + paramsBytes + + + java.lang.String + schemaName + + + java.lang.String + qryInitiatorId + + + long + qryId + + + boolean + explicitTimeout + + + + + + + java.util.List<org.apache.ignite.internal.processors.query.h2.twostep.msg.GridH2ValueMessage> + vals + + + + + + + java.util.UUID + originNodeId + + + long + qryId + + + int + segmentId + + + int + originSegmentId + + + int + batchLookupId + + + java.util.List<org.apache.ignite.internal.processors.query.h2.twostep.msg.GridH2RowRange> + ranges + + + byte + status + + + java.lang.String + err + + + + + + + java.util.UUID + originNodeId + + + long + qryId + + + int + originSegmentId + + + int + segmentId + + + int + batchLookupId + + + java.util.List<org.apache.ignite.internal.processors.query.h2.twostep.msg.GridH2RowRangeBounds> + bounds + + + + + + + org.apache.ignite.internal.processors.cache.CacheObject + obj + + + + + + + byte[] + b + + + + + + + long + high + + + long + low + + + + + + + byte[] + b + + + + + + + java.util.Collection<org.apache.ignite.plugin.extensions.communication.Message> + x + + + + + + + java.lang.String + x + + + + + + + byte[] + b + + + + + + + long + date + + + long + nanos + + + + + + + long + date + + + + + + + long + nanos + + + + + + + float + x + + + + + + + double + x + + + + + + + int + scale + + + byte[] + b + + + + + + + long + x + + + + + + + int + x + + + + + + + short + x + + + + + + + byte + x + + + + + + + boolean + x + + + + + + + + + java.lang.String + schema + + + java.util.UUID + qryId + + + long + originatingQryId + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + ver + + + org.apache.ignite.internal.processors.query.calcite.metadata.FragmentDescription + fragmentDesc + + + java.lang.String + root + + + int + totalFragmentsCnt + + + byte[] + paramsBytes + + + long + timeout + + + java.util.Collection<org.apache.ignite.internal.processors.query.calcite.message.QueryTxEntry> + qryTxEntries + + + java.util.Map<java.lang.String,java.lang.String> + appAttrs + + + boolean + keepBinaryMode + + + + + + value=paramsBytes + + java.lang.Object[] + params + + + + + + + java.util.UUID + qryId + + + long + fragmentId + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + + + + + + + + byte[] + errBytes + + + java.util.UUID + qryId + + + long + fragmentId + + + + + + + java.util.UUID + qryId + + + long + fragmentId + + + long + exchangeId + + + int + batchId + + + boolean + last + + + java.util.List<org.apache.ignite.internal.processors.query.calcite.message.GenericValueMessage> + mRows + + + + + + + java.util.UUID + qryId + + + long + fragmentId + + + long + exchangeId + + + int + batchId + + + + + + + java.util.UUID + qryId + + + long + fragmentId + + + long + exchangeId + + + + + + + java.util.UUID + qryId + + + + + + + byte[] + serialized + + + + + + value=serialized + + java.lang.Object + val + + + + + + + java.util.List<org.apache.ignite.internal.processors.query.calcite.metadata.ColocationGroup> + colocationGrps + + + + + + + long[] + srcIds + + + java.util.List<java.util.UUID> + nodeIds + + + int[] + marshalledAssignments + + + + + + + long + fragmentId + + + org.apache.ignite.internal.processors.query.calcite.metadata.FragmentMapping + mapping + + + java.util.Map<java.lang.Long,java.util.List<java.util.UUID>> + remoteSources + + + org.apache.ignite.internal.processors.query.calcite.metadata.ColocationGroup + target + + + + + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.KeyCacheObject + key + + + org.apache.ignite.internal.processors.cache.CacheObject + val + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + + + + + java.util.UUID + futId + + + long + topVer + + + + + + + java.util.UUID + id + + + + + + + long + nodeInternalId + + + java.lang.String + warning + + + + + + + + + java.util.Map<java.lang.Integer,org.apache.ignite.plugin.extensions.communication.Message> + data + + + + + + + org.apache.ignite.spi.discovery.DiscoverySpiCustomMessage + delegate + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + + + + + + + + + + byte[] + errBytes + + + + + + + java.lang.String + hostName + + + byte[] + addrBytes + + + int + port + + + + + + + java.lang.String + hostName + + + byte[] + addrBytes + + + + + + + java.util.UUID + id + + + byte[] + consistentIdBytes + + + byte[] + attrsBytes + + + java.util.Collection<java.lang.String> + addrs + + + java.util.Collection<java.lang.String> + hostNames + + + int + discPort + + + org.apache.ignite.internal.ClusterMetricsSnapshot + clusterMetricsSnapshot + + + long + order + + + long + intOrder + + + org.apache.ignite.lang.IgniteProductVersion + ver + + + java.util.UUID + clientRouterNodeId + + + org.apache.ignite.internal.processors.rollingupgrade.feature.IgniteNodeFeatureSet + features + + + + + + value=consistentIdBytes + + java.lang.Object + consistentId + + + + value=attrsBytes + + java.util.Map<java.lang.String,java.lang.Object> + attrs + + + + + + + java.util.UUID + joiningNodeId + + + + + + java.util.Map<java.lang.Integer,org.apache.ignite.plugin.extensions.communication.Message> + joiningNodeData + + + + + + java.util.Map<java.lang.Integer,org.apache.ignite.plugin.extensions.communication.Message> + commonData + + + + + + java.util.Map<java.util.UUID,java.util.Map<java.lang.Integer,org.apache.ignite.plugin.extensions.communication.Message>> + nodeSpecificData + + + + + + + byte[] + data + + + int + size + + + + + + + org.apache.ignite.internal.processors.cache.CacheObject + val + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + int + cacheId + + + + + + + org.apache.ignite.internal.processors.cache.CacheObject + val + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.KeyCacheObject + key + + + + + + + long + idx + + + int + fileOff + + + int + len + + + + + + + byte[] + dataBytes + + + + + + + byte[] + topicBytes + + + int + ord + + + + + + + int[] + arr + + + int + idx + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + java.util.UUID + prevNodeId + + + java.lang.String + dcId + + + org.apache.ignite.internal.processors.rollingupgrade.feature.IgniteNodeFeatureSet + nodeFeatures + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + long + order + + + boolean + prevNodeAliveFlag + + + java.util.Collection<org.apache.ignite.spi.discovery.tcp.messages.InetSocketAddressMessage> + redirectAddrsMsgs + + + org.apache.ignite.internal.processors.rollingupgrade.feature.IgniteNodeFeatureSet + nodeFeatures + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + org.apache.ignite.spi.discovery.tcp.internal.TcpDiscoveryNode + node + + + org.apache.ignite.spi.discovery.tcp.internal.DiscoveryDataPacket + dataPacket + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + org.apache.ignite.spi.discovery.tcp.internal.TcpDiscoveryNode + node + + + org.apache.ignite.spi.discovery.tcp.internal.DiscoveryDataPacket + dataPacket + + + java.util.Collection<org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryAbstractMessage> + pendingMsgs + + + java.util.Collection<org.apache.ignite.spi.discovery.tcp.internal.TcpDiscoveryNode> + top + + + java.util.Map<java.lang.Long,java.util.Collection<org.apache.ignite.spi.discovery.tcp.internal.TcpDiscoveryNode>> + topHist + + + long + gridStartTime + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + java.util.UUID + nodeId + + + org.apache.ignite.spi.discovery.tcp.internal.DiscoveryDataPacket + clientDiscoData + + + byte[] + clientNodeAttrsBytes + + + + + + value=clientNodeAttrsBytes + + java.util.Map<java.lang.String,java.lang.Object> + clientNodeAttrs + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + java.util.UUID + failedNodeId + + + long + order + + + java.lang.String + warning + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + java.util.UUID + clientNodeId + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + boolean + clientExists + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + java.util.UUID + nodeToPing + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + java.util.UUID + nodeToPing + + + boolean + res + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + org.apache.ignite.lang.IgniteUuid + msgId + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + java.util.UUID + routerNodeId + + + org.apache.ignite.lang.IgniteUuid + lastMsgId + + + java.util.Collection<org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryAbstractMessage> + pendingMsgs + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + org.apache.ignite.lang.IgniteUuid + msgId + + + boolean + customMsgDiscard + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + java.lang.String + err + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + java.util.Collection<java.lang.String> + addrs + + + java.util.Collection<java.lang.String> + hostNames + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + int + maxHops + + + int + curHops + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + java.util.UUID + nodeId + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + org.apache.ignite.spi.discovery.DiscoverySpiCustomMessage + msg + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + org.apache.ignite.spi.discovery.DiscoverySpiCustomMessage + msg + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + java.util.Collection<org.apache.ignite.spi.discovery.tcp.messages.InetSocketAddressMessage> + creatorNodeAddrsMsgs + + + java.util.UUID + failedNodeId + + + int + status + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + procId + + + int + type + + + org.apache.ignite.plugin.extensions.communication.Message + req + + + boolean + waitClnRes + + + boolean + needExchange + + + + + + + java.util.UUID + reqId + + + java.lang.String + snpName + + + java.lang.String + snpPath + + + java.util.Collection<java.lang.String> + grps + + + long + startTime + + + java.util.Set<java.util.UUID> + nodes + + + boolean + fullCheck + + + boolean + allRestoreHandlers + + + int + incIdx + + + + + + + java.util.UUID + reqId + + + java.lang.String + snpName + + + java.lang.String + snpPath + + + java.util.Collection<java.lang.String> + grps + + + long + startTime + + + java.util.Set<java.util.UUID> + nodes + + + java.util.UUID + opNodeId + + + boolean + incremental + + + int + incIdx + + + boolean + onlyPrimary + + + boolean + dump + + + boolean + compress + + + boolean + encrypt + + + boolean + configOnly + + + + + + + java.util.UUID + reqId + + + org.apache.ignite.internal.util.ErrorMessage + err + + + java.util.List<java.lang.String> + warnings + + + + + + + java.util.UUID + reqId + + + + + + + java.util.Map<java.lang.String,org.apache.ignite.internal.processors.cache.persistence.snapshot.SnapshotHandlerResult<org.apache.ignite.plugin.extensions.communication.Message>> + hndResults + + + + + + + org.apache.ignite.plugin.extensions.communication.Message + data + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + + + + + org.apache.ignite.plugin.extensions.communication.Message + result + + + java.util.Map<java.lang.String,org.apache.ignite.internal.util.ErrorMessage> + errors + + + + + + + java.util.Map<org.apache.ignite.internal.management.cache.PartitionKey,org.apache.ignite.internal.processors.cache.verify.PartitionHashRecord> + res + + + + + + + java.util.List<org.apache.ignite.internal.processors.cache.StoredCacheData> + ccfgs + + + java.util.List<org.apache.ignite.internal.processors.cache.persistence.snapshot.SnapshotMetadata> + metas + + + + + + + java.util.List<org.apache.ignite.internal.processors.cache.persistence.snapshot.SnapshotMetadata> + metadata + + + + + + + java.util.UUID + rqId + + + java.lang.String + snpName + + + java.lang.String + consId + + + java.lang.String + folderName + + + boolean + comprParts + + + int + pageSize + + + java.util.List<java.lang.Integer> + grpIds + + + java.util.Set<java.lang.String> + bltNodes + + + org.apache.ignite.internal.processors.cache.persistence.wal.WALPointer + snpRecPtr + + + java.util.Map<java.lang.Integer,java.util.Set<java.lang.Integer>> + locParts + + + byte[] + masterKeyDigest + + + java.util.List<java.lang.String> + warnings + + + long + snapshotTime + + + java.util.Set<java.lang.Integer> + comprGrpIds + + + boolean + hasComprGrps + + + boolean + onlyPrimary + + + boolean + dump + + + byte[] + encKey + + + + + + + java.util.Map<java.lang.String,java.util.Map<org.apache.ignite.internal.management.cache.PartitionKey,org.apache.ignite.internal.processors.cache.verify.PartitionHashRecord>> + perMetaResults + + + + + + + java.util.Map<java.lang.String,java.util.Map<java.lang.String,org.apache.ignite.internal.processors.cache.persistence.snapshot.SnapshotHandlerResult<org.apache.ignite.plugin.extensions.communication.Message>>> + perMetaResults + + + + + + + java.lang.String + id + + + java.util.UUID + reqId + + + java.lang.String + snpName + + + java.lang.String + snpPath + + + java.util.Map<java.lang.Integer,int[]> + parts + + + + + + + java.lang.String + id + + + java.lang.String + errMsg + + + + + + + java.util.Collection<org.apache.ignite.internal.processors.cache.verify.TransactionsHashRecord> + txHashRes + + + java.util.Collection<org.apache.ignite.internal.processors.cache.verify.PartitionHashRecord> + partHashRes + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + partiallyCommittedTxs + + + java.util.Collection<org.apache.ignite.internal.util.ErrorMessage> + exceptions + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + org.apache.ignite.internal.processors.cache.GridCacheMessage + payload + + + java.util.UUID + id + + + java.util.UUID + txSnpId + + + long + topVer + + + + + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + org.apache.ignite.lang.IgniteUuid + reqId + + + + + + + int + cnt + + + java.util.Collection<org.apache.ignite.internal.util.ErrorMessage> + errors + + + + + + + org.apache.ignite.lang.IgniteUuid + srvcId + + + java.util.Map<java.util.UUID,org.apache.ignite.internal.processors.service.ServiceSingleNodeDeploymentResult> + results + + + boolean + isSvcTopTransitional + + + + + + + org.apache.ignite.lang.IgniteUuid + srvcId + + + org.apache.ignite.internal.processors.service.LazyServiceConfigurationMessage + cfgMsg + + + + + + + org.apache.ignite.lang.IgniteUuid + srvcId + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + org.apache.ignite.internal.processors.service.ServiceDeploymentProcessId + depId + + + java.util.Collection<org.apache.ignite.internal.processors.service.ServiceClusterDeploymentResult> + results + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.Collection<org.apache.ignite.internal.processors.service.ServiceChangeAbstractRequest> + reqs + + + + + + + org.apache.ignite.internal.processors.service.ServiceDeploymentProcessId + depId + + + java.util.Map<org.apache.ignite.lang.IgniteUuid,org.apache.ignite.internal.processors.service.ServiceSingleNodeDeploymentResult> + results + + + + + + + java.util.List<org.apache.ignite.internal.processors.service.ServiceInfo> + registeredServices + + + + + + + java.util.List<org.apache.ignite.internal.processors.service.ServiceInfo> + staticServicesInfo + + + + + + + java.util.UUID + originNodeId + + + org.apache.ignite.lang.IgniteUuid + srvcId + + + org.apache.ignite.internal.processors.service.LazyServiceConfigurationMessage + cfgMsg + + + boolean + staticCfg + + + org.apache.ignite.internal.processors.service.ServiceTopology + top + + + + + + + java.util.Map<java.util.UUID,java.lang.Integer> + snapshot + + + boolean + isTransitional + + + + + + + java.lang.String + name + + + int + totalCnt + + + int + maxPerNodeCnt + + + java.lang.String + cacheName + + + byte[] + affKeyBytes + + + boolean + isStatisticsEnabled + + + int + locStartOrder + + + java.lang.String + srvcClsName + + + byte[] + srvcBytes + + + byte[] + nodeFilterBytes + + + byte[] + interceptorsBytes + + + java.lang.String[] + platformMtdNames + + + + + + value=affKeyBytes + + java.lang.Object + affKey + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + receiverNodeId + + + int + connIdx + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + reqId + + + java.lang.String + key + + + byte[] + valBytes + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + reqId + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + reqId + + + java.lang.String + key + + + byte[] + valBytes + + + byte[] + expValBytes + + + boolean + matches + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + reqId + + + boolean + updated + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + processId + + + int + type + + + java.util.Map<java.util.UUID,R> + res + + + java.util.Map<java.util.UUID,org.apache.ignite.internal.util.ErrorMessage> + err + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + procId + + + int + type + + + org.apache.ignite.plugin.extensions.communication.Message + req + + + boolean + waitClnRes + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + reqId + + + java.util.Collection<java.lang.String> + caches + + + byte + flags + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + int + typeId + + + boolean + duplicated + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + origNodeId + + + int + typeId + + + boolean + onCoordinator + + + java.lang.String + errMsg + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + opId + + + int + grpId + + + org.apache.ignite.lang.IgniteUuid + grpDepId + + + boolean + changed + + + java.lang.String + errMsg + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + opId + + + int + grpId + + + org.apache.ignite.lang.IgniteUuid + grpDepId + + + java.util.Map<java.lang.String,org.apache.ignite.lang.IgniteUuid> + caches + + + boolean + enable + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + int + typeId + + + int + acceptedVer + + + boolean + duplicated + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + origNodeId + + + byte[] + metadataBytes + + + int + typeId + + + int + pendingVer + + + int + acceptedVer + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + + + + value=metadataBytes + + org.apache.ignite.internal.binary.BinaryMetadata + metadata + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + reqId + + + long + timeout + + + boolean + isInit + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + org.apache.ignite.lang.IgniteUuid + opId + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + org.apache.ignite.internal.processors.authentication.UserManagementOperation + op + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + reqId + + + org.apache.ignite.cluster.ClusterState + state + + + boolean + transitionRes + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + routineId + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + routineId + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionExchangeId + exchId + + + java.util.Map<java.lang.Integer,java.util.Map<java.lang.Integer,java.util.List<java.util.UUID>>> + assignmentChange + + + java.util.Map<java.lang.Integer,org.apache.ignite.lang.IgniteUuid> + cacheDeploymentIds + + + org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsFullMessage + partsMsg + + + boolean + exchangeNeeded + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.Map<java.lang.Integer,java.lang.Boolean> + startedCaches + + + java.util.Set<java.lang.Integer> + closedCaches + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + org.apache.ignite.internal.processors.marshaller.MarshallerMappingItem + item + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + origNodeId + + + org.apache.ignite.internal.processors.marshaller.MarshallerMappingItem + mappingItem + + + org.apache.ignite.internal.processors.marshaller.MappingProposedMessage.ProposalStatus + status + + + java.lang.String + conflictingClsName + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.Collection<java.lang.String> + cacheNames + + + org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionExchangeId + exchId + + + java.util.Map<java.util.UUID,org.apache.ignite.internal.util.ErrorMessage> + exchangeErrors + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + reqId + + + java.util.Collection<java.lang.String> + caches + + + byte + flags + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + reqId + + + java.util.Map<java.lang.String,org.apache.ignite.internal.processors.cache.DynamicCacheChangeRequest> + startReqs + + + java.util.Set<java.lang.String> + cachesToClose + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.Collection<org.apache.ignite.internal.processors.cache.DynamicCacheChangeRequest> + reqs + + + + + + + java.util.Map<java.lang.String,org.apache.ignite.internal.processors.cache.CacheReconnectInfo> + clientCaches + + + + + + + java.util.Set<java.lang.Integer> + lostParts + + + java.util.Set<java.lang.Integer> + zeroParts + + + + + + + org.apache.ignite.internal.processors.cache.StoredCacheData + cacheData + + + org.apache.ignite.internal.processors.cache.CacheType + cacheType + + + boolean + sql + + + long + flags + + + boolean + staticallyConfigured + + + + + + + java.util.Map<java.lang.String,org.apache.ignite.internal.processors.cache.CacheJoinInfo> + caches + + + java.util.Map<java.lang.String,org.apache.ignite.internal.processors.cache.CacheJoinInfo> + templates + + + org.apache.ignite.lang.IgniteUuid + cacheDeploymentId + + + boolean + startCaches + + + org.apache.ignite.internal.processors.cache.ClusterCacheGroupRecoveryData + clusterCacheGrpRecoveryData + + + + + + + java.lang.String + cacheName + + + org.apache.ignite.lang.IgniteUuid + deploymentId + + + boolean + nearCache + + + + + + + long + clusterBaselineTopVer + + + java.util.Map<java.lang.Integer,org.apache.ignite.internal.processors.cache.CacheGroupRecoveryState> + grpStates + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + byte[] + payload + + + java.util.List<java.util.UUID> + path + + + long + hopSendTsMillis + + + java.util.List<java.lang.Long> + hopTimesMillis + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + org.apache.ignite.lang.IgniteUuid + requestId + + + java.util.List<java.util.UUID> + path + + + java.util.List<java.lang.Long> + hopTimesMillis + + + + + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + dhtVer + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + nearVer + + + + + + + int + cacheId + + + java.util.Collection<org.apache.ignite.internal.processors.cache.KeyCacheObject> + keys + + + + + + + java.util.UUID + nearNodeId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + txId + + + long + threadId + + + byte + ownership + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + long + futId + + + java.util.Collection<org.apache.ignite.internal.processors.cache.transactions.IgniteTxKey> + txKeys + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + long + futId + + + org.apache.ignite.internal.processors.cache.transactions.IgniteTxKey[] + nearTxKeysArr + + + java.util.Collection<org.apache.ignite.internal.processors.cache.transactions.IgniteTxKey> + txKeys + + + java.util.List<org.apache.ignite.internal.processors.cache.transactions.TxLock>[] + locksArr + + + + + + keys=nearTxKeysArr values=locksArr + + java.util.Map<org.apache.ignite.internal.processors.cache.transactions.IgniteTxKey,java.util.List<org.apache.ignite.internal.processors.cache.transactions.TxLock>> + nearTxKeyLocks + + + + + + + org.apache.ignite.internal.processors.cache.KeyCacheObject + key + + + int + cacheId + + + + + + + org.apache.ignite.internal.processors.cache.KeyCacheObject + key + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.transactions.TxEntryValueHolder + val + + + org.apache.ignite.internal.processors.cache.transactions.TxEntryValueHolder + oldVal + + + byte[] + transformClosBytes + + + long + ttl + + + long + conflictExpireTime + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + conflictVer + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + explicitVer + + + org.apache.ignite.internal.processors.cache.CacheEntryPredicate[] + filters + + + byte[] + expiryPlcBytes + + + byte + flags + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + serReadVer + + + + + + value=transformClosBytes + + java.util.Collection<org.apache.ignite.internal.util.typedef.T2<javax.cache.processor.EntryProcessor<java.lang.Object,java.lang.Object,java.lang.Object>,java.lang.Object[]>> + entryProcessorsCol + + + + + + + org.apache.ignite.internal.processors.cache.CacheObject + val + + + org.apache.ignite.internal.processors.cache.GridCacheOperation + op + + + boolean + hasWriteVal + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + org.apache.ignite.lang.IgniteUuid + futId + + + org.apache.ignite.lang.IgniteUuid + miniId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + nearXidVer + + + int + txNum + + + boolean + sys + + + boolean + nearTxCheck + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + org.apache.ignite.lang.IgniteUuid + futId + + + org.apache.ignite.lang.IgniteUuid + miniId + + + boolean + success + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + org.apache.ignite.lang.IgniteUuid + futId + + + long + threadId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + commitVer + + + boolean + invalidate + + + boolean + commit + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + baseVer + + + byte + plc + + + int + taskNameHash + + + byte + flags + + + org.apache.ignite.cache.CacheWriteSynchronizationMode + syncMode + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + txId + + + org.apache.ignite.lang.IgniteUuid + futId + + + int + part + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + long + threadId + + + org.apache.ignite.transactions.TransactionConcurrency + concurrency + + + org.apache.ignite.transactions.TransactionIsolation + isolation + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + writeVer + + + long + timeout + + + java.util.Collection<org.apache.ignite.internal.processors.cache.transactions.IgniteTxEntry> + reads + + + java.util.Collection<org.apache.ignite.internal.processors.cache.transactions.IgniteTxEntry> + writes + + + java.util.Collection<org.apache.ignite.internal.processors.cache.transactions.IgniteTxKey> + dhtVerKeys + + + int + txSize + + + java.util.Map<java.util.UUID,java.util.Collection<java.util.UUID>> + txNodes + + + byte + plc + + + byte + flags + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + int + part + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + org.apache.ignite.lang.IgniteUuid + futId + + + long + threadId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + commitVer + + + boolean + invalidate + + + boolean + commit + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + baseVer + + + byte + plc + + + int + taskNameHash + + + byte + flags + + + org.apache.ignite.cache.CacheWriteSynchronizationMode + syncMode + + + java.util.UUID + nearNodeId + + + int + miniId + + + java.util.Collection<org.apache.ignite.internal.processors.cache.distributed.dht.PartitionUpdateCountersMessage> + updCntrs + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + txId + + + org.apache.ignite.lang.IgniteUuid + futId + + + int + part + + + int + miniId + + + org.apache.ignite.internal.util.ErrorMessage + checkCommittedErrMsg + + + org.apache.ignite.internal.processors.cache.GridCacheReturn + retVal + + + boolean + checkCommitted + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + long + threadId + + + org.apache.ignite.transactions.TransactionConcurrency + concurrency + + + org.apache.ignite.transactions.TransactionIsolation + isolation + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + writeVer + + + long + timeout + + + java.util.Collection<org.apache.ignite.internal.processors.cache.transactions.IgniteTxEntry> + reads + + + java.util.Collection<org.apache.ignite.internal.processors.cache.transactions.IgniteTxEntry> + writes + + + java.util.Collection<org.apache.ignite.internal.processors.cache.transactions.IgniteTxKey> + dhtVerKeys + + + int + txSize + + + java.util.Map<java.util.UUID,java.util.Collection<java.util.UUID>> + txNodes + + + byte + plc + + + byte + flags + + + java.util.UUID + nearNodeId + + + org.apache.ignite.lang.IgniteUuid + futId + + + int + miniId + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + java.util.BitSet + invalidateNearEntries + + + java.util.Collection<org.apache.ignite.internal.processors.cache.transactions.IgniteTxEntry> + nearWrites + + + java.util.Collection<org.apache.ignite.internal.processors.cache.transactions.IgniteTxKey> + ownedKeys + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + ownedVals + + + java.util.Collection<org.apache.ignite.internal.processors.cache.distributed.dht.PartitionUpdateCountersMessage> + updCntrs + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + nearXidVer + + + int + taskNameHash + + + java.util.BitSet + preloadKeys + + + boolean + skipCompletedVers + + + java.lang.String + txLbl + + + + + + keys=ownedKeys values=ownedVals + + java.util.Map<org.apache.ignite.internal.processors.cache.transactions.IgniteTxKey,org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + owned + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + int + part + + + java.util.Collection<org.apache.ignite.internal.processors.cache.transactions.IgniteTxKey> + nearEvicted + + + org.apache.ignite.lang.IgniteUuid + futId + + + int + miniId + + + java.util.Map<java.lang.Integer,int[]> + invalidParts + + + java.util.List<org.apache.ignite.internal.processors.cache.GridCacheEntryInfo> + preloadEntries + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + org.apache.ignite.lang.IgniteUuid + futId + + + long + threadId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + commitVer + + + boolean + invalidate + + + boolean + commit + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + baseVer + + + byte + plc + + + int + taskNameHash + + + byte + flags + + + org.apache.ignite.cache.CacheWriteSynchronizationMode + syncMode + + + int + miniId + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + txId + + + org.apache.ignite.lang.IgniteUuid + futId + + + int + part + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + int + miniId + + + long + nearThreadId + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + long + threadId + + + org.apache.ignite.transactions.TransactionConcurrency + concurrency + + + org.apache.ignite.transactions.TransactionIsolation + isolation + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + writeVer + + + long + timeout + + + java.util.Collection<org.apache.ignite.internal.processors.cache.transactions.IgniteTxEntry> + reads + + + java.util.Collection<org.apache.ignite.internal.processors.cache.transactions.IgniteTxEntry> + writes + + + java.util.Collection<org.apache.ignite.internal.processors.cache.transactions.IgniteTxKey> + dhtVerKeys + + + int + txSize + + + java.util.Map<java.util.UUID,java.util.Collection<java.util.UUID>> + txNodes + + + byte + plc + + + byte + flags + + + org.apache.ignite.lang.IgniteUuid + futId + + + int + miniId + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + int + taskNameHash + + + byte + flags + + + java.lang.String + txLbl + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + int + part + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + pending + + + org.apache.ignite.lang.IgniteUuid + futId + + + int + miniId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + dhtVer + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + writeVer + + + java.util.Collection<org.apache.ignite.internal.processors.cache.distributed.near.KeyedVersionedValue> + ownedVals + + + org.apache.ignite.internal.processors.cache.GridCacheReturn + retVal + + + java.util.Collection<org.apache.ignite.internal.processors.cache.transactions.IgniteTxKey> + filterFailedKeys + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + clientRemapVer + + + boolean + onePhaseCommit + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + java.util.UUID + nodeId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + nearXidVer + + + long + threadId + + + org.apache.ignite.lang.IgniteUuid + futId + + + long + timeout + + + boolean + isInTx + + + boolean + isInvalidate + + + boolean + isRead + + + org.apache.ignite.transactions.TransactionIsolation + isolation + + + java.util.List<org.apache.ignite.internal.processors.cache.KeyCacheObject> + keys + + + boolean[] + retVals + + + int + txSize + + + byte + flags + + + java.util.BitSet + invalidateEntries + + + org.apache.ignite.lang.IgniteUuid + miniId + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + int + taskNameHash + + + java.util.BitSet + preloadKeys + + + long + accessTtl + + + java.lang.String + txLbl + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + org.apache.ignite.lang.IgniteUuid + futId + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + java.util.List<org.apache.ignite.internal.processors.cache.CacheObject> + vals + + + org.apache.ignite.lang.IgniteUuid + miniId + + + java.util.Collection<java.lang.Integer> + invalidParts + + + java.util.List<org.apache.ignite.internal.processors.cache.GridCacheEntryInfo> + preloadEntries + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + java.util.List<org.apache.ignite.internal.processors.cache.KeyCacheObject> + keys + + + boolean + forSavepoint + + + java.util.List<org.apache.ignite.internal.processors.cache.KeyCacheObject> + nearKeys + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + java.util.UUID + nodeId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + nearXidVer + + + long + threadId + + + org.apache.ignite.lang.IgniteUuid + futId + + + long + timeout + + + boolean + isInTx + + + boolean + isInvalidate + + + boolean + isRead + + + org.apache.ignite.transactions.TransactionIsolation + isolation + + + java.util.List<org.apache.ignite.internal.processors.cache.KeyCacheObject> + keys + + + boolean[] + retVals + + + int + txSize + + + byte + flags + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + int + miniId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion[] + dhtVers + + + int + taskNameHash + + + long + createTtl + + + long + accessTtl + + + byte + flags + + + java.lang.String + txLbl + + + long + waitTimeout + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + org.apache.ignite.lang.IgniteUuid + futId + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + java.util.List<org.apache.ignite.internal.processors.cache.CacheObject> + vals + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + pending + + + int + miniId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion[] + dhtVers + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion[] + mappedVers + + + boolean[] + filterRes + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + clientRemapVer + + + boolean + compatibleRemapVer + + + boolean + lockAcquired + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + java.util.List<org.apache.ignite.internal.processors.cache.KeyCacheObject> + keys + + + boolean + forSavepoint + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + java.util.UUID + nodeId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + nearXidVer + + + long + threadId + + + org.apache.ignite.lang.IgniteUuid + futId + + + long + timeout + + + boolean + isInTx + + + boolean + isInvalidate + + + boolean + isRead + + + org.apache.ignite.transactions.TransactionIsolation + isolation + + + java.util.List<org.apache.ignite.internal.processors.cache.KeyCacheObject> + keys + + + boolean[] + retVals + + + int + txSize + + + byte + flags + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + committedVers + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + rolledbackVers + + + org.apache.ignite.lang.IgniteUuid + futId + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + java.util.List<org.apache.ignite.internal.processors.cache.CacheObject> + vals + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + java.util.Collection<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + vers + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + org.apache.ignite.internal.processors.cache.distributed.GridDistributedTxPrepareRequest + payload + + + java.util.Map<java.lang.String,java.lang.String> + appAttrs + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.lang.IgniteUuid + futId + + + org.apache.ignite.lang.IgniteUuid + miniId + + + java.util.Collection<org.apache.ignite.internal.processors.cache.KeyCacheObject> + keys + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.lang.IgniteUuid + futId + + + org.apache.ignite.lang.IgniteUuid + miniId + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + java.util.List<org.apache.ignite.internal.processors.cache.KeyCacheObject> + missedKeys + + + java.util.List<org.apache.ignite.internal.processors.cache.GridCacheEntryInfo> + infos + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.util.GridLongList + futIds + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + long + futId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + writeVer + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + int + taskNameHash + + + java.util.UUID + nearNodeId + + + long + nearFutId + + + byte + flags + + + java.util.List<org.apache.ignite.internal.processors.cache.KeyCacheObject> + keys + + + java.util.List<org.apache.ignite.internal.processors.cache.CacheObject> + vals + + + java.util.List<org.apache.ignite.internal.processors.cache.CacheObject> + prevVals + + + java.util.List<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + conflictVers + + + org.apache.ignite.internal.util.GridLongList + ttls + + + org.apache.ignite.internal.util.GridLongList + conflictExpireTimes + + + org.apache.ignite.internal.util.GridLongList + nearTtls + + + org.apache.ignite.internal.util.GridLongList + nearExpireTimes + + + java.util.List<org.apache.ignite.internal.processors.cache.KeyCacheObject> + nearKeys + + + java.util.List<org.apache.ignite.internal.processors.cache.CacheObject> + nearVals + + + java.util.List<java.lang.Integer> + obsoleteIndexes + + + org.apache.ignite.internal.util.GridLongList + updateCntrs + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + long + futId + + + org.apache.ignite.internal.processors.cache.distributed.dht.atomic.UpdateErrors + errs + + + java.util.List<org.apache.ignite.internal.processors.cache.KeyCacheObject> + nearEvicted + + + int + partId + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + long + futId + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + org.apache.ignite.internal.processors.cache.GridCacheOperation + op + + + org.apache.ignite.cache.CacheWriteSynchronizationMode + syncMode + + + int + taskNameHash + + + short + flags + + + java.util.List<org.apache.ignite.internal.processors.cache.KeyCacheObject> + keys + + + java.util.List<org.apache.ignite.internal.processors.cache.CacheObject> + vals + + + java.util.List<byte[]> + entryProcessorsBytes + + + java.util.List<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + conflictVers + + + org.apache.ignite.internal.util.GridLongList + conflictTtls + + + org.apache.ignite.internal.util.GridLongList + conflictExpireTimes + + + java.util.List<byte[]> + invokeArgsBytes + + + byte[] + expiryPlcBytes + + + org.apache.ignite.internal.processors.cache.CacheEntryPredicate[] + filter + + + + + + value=entryProcessorsBytes + + java.util.List<java.lang.Object> + entryProcessors + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + long + futId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + writeVer + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + int + taskNameHash + + + java.util.UUID + nearNodeId + + + long + nearFutId + + + byte + flags + + + org.apache.ignite.internal.processors.cache.KeyCacheObject + key + + + org.apache.ignite.internal.processors.cache.CacheObject + val + + + org.apache.ignite.internal.processors.cache.CacheObject + prevVal + + + long + updateCntr + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + long + futId + + + org.apache.ignite.internal.processors.cache.distributed.dht.atomic.UpdateErrors + errs + + + org.apache.ignite.internal.processors.cache.GridCacheReturn + ret + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + remapTopVer + + + org.apache.ignite.internal.processors.cache.distributed.dht.atomic.NearCacheUpdates + nearUpdates + + + int + partId + + + java.util.List<java.util.UUID> + mapping + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + long + futId + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + org.apache.ignite.internal.processors.cache.GridCacheOperation + op + + + org.apache.ignite.cache.CacheWriteSynchronizationMode + syncMode + + + int + taskNameHash + + + short + flags + + + org.apache.ignite.internal.processors.cache.KeyCacheObject + key + + + org.apache.ignite.internal.processors.cache.CacheObject + val + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + long + futId + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + org.apache.ignite.internal.processors.cache.GridCacheOperation + op + + + org.apache.ignite.cache.CacheWriteSynchronizationMode + syncMode + + + int + taskNameHash + + + short + flags + + + org.apache.ignite.internal.processors.cache.KeyCacheObject + key + + + org.apache.ignite.internal.processors.cache.CacheObject + val + + + java.util.List<byte[]> + invokeArgsBytes + + + byte[] + entryProcBytes + + + + + + value=entryProcBytes + + javax.cache.processor.EntryProcessor<java.lang.Object,java.lang.Object,java.lang.Object> + entryProc + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + long + futId + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + org.apache.ignite.internal.processors.cache.GridCacheOperation + op + + + org.apache.ignite.cache.CacheWriteSynchronizationMode + syncMode + + + int + taskNameHash + + + short + flags + + + org.apache.ignite.internal.processors.cache.KeyCacheObject + key + + + org.apache.ignite.internal.processors.cache.CacheObject + val + + + org.apache.ignite.internal.processors.cache.CacheEntryPredicate[] + filter + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + int + partId + + + long + futId + + + + + + + java.util.List<java.lang.Integer> + nearValsIdxs + + + java.util.List<java.lang.Integer> + nearSkipIdxs + + + java.util.List<org.apache.ignite.internal.processors.cache.CacheObject> + nearVals + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + nearVer + + + org.apache.ignite.internal.util.GridLongList + nearTtls + + + org.apache.ignite.internal.util.GridLongList + nearExpireTimes + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.lang.IgniteUuid + futId + + + org.apache.ignite.lang.IgniteUuid + miniId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.KeyCacheObject> + keys + + + java.util.Collection<java.lang.Boolean> + readersFlags + + + byte + flags + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + int + taskNameHash + + + long + createTtl + + + long + accessTtl + + + java.lang.String + txLbl + + + + + + keys=keys values=readersFlags + + java.util.Map<org.apache.ignite.internal.processors.cache.KeyCacheObject,java.lang.Boolean> + keyMap + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.lang.IgniteUuid + futId + + + org.apache.ignite.lang.IgniteUuid + miniId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + java.util.Collection<org.apache.ignite.internal.processors.cache.GridCacheEntryInfo> + entries + + + java.util.Collection<java.lang.Integer> + invalidParts + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + long + futId + + + org.apache.ignite.internal.processors.cache.KeyCacheObject + key + + + byte + flags + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + int + taskNameHash + + + long + createTtl + + + long + accessTtl + + + java.lang.String + txLbl + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + long + futId + + + org.apache.ignite.plugin.extensions.communication.Message + res + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + byte + flags + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + int + partId + + + long + futId + + + java.util.UUID + primaryId + + + byte + flags + + + org.apache.ignite.internal.processors.cache.distributed.dht.atomic.UpdateErrors + errs + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + java.util.List<org.apache.ignite.internal.processors.cache.KeyCacheObject> + keys + + + java.util.List<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + vers + + + java.util.List<org.apache.ignite.internal.processors.cache.KeyCacheObject> + nearKeys + + + java.util.List<org.apache.ignite.internal.processors.cache.version.GridCacheVersion> + nearVers + + + long + ttl + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + + + + + org.apache.ignite.internal.processors.cache.CacheObject + cacheObj + + + java.util.Collection<org.apache.ignite.internal.processors.cache.CacheInvokeDirectResult> + invokeResCol + + + boolean + success + + + boolean + invokeRes + + + int + cacheId + + + + + + + org.apache.ignite.internal.processors.cache.KeyCacheObject + key + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.CacheObject + val + + + long + ttl + + + long + expireTimeDelta + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + + + + + org.apache.ignite.internal.processors.cache.KeyCacheObject + key + + + org.apache.ignite.internal.processors.cache.CacheObject + res + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + + + + + org.apache.ignite.internal.processors.cache.KeyCacheObject + key + + + org.apache.ignite.internal.processors.cache.CacheObject + val + + + long + ttl + + + long + expireTime + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + + + + + org.apache.ignite.internal.processors.cache.KeyCacheObject + key + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + boolean + near + + + + + + + org.apache.ignite.internal.processors.cache.CacheEntryPredicateType + type + + + org.apache.ignite.internal.processors.cache.CacheObject + val + + + + + + + org.apache.ignite.internal.processors.continuous.GridContinuousMessageType + type + + + java.util.UUID + routineId + + + java.util.Collection<org.apache.ignite.plugin.extensions.communication.Message> + msgs + + + byte[] + dataBytes + + + org.apache.ignite.lang.IgniteUuid + futId + + + + + + + java.util.UUID + routineId + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + org.apache.ignite.internal.processors.cache.distributed.dht.preloader.CachePartitionPartialCountersMap + cntrsMap + + + + + + + java.util.List<org.apache.ignite.internal.processors.cache.KeyCacheObject> + failedKeys + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + + + + + java.lang.String + latchId + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + boolean + isFinal + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + org.apache.ignite.internal.processors.cache.distributed.dht.atomic.GridNearAtomicAbstractUpdateRequest + payload + + + java.util.Map<java.lang.String,java.lang.String> + appAttrs + + + + + + + byte[] + nodeFilterBytes + + + java.lang.String + clsName + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.continuous.GridContinuousHandler + hnd + + + int + bufSize + + + long + interval + + + boolean + autoUnsubscribe + + + boolean + keepBinary + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + routineId + + + java.util.Map<java.util.UUID,org.apache.ignite.internal.util.ErrorMessage> + errs + + + java.util.Map<java.lang.Integer,java.lang.Long> + updateCntrs + + + java.util.Map<java.util.UUID,java.util.Map<java.lang.Integer,java.lang.Long>> + updateCntrsPerNode + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + routineId + + + org.apache.ignite.internal.processors.continuous.StartRequestData + startReqData + + + java.util.Map<java.util.UUID,org.apache.ignite.internal.util.ErrorMessage> + errs + + + java.util.Map<java.lang.Integer,java.lang.Long> + updateCntrs + + + java.util.Map<java.util.UUID,java.util.Map<java.lang.Integer,java.lang.Long>> + updateCntrsPerNode + + + org.apache.ignite.internal.processors.continuous.StartRoutineDiscoveryMessage.Mode + mode + + + + + + + + + + byte[] + ccfgBytes + + + byte[] + qryEntitiesBytes + + + boolean + sql + + + org.apache.ignite.internal.processors.cache.CacheConfigurationEnrichment + cacheConfigurationEnrichment + + + org.apache.ignite.internal.managers.encryption.GroupKeyEncrypted + grpKeyEncrypted + + + + + + value=qryEntitiesBytes + + java.util.Collection<org.apache.ignite.cache.QueryEntity> + qryEntities + + + + value=ccfgBytes + + org.apache.ignite.configuration.CacheConfiguration<?,?> + ccfg + + + + + + + java.util.Map<java.lang.String,org.apache.ignite.internal.processors.cache.CacheData> + caches + + + java.util.Map<java.lang.String,org.apache.ignite.internal.processors.cache.CacheData> + templates + + + java.util.Map<java.lang.Integer,org.apache.ignite.internal.processors.cache.CacheGroupData> + cacheGrps + + + java.util.Map<java.lang.String,java.util.Map<java.util.UUID,java.lang.Boolean>> + clientNodesMap + + + org.apache.ignite.internal.processors.cache.ClusterCacheGroupRecoveryData + clusterCacheGrpRecoveryData + + + + + + + byte[] + cacheCfgBytes + + + int + grpId + + + org.apache.ignite.internal.processors.cache.CacheType + cacheType + + + org.apache.ignite.lang.IgniteUuid + deploymentId + + + java.util.Collection<org.apache.ignite.internal.processors.query.schema.message.QueryEntityMessage> + entitiesMsgs + + + java.util.UUID + rcvdFrom + + + boolean + staticCfg + + + boolean + sql + + + org.apache.ignite.internal.processors.cache.CacheConfigurationEnrichment + cacheCfgEnrichment + + + + + + value=cacheCfgBytes + + org.apache.ignite.configuration.CacheConfiguration + cacheCfg + + + + + + + int + grpId + + + java.lang.String + grpName + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + startTopVer + + + java.util.UUID + rcvdFrom + + + org.apache.ignite.lang.IgniteUuid + deploymentId + + + byte[] + cacheCfgBytes + + + java.util.Map<java.lang.String,java.lang.Integer> + caches + + + boolean + persistenceEnabled + + + boolean + walEnabled + + + java.util.List<org.apache.ignite.internal.processors.cache.WalStateProposeMessage> + walChangeReqs + + + org.apache.ignite.internal.processors.cache.CacheConfigurationEnrichment + cacheCfgEnrichment + + + + + + value=cacheCfgBytes + + org.apache.ignite.configuration.CacheConfiguration<?,?> + cacheCfg + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + grpId + + + byte + flags + + + long + futId + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + grpId + + + long + futId + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + java.util.List<java.util.List<java.util.UUID>> + affAssignmentIds + + + java.util.List<java.util.List<java.util.UUID>> + idealAffAssignment + + + + + + org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionFullMap + partMap + + + org.apache.ignite.internal.util.ErrorMessage + affAssignmentErrMsg + + + + + + + java.util.List<org.apache.ignite.internal.util.GridLongList> + assigns + + + java.util.List<org.apache.ignite.internal.util.GridLongList> + idealAssigns + + + java.util.Map<java.lang.Integer,org.apache.ignite.internal.util.GridLongList> + assignsDiff + + + + + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + + + + + int + cacheId + + + byte[] + data + + + int + size + + + + + + + int[] + partIds + + + long[] + initialUpdCntrs + + + long[] + updCntrs + + + int + curIdx + + + + + + + org.apache.ignite.internal.processors.cache.distributed.dht.preloader.CachePartitionPartialCountersMap + historical + + + java.util.Set<java.lang.Integer> + full + + + + + + + long[] + initUpdCntrs + + + long[] + updCntrs + + + + + + + int + grpId + + + int + partId + + + + + + + java.util.BitSet + states + + + int + size + + + + + + + java.util.UUID + nodeId + + + long + updateSeq + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + top + + + org.apache.ignite.internal.util.GridPartitionStateMap + map + + + int + moving + + + + + + + java.util.UUID + nodeId + + + long + nodeOrder + + + long + updateSeq + + + java.util.Map<java.util.UUID,org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionMap> + map + + + + + + + java.util.UUID + nodeId + + + int + evt + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + + + + + org.apache.ignite.lang.IgniteUuid + sesId + + + java.lang.String + key + + + java.lang.String + cpSpi + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + grpId + + + long + rebalanceId + + + org.apache.ignite.internal.processors.cache.distributed.dht.preloader.IgniteDhtDemandedPartitionsMap + parts + + + long + timeout + + + int + workerId + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + grpId + + + long + rebalanceId + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + java.util.Map<java.lang.Integer,java.lang.Long> + last + + + java.util.Collection<java.lang.Integer> + missed + + + java.util.Map<java.lang.Integer,java.util.List<org.apache.ignite.internal.processors.cache.GridCacheEntryInfo>> + infos + + + int + msgSize + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionExchangeId + exchId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + lastVer + + + byte + flags + + + + + + java.util.Map<java.lang.Integer,org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionFullMap> + locParts + + + java.util.Map<java.lang.Integer,java.lang.Integer> + dupPartsData + + + + + + java.util.Map<java.lang.Integer,org.apache.ignite.internal.processors.cache.distributed.dht.preloader.CachePartitionFullCountersMap> + partCntrs + + + + + + java.util.Map<java.util.UUID,java.util.Map<org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GroupPartitionIdPair,java.lang.Long>> + partHistSuppliers + + + + + + java.util.Map<java.util.UUID,java.util.Map<java.lang.Integer,java.util.Set<java.lang.Integer>>> + partsToReload + + + java.util.Map<java.lang.Integer,java.util.Map<java.lang.Integer,java.lang.Long>> + partsSizes + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + + + + java.util.Map<java.util.UUID,org.apache.ignite.internal.util.ErrorMessage> + errMsgs + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + resTopVer + + + java.util.Map<java.lang.Integer,org.apache.ignite.internal.processors.cache.distributed.dht.preloader.CacheGroupAffinityMessage> + joinedNodeAff + + + java.util.Map<java.lang.Integer,org.apache.ignite.internal.processors.cache.distributed.dht.preloader.CacheGroupAffinityMessage> + idealAffDiff + + + byte + flags + + + java.util.Map<java.lang.Integer,int[]> + lostParts + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionExchangeId + exchId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + lastVer + + + byte + flags + + + + + + java.util.Map<java.lang.Integer,org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionMap> + parts + + + java.util.Map<java.lang.Integer,java.lang.Integer> + dupPartsData + + + + + + java.util.Map<java.lang.Integer,org.apache.ignite.internal.processors.cache.distributed.dht.preloader.CachePartitionPartialCountersMap> + partCntrs + + + + + + java.util.Map<java.lang.Integer,java.util.Map<java.lang.Integer,java.lang.Long>> + partsSizes + + + + + + java.util.Map<java.lang.Integer,java.util.Map<java.lang.Integer,java.lang.Long>> + partHistCntrs + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + boolean + client + + + java.util.Collection<java.lang.Integer> + grpsAffReq + + + long + exchangeStartTime + + + org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionsFullMessage + finishMsg + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionExchangeId + exchId + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + lastVer + + + byte + flags + + + org.apache.ignite.internal.processors.cache.distributed.dht.preloader.GridDhtPartitionExchangeId + restoreExchId + + + + + + + int + grpId + + + java.lang.String + grpName + + + int + partId + + + + + + + java.util.UUID + opId + + + java.lang.String + cacheName + + + java.lang.String + schemaName + + + java.lang.String + tblName + + + java.util.List<org.apache.ignite.internal.processors.query.QueryField> + cols + + + boolean + ifTblExists + + + boolean + ifNotExists + + + + + + + java.util.UUID + opId + + + java.lang.String + cacheName + + + java.lang.String + schemaName + + + java.lang.String + tblName + + + org.apache.ignite.internal.cache.query.QueryIndexMessage + idxMsg + + + boolean + ifNotExists + + + int + parallel + + + + + + + java.util.UUID + opId + + + java.lang.String + cacheName + + + java.lang.String + schemaName + + + java.lang.String + idxName + + + boolean + ifExists + + + + + + + java.util.UUID + opId + + + java.lang.String + cacheName + + + java.lang.String + schemaName + + + java.lang.String + tblName + + + java.util.List<java.lang.String> + cols + + + boolean + ifTblExists + + + boolean + ifExists + + + + + + + java.util.UUID + opId + + + java.lang.String + cacheName + + + java.lang.String + schemaName + + + java.util.Collection<org.apache.ignite.internal.processors.query.schema.message.QueryEntityMessage> + entitiesMsgs + + + int + qryParallelism + + + boolean + sqlEscape + + + + + + + java.util.UUID + opId + + + int + errCode + + + java.lang.String + errMsg + + + boolean + nop + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + org.apache.ignite.internal.processors.query.schema.operation.SchemaAbstractOperation + op + + + java.lang.String + errMsg + + + int + errCode + + + org.apache.ignite.lang.IgniteUuid + depId + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + org.apache.ignite.internal.processors.query.schema.operation.SchemaAbstractOperation + op + + + java.lang.String + errMsg + + + int + errCode + + + boolean + nop + + + + + + + java.lang.String + name + + + java.lang.String + alias + + + java.lang.String + typeName + + + boolean + nullable + + + int + precision + + + int + scale + + + + + + + java.lang.String + name + + + java.util.LinkedHashMap<java.lang.String,java.lang.Boolean> + fields + + + org.apache.ignite.cache.QueryIndexType + type + + + int + inlineSize + + + + + + + java.lang.String + qry + + + int[] + paramIdxs + + + java.util.UUID + node + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + long + id + + + java.lang.String + cacheName + + + org.apache.ignite.internal.processors.cache.query.GridCacheQueryType + type + + + java.lang.String + clause + + + byte[] + idxQryDescBytes + + + int + limit + + + java.lang.String + clsName + + + byte[] + keyValFilterBytes + + + byte[] + rdcBytes + + + byte[] + transBytes + + + byte[] + argsBytes + + + int + pageSize + + + boolean + incBackups + + + boolean + cancel + + + boolean + incMeta + + + boolean + all + + + boolean + keepBinary + + + int + taskHash + + + int + part + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + java.util.Collection<org.apache.ignite.internal.processors.cache.KeyCacheObject> + skipKeys + + + byte + flags + + + + + + value=argsBytes + + java.lang.Object[] + args + + + + value=idxQryDescBytes + + org.apache.ignite.internal.processors.cache.query.IndexQueryDesc + idxQryDesc + + + + value=keyValFilterBytes + + org.apache.ignite.lang.IgniteBiPredicate<java.lang.Object,java.lang.Object> + keyValFilter + + + + value=transBytes + + org.apache.ignite.lang.IgniteClosure<?,?> + trans + + + + value=rdcBytes + + org.apache.ignite.lang.IgniteReducer<java.lang.Object,java.lang.Object> + rdc + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + boolean + finished + + + long + reqId + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + boolean + fields + + + org.apache.ignite.internal.cache.query.index.IndexQueryResultMeta + idxQryMetadata + + + java.util.Collection<byte[]> + dataBytes + + + + + + value=dataBytes + + java.util.Collection<java.lang.Object> + data + + + + + + + long + qryReqId + + + + + + + long + qryReqId + + + java.lang.String + errMsg + + + byte + failCode + + + + + + + long + qryReqId + + + int + segmentId + + + int + qry + + + int + pageSize + + + byte + flags + + + + + + + long + qryReqId + + + int + segmentId + + + int + qry + + + int + page + + + int + allRows + + + int + cols + + + java.util.Collection<org.apache.ignite.plugin.extensions.communication.Message> + vals + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + retry + + + java.lang.String + retryCause + + + boolean + last + + + + + + + long + reqId + + + long + nodeQryId + + + boolean + asyncRes + + + + + + + java.lang.String + errMsg + + + long + reqId + + + + + + + org.apache.ignite.internal.cache.query.index.sorted.IndexKeyType + idxType + + + boolean + asc + + + int + precision + + + + + + + boolean + inlineObjHash + + + boolean + inlineObjSupported + + + boolean + strOptimizedCompare + + + boolean + binaryUnsigned + + + + + + + org.apache.ignite.internal.cache.query.index.sorted.IndexKeyTypeSettings + keyTypeSettings + + + java.util.LinkedHashMap<java.lang.String,org.apache.ignite.internal.cache.query.index.sorted.IndexKeyDefinition> + keyDefs + + + + + + + java.lang.String + schema + + + java.lang.String + obj + + + java.util.List<java.lang.String> + colNames + + + + + + + int + scale + + + byte[] + b + + + + + + + org.apache.ignite.internal.processors.query.stat.messages.StatisticsKeyMessage + key + + + long + rowsCnt + + + org.apache.ignite.internal.processors.query.stat.StatisticsType + type + + + int + partId + + + long + updCnt + + + java.util.Map<java.lang.String,org.apache.ignite.internal.processors.query.stat.messages.StatisticsColumnData> + data + + + + + + + org.apache.ignite.internal.processors.query.stat.messages.StatisticsDecimalMessage + min + + + org.apache.ignite.internal.processors.query.stat.messages.StatisticsDecimalMessage + max + + + long + nulls + + + long + distinct + + + long + total + + + int + size + + + byte[] + rawData + + + long + ver + + + long + createdAt + + + + + + + java.util.UUID + reqId + + + org.apache.ignite.internal.processors.query.stat.messages.StatisticsKeyMessage + key + + + org.apache.ignite.internal.processors.query.stat.StatisticsType + type + + + java.util.Map<java.lang.String,java.lang.Long> + versions + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + + + + + java.util.UUID + reqId + + + org.apache.ignite.internal.processors.query.stat.messages.StatisticsObjectData + data + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + int + cacheId + + + java.util.UUID + routineId + + + java.util.Map<java.lang.Integer,java.lang.Long> + updateCntrs + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + org.apache.ignite.internal.processors.cache.version.GridCacheVersion + ver + + + + + + + javax.cache.event.EventType + evtType + + + byte + flags + + + org.apache.ignite.internal.processors.cache.KeyCacheObject + key + + + org.apache.ignite.internal.processors.cache.CacheObject + newVal + + + org.apache.ignite.internal.processors.cache.CacheObject + oldVal + + + int + cacheId + + + int + part + + + long + updateCntr + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + long + filteredCnt + + + + + + + java.util.Map<java.lang.String,java.lang.Integer> + sizes + + + + + + + java.util.LinkedHashMap<java.util.UUID,org.apache.ignite.internal.processors.query.schema.message.SchemaProposeDiscoveryMessage> + activeProposals + + + + + + + java.lang.String + keyType + + + java.lang.String + valType + + + java.lang.String + keyFieldName + + + java.lang.String + valFieldName + + + java.util.LinkedHashMap<java.lang.String,java.lang.String> + fields + + + java.lang.String[] + keyFields + + + java.util.Map<java.lang.String,java.lang.String> + aliases + + + java.util.Collection<org.apache.ignite.internal.cache.query.QueryIndexMessage> + idxs + + + java.lang.String + tableName + + + java.util.Set<java.lang.String> + notNullFields + + + byte[] + dfltFieldValuesBytes + + + java.util.Map<java.lang.String,java.lang.Integer> + fieldsPrecision + + + java.util.Map<java.lang.String,java.lang.Integer> + fieldsScale + + + + + + value=dfltFieldValuesBytes + + java.util.Map<java.lang.String,java.lang.Object> + dfltFieldValues + + + + + + + java.lang.String + keyType + + + java.lang.String + valType + + + java.lang.String + keyFieldName + + + java.lang.String + valFieldName + + + java.util.LinkedHashMap<java.lang.String,java.lang.String> + fields + + + java.lang.String[] + keyFields + + + java.util.Map<java.lang.String,java.lang.String> + aliases + + + java.util.Collection<org.apache.ignite.internal.cache.query.QueryIndexMessage> + idxs + + + java.lang.String + tableName + + + java.util.Set<java.lang.String> + notNullFields + + + byte[] + dfltFieldValuesBytes + + + java.util.Map<java.lang.String,java.lang.Integer> + fieldsPrecision + + + java.util.Map<java.lang.String,java.lang.Integer> + fieldsScale + + + boolean + preserveKeysOrder + + + boolean + implicitPk + + + boolean + fillAbsentPKsWithDefaults + + + int + pkInlineSize + + + int + affKeyInlineSize + + + boolean + sql + + + + + + value=dfltFieldValuesBytes + + java.util.Map<java.lang.String,java.lang.Object> + dfltFieldValues + + + + + + + java.util.UUID + srcNodeId + + + java.util.UUID + routineId + + + org.apache.ignite.internal.processors.continuous.GridContinuousHandler + hnd + + + byte[] + nodeFilter + + + int + bufSize + + + long + interval + + + boolean + autoUnsubscribe + + + + + + + java.util.List<org.apache.ignite.internal.processors.continuous.ContinuousRoutineInfo> + startedRoutines + + + + + + + byte[] + bytes + + + java.lang.String + clsName + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + + + + + java.lang.String + cacheName + + + byte[] + topicBytes + + + org.apache.ignite.internal.processors.cache.query.continuous.CacheContinuousQueryDeployableObject + rmtFilterDep + + + byte[] + rmtFilterBytes + + + org.apache.ignite.internal.processors.cache.query.continuous.CacheContinuousQueryDeployableObject + rmtFilterFactoryDep + + + byte[] + rmtFilterFactoryBytes + + + byte + types + + + org.apache.ignite.internal.processors.cache.query.continuous.CacheContinuousQueryDeployableObject + rmtTransFactoryDep + + + byte[] + rmtTransFactoryBytes + + + boolean + internal + + + boolean + notifyExisting + + + boolean + oldValRequired + + + boolean + sync + + + boolean + ignoreExpired + + + int + taskHash + + + boolean + keepBinary + + + + + + value=topicBytes + + java.lang.Object + topic + + + + + + + byte[] + filterBytes + + + java.lang.String + clsName + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + int[] + types + + + + + + + byte[] + topicBytes + + + byte[] + predBytes + + + java.lang.String + clsName + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + predDepInfo + + + + + + + java.util.UUID + nodeId + + + byte[] + prjPredBytes + + + org.apache.ignite.internal.processors.continuous.GridContinuousHandler + hnd + + + int + bufSize + + + long + interval + + + boolean + autoUnsubscribe + + + + + + value=prjPredBytes + + org.apache.ignite.lang.IgnitePredicate<org.apache.ignite.cluster.ClusterNode> + prjPred + + + + + + + java.util.UUID + routineId + + + byte[] + prjPredBytes + + + org.apache.ignite.internal.processors.continuous.GridContinuousHandler + hnd + + + int + bufSize + + + long + interval + + + boolean + autoUnsubscribe + + + + + + value=prjPredBytes + + org.apache.ignite.lang.IgnitePredicate<org.apache.ignite.cluster.ClusterNode> + prjPred + + + + + + + java.util.UUID + nodeId + + + java.util.Collection<org.apache.ignite.internal.processors.continuous.ContinousRoutineDiscoveryDataItem> + items + + + java.util.Map<java.util.UUID,java.util.Map<java.util.UUID,org.apache.ignite.internal.processors.continuous.ContinousRoutineLocalInfo>> + clientInfos + + + + + + + java.util.List<org.apache.ignite.internal.processors.continuous.ContinuousRoutineInfo> + startedRoutines + + + + + + + org.apache.ignite.lang.IgniteUuid + sessionId + + + org.apache.ignite.lang.IgniteUuid + jobId + + + boolean + system + + + + + + + org.apache.ignite.lang.IgniteUuid + sesId + + + org.apache.ignite.lang.IgniteUuid + jobId + + + byte[] + jobBytes + + + long + startTaskTime + + + long + timeout + + + java.lang.String + taskName + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + java.lang.String + taskClsName + + + byte[] + sesAttrsBytes + + + byte[] + jobAttrsBytes + + + java.lang.String + cpSpi + + + org.apache.ignite.lang.IgniteUuid[] + siblingJobsIds + + + boolean + forceLocDep + + + boolean + sesFullSup + + + boolean + internal + + + java.util.Collection<java.util.UUID> + top + + + byte[] + topPredBytes + + + int[] + cacheIds + + + int + part + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + java.lang.String + execName + + + + + + value=jobAttrsBytes + + java.util.Map<? extends java.io.Serializable,? extends java.io.Serializable> + jobAttrs + + + + value=sesAttrsBytes + + java.util.Map<java.lang.Object,java.lang.Object> + sesAttrs + + + + value=jobBytes + + org.apache.ignite.compute.ComputeJob + job + + + + value=topPredBytes + + org.apache.ignite.lang.IgnitePredicate<org.apache.ignite.cluster.ClusterNode> + topPred + + + + + + + java.util.UUID + nodeId + + + org.apache.ignite.lang.IgniteUuid + sesId + + + org.apache.ignite.lang.IgniteUuid + jobId + + + byte[] + gridExBytes + + + byte[] + resBytes + + + byte[] + jobAttrsBytes + + + boolean + isCancelled + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + retry + + + + + + value=resBytes + + java.lang.Object + res + + + + value=jobAttrsBytes + + java.util.Map<java.lang.Object,java.lang.Object> + jobAttrs + + + + value=gridExBytes + + org.apache.ignite.IgniteException + gridEx + + + + + + + org.apache.ignite.lang.IgniteUuid + sesId + + + long + topicId + + + + + + + org.apache.ignite.lang.IgniteUuid[] + siblingJobsIds + + + + + + + org.apache.ignite.lang.IgniteUuid + sesId + + + + + + + org.apache.ignite.lang.IgniteUuid + sesId + + + org.apache.ignite.lang.IgniteUuid + jobId + + + byte[] + attrsBytes + + + + + + + org.apache.ignite.lang.IgniteUuid + taskId + + + long + topicId + + + + + + + byte[] + resBytes + + + boolean + finished + + + boolean + found + + + java.lang.String + err + + + + + + value=resBytes + + java.lang.Object + res + + + + + + + int + delta + + + + + + + + + + java.util.UUID + processId + + + int + type + + + org.apache.ignite.plugin.extensions.communication.Message + resp + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + + + + + java.util.UUID + nodeId + + + + + + + java.util.UUID + nodeId + + + long + rcvCnt + + + long + connectCnt + + + int + connIdx + + + + + + + + + byte + plc + + + + + + org.apache.ignite.internal.GridTopicMessage + topicMsg + + + boolean + ordered + + + long + timeout + + + boolean + skipOnTimeout + + + org.apache.ignite.plugin.extensions.communication.Message + msg + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + + + + + long + id + + + boolean + processInNioThread + + + boolean + req + + + byte[] + payload + + + long + reqSndTsMillis + + + long + reqRcvTsMillis + + + long + resSndTsMillis + + + long + resRcvTsMillis + + + + + + + byte[] + bodyBytes + + + byte[] + topicBytes + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + java.lang.String + depClsName + + + + + + + long + rcvCnt + + + + + + + int + connIdx + + + + + + + org.apache.ignite.lang.IgniteUuid + sesId + + + + + + + boolean + streamerWarning + + + + + + + org.apache.ignite.internal.processors.cache.KeyCacheObject + key + + + org.apache.ignite.internal.processors.cache.CacheObject + val + + + + + + + long + reqId + + + org.apache.ignite.lang.IgniteUuid + resTopicId + + + java.lang.String + cacheName + + + org.apache.ignite.internal.processors.datastreamer.DataStreamerReceiverMessage + updaterMsg + + + java.util.Collection<org.apache.ignite.internal.processors.datastreamer.DataStreamerEntry> + entries + + + boolean + ignoreDepOwnership + + + boolean + skipStore + + + boolean + keepBinary + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + java.lang.String + sampleClsName + + + boolean + forceLocDep + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + topVer + + + int + partId + + + + + + + long + reqId + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + + + + + byte[] + rcvrBytes + + + org.apache.ignite.internal.processors.datastreamer.DataStreamerBuiltInUpdater + builtIn + + + + + + value=rcvrBytes + + org.apache.ignite.stream.StreamReceiver<?,?> + rcvr + + + + + + + long + cacheGets + + + long + cachePuts + + + long + entryProcessorPuts + + + long + entryProcessorReadOnlyInvocations + + + float + entryProcessorAverageInvocationTime + + + long + entryProcessorInvocations + + + long + entryProcessorRemovals + + + long + entryProcessorMisses + + + long + entryProcessorHits + + + float + entryProcessorMissPercentage + + + float + entryProcessorHitPercentage + + + float + entryProcessorMaxInvocationTime + + + float + entryProcessorMinInvocationTime + + + long + cacheHits + + + long + cacheMisses + + + long + cacheTxCommits + + + long + cacheTxRollbacks + + + long + cacheEvictions + + + long + cacheRemovals + + + float + averagePutTime + + + float + averageGetTime + + + float + averageRemoveTime + + + float + averageTxCommitTime + + + float + averageTxRollbackTime + + + java.lang.String + cacheName + + + long + offHeapGets + + + long + offHeapPuts + + + long + offHeapRemoves + + + long + offHeapEvicts + + + long + offHeapHits + + + long + offHeapMisses + + + long + offHeapEntriesCnt + + + long + heapEntriesCnt + + + long + offHeapPrimaryEntriesCnt + + + long + offHeapBackupEntriesCnt + + + long + offHeapAllocatedSize + + + int + size + + + long + cacheSize + + + int + keySize + + + boolean + empty + + + int + dhtEvictQueueCurrSize + + + int + txThreadMapSize + + + int + txXidMapSize + + + int + txCommitQueueSize + + + int + txPrepareQueueSize + + + int + txStartVerCountsSize + + + int + txCommittedVersionsSize + + + int + txRolledbackVersionsSize + + + int + txDhtThreadMapSize + + + int + txDhtXidMapSize + + + int + txDhtCommitQueueSize + + + int + txDhtPrepareQueueSize + + + int + txDhtStartVerCountsSize + + + int + txDhtCommittedVersionsSize + + + int + txDhtRolledbackVersionsSize + + + boolean + writeBehindEnabled + + + int + writeBehindFlushSize + + + int + writeBehindFlushThreadCnt + + + long + writeBehindFlushFreq + + + int + writeBehindStoreBatchSize + + + int + writeBehindTotalCriticalOverflowCnt + + + int + writeBehindCriticalOverflowCnt + + + int + writeBehindErrorRetryCnt + + + int + writeBehindBufSize + + + int + totalPartitionsCnt + + + int + rebalancingPartitionsCnt + + + long + rebalancedKeys + + + long + estimatedRebalancingKeys + + + long + keysToRebalanceLeft + + + long + rebalancingKeysRate + + + long + rebalancingBytesRate + + + long + rebalanceStartTime + + + long + rebalanceFinishTime + + + long + rebalanceClearingPartitionsLeft + + + java.lang.String + keyType + + + java.lang.String + valType + + + boolean + storeByVal + + + boolean + statisticsEnabled + + + boolean + managementEnabled + + + boolean + readThrough + + + boolean + writeThrough + + + boolean + validForReading + + + boolean + validForWriting + + + java.lang.String + txKeyCollisions + + + boolean + idxRebuildInProgress + + + long + idxRebuildKeyProcessed + + + int + idxBuildPartitionsLeftCount + + + + + + + int + maxActiveJobs + + + int + curActiveJobs + + + float + avgActiveJobs + + + int + maxWaitingJobs + + + int + curWaitingJobs + + + float + avgWaitingJobs + + + int + maxRejectedJobs + + + int + curRejectedJobs + + + float + avgRejectedJobs + + + int + maxCancelledJobs + + + int + curCancelledJobs + + + float + avgCancelledJobs + + + int + totalRejectedJobs + + + int + totalCancelledJobs + + + int + totalExecutedJobs + + + long + maxJobWaitTime + + + long + curJobWaitTime + + + double + avgJobWaitTime + + + long + maxJobExecTime + + + long + curJobExecTime + + + double + avgJobExecTime + + + int + totalExecTasks + + + long + totalIdleTime + + + long + curIdleTime + + + int + totalCpus + + + double + curCpuLoad + + + double + avgCpuLoad + + + double + curGcCpuLoad + + + long + heapInit + + + long + heapUsed + + + long + heapCommitted + + + long + heapMax + + + long + heapTotal + + + long + nonHeapInit + + + long + nonHeapUsed + + + long + nonHeapCommitted + + + long + nonHeapMax + + + long + nonHeapTotal + + + long + upTime + + + long + startTime + + + long + nodeStartTime + + + int + threadCnt + + + int + peakThreadCnt + + + long + startedThreadCnt + + + int + daemonThreadCnt + + + long + lastDataVer + + + int + sentMsgsCnt + + + long + sentBytesCnt + + + int + rcvdMsgsCnt + + + long + rcvdBytesCnt + + + int + outMesQueueSize + + + int + totalNodes + + + long + totalJobsExecTime + + + long + curPmeDuration + + + + + + + org.apache.ignite.internal.ClusterMetricsSnapshot + nodeMetricsMsg + + + java.util.Map<java.lang.Integer,org.apache.ignite.internal.processors.cluster.CacheMetricsMessage> + cachesMetricsMsgs + + + + + + + org.apache.ignite.internal.processors.cluster.NodeFullMetricsMessage + singleNodeMetricsMsg + + + java.util.Map<java.util.UUID,org.apache.ignite.internal.processors.cluster.NodeFullMetricsMessage> + allNodesMetrics + + + + + + + java.util.Map<java.util.UUID,org.apache.ignite.internal.ClusterMetricsSnapshot> + nodesMetricsMsgs + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + java.util.Map<java.util.UUID,org.apache.ignite.spi.discovery.tcp.messages.TcpDiscoveryClientNodesMetricsMessage> + connectedClientsMetricsMsgs + + + java.util.Map<java.util.UUID,org.apache.ignite.internal.processors.cluster.NodeFullMetricsMessage> + serversFullMetricsMsgs + + + java.util.Set<java.util.UUID> + clientNodeIds + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + org.apache.ignite.internal.ClusterMetricsSnapshot + metricsMsg + + + + + + + java.lang.String + name + + + java.lang.String + hashedPasswd + + + + + + + org.apache.ignite.internal.processors.authentication.User + usr + + + org.apache.ignite.internal.processors.authentication.UserManagementOperation.OperationType + type + + + org.apache.ignite.lang.IgniteUuid + id + + + + + + + org.apache.ignite.lang.IgniteUuid + opId + + + java.lang.String + errorMsg + + + + + + + java.lang.String + name + + + java.lang.String + passwd + + + org.apache.ignite.lang.IgniteUuid + id + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.lang.String + errMsg + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + verifierNodeId + + + long + topVer + + + int + flags + + + java.util.Set<java.util.UUID> + failedNodes + + + org.apache.ignite.internal.thread.context.OperationContextSnapshotMessage + opCtxSnp + + + org.apache.ignite.spi.discovery.tcp.messages.InetAddressMessage + creatorAddrMsg + + + java.util.UUID + targetNodeId + + + + + + + java.util.ArrayList<org.apache.ignite.internal.processors.authentication.User> + usrs + + + java.util.ArrayList<org.apache.ignite.internal.processors.authentication.UserManagementOperation> + activeOps + + + + + + + java.util.Map<java.lang.String,java.util.EnumSet<org.apache.ignite.plugin.security.SecurityPermission>> + cachePermissions + + + java.util.Map<java.lang.String,java.util.EnumSet<org.apache.ignite.plugin.security.SecurityPermission>> + taskPermissions + + + java.util.Map<java.lang.String,java.util.EnumSet<org.apache.ignite.plugin.security.SecurityPermission>> + srvcPermissions + + + java.util.EnumSet<org.apache.ignite.plugin.security.SecurityPermission> + sysPermissions + + + boolean + dfltAllowAll + + + + + + + org.apache.ignite.lang.IgniteUuid + clsLdrId + + + org.apache.ignite.configuration.DeploymentMode + depMode + + + java.lang.String + userVer + + + java.util.Map<java.util.UUID,org.apache.ignite.lang.IgniteUuid> + participants + + + + + + + org.apache.ignite.lang.IgniteUuid + resTopicId + + + java.lang.String + rsrcName + + + org.apache.ignite.lang.IgniteUuid + ldrId + + + java.util.Collection<java.util.UUID> + nodeIds + + + + + + + boolean + success + + + java.lang.String + errMsg + + + org.apache.ignite.internal.util.GridByteArrayList + byteSrc + + + + + + + byte + platformId + + + int + typeId + + + + + + + byte + platformId + + + int + typeId + + + java.lang.String + clsName + + + + + + + int + typeId + + + + + + + int + typeId + + + org.apache.ignite.internal.processors.cache.binary.BinaryMetadataVersionInfo + metaVerInfo + + + + + + + byte + platformId + + + int + typeId + + + java.lang.String + clsName + + + + + + + + + + byte[] + metadataBytes + + + int + pendingVer + + + int + acceptedVer + + + + + + value=metadataBytes + + org.apache.ignite.internal.binary.BinaryMetadata + metadata + + + + + + + java.util.Map<java.lang.Integer,org.apache.ignite.internal.processors.cache.binary.BinaryMetadataVersionInfo> + meta + + + + + + + java.lang.String + clsName + + + boolean + accepted + + + + + + + java.util.List<java.util.Map<java.lang.Integer,org.apache.ignite.internal.processors.marshaller.MappedName>> + mappings + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + int + keyCnt + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.Collection<byte[]> + encKeys + + + byte[] + masterKeyDigest + + + + + + + java.util.UUID + reqId + + + int[] + grpIds + + + byte[][] + keys + + + byte[] + keyIds + + + byte[] + masterKeyDigest + + + + + + + java.util.UUID + reqId + + + byte[] + encKeyName + + + byte[] + digest + + + + + + + int + id + + + byte[] + key + + + + + + + java.util.Map<java.lang.Integer,byte[]> + knownKeys + + + java.util.Map<java.lang.Integer,byte[]> + newKeys + + + byte[] + masterKeyDigest + + + java.util.Map<java.lang.Integer,java.util.List<org.apache.ignite.internal.managers.encryption.GroupKeyEncrypted>> + knownKeysWithIds + + + + + + + java.util.Map<java.lang.Integer,org.apache.ignite.internal.managers.encryption.GroupKeyEncrypted> + knownKeys + + + + + + + org.apache.ignite.lang.IgniteUuid + resTopicId + + + byte[] + filterBytes + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + java.lang.String + filterClsName + + + + + + value=filterBytes + + org.apache.ignite.lang.IgnitePredicate<?> + filter + + + + + + + byte[] + evtsBytes + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + + + + value=evtsBytes + + java.util.Collection<org.apache.ignite.events.Event> + evts + + + + + + + org.apache.ignite.lang.IgniteUuid + id + + + java.util.UUID + reqId + + + java.util.UUID + initiatingNodeId + + + org.apache.ignite.cluster.ClusterState + state + + + java.util.List<org.apache.ignite.internal.processors.cache.StoredCacheData> + storedCfgs + + + byte[] + baselineTopologyBytes + + + boolean + forceChangeBaselineTopology + + + boolean + forceDeactivation + + + + + + value=baselineTopologyBytes + + org.apache.ignite.internal.processors.cluster.BaselineTopology + baselineTopology + + + + + + + long + msgId + + + org.apache.ignite.internal.managers.deployment.GridDeploymentInfoMessage + depInfo + + + org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion + lastAffChangedTopVer + + + java.util.UUID + reqId + + + org.apache.ignite.internal.util.ErrorMessage + errMsg + + + + + + + long + futId + + + java.util.UUID + nodeId + + + java.util.Set<org.apache.ignite.internal.IgniteDiagnosticRequest.DiagnosticBaseInfo> + infos + + + + + + + long + futId + + + java.lang.String + respInfo + + + + + + + java.util.UUID + opId + + + boolean + affNode + + + boolean + changed + + + java.lang.String + errMsg + + + + + + + java.util.Map<java.lang.String,byte[]> + enrichFields + + + java.util.Map<java.lang.String,java.lang.String> + fieldClassNames + + + + + + + java.util.UUID + reqId + + + org.apache.ignite.lang.IgniteUuid + deploymentId + + + java.lang.String + cacheName + + + byte[] + cfgBytes + + + org.apache.ignite.internal.processors.cache.CacheType + cacheType + + + java.util.UUID + initiatingNodeId + + + byte[] + nearCfgBytes + + + boolean + clientStartOnly + + + boolean + stop + + + boolean + restart + + + boolean + finalizePartitionCounters + + + org.apache.ignite.lang.IgniteUuid + restartId + + + boolean + disabledAfterStart + + + boolean + destroy + + + boolean + sql + + + boolean + failIfExists + + + boolean + template + + + boolean + resetLostPartitions + + + byte[] + schemaBytes + + + byte[] + encKey + + + int + encKeyId + + + byte[] + masterKeyDigest + + + org.apache.ignite.internal.processors.cache.CacheConfigurationEnrichment + cacheCfgEnrichment + + + + + + value=cfgBytes + + org.apache.ignite.configuration.CacheConfiguration<?,?> + startCfg + + + + value=nearCfgBytes + + org.apache.ignite.configuration.NearCacheConfiguration<?,?> + nearCacheCfg + + + + value=schemaBytes + + org.apache.ignite.internal.processors.query.QuerySchema + schema + + + + + + + + + + org.apache.ignite.internal.management.cache.PartitionKey + partKey + + + boolean + isPrimary + + + byte[] + consistentIdBytes + + + int + partHash + + + int + partVerHash + + + byte[] + updateCntrBytes + + + long + size + + + org.apache.ignite.internal.processors.cache.verify.PartitionHashRecord.PartitionState + partitionState + + + int + cfKeys + + + int + noCfKeys + + + int + binKeys + + + int + regKeys + + + boolean + hasExpiringEntries + + + + + + value=consistentIdBytes + + java.lang.Object + consistentId + + + + value=updateCntrBytes + + java.lang.Object + updateCntr + + + + + + + + + + byte[] + locConsistentIdBytes + + + byte[] + rmtConsistentIdBytes + + + int + txHash + + + + + + value=locConsistentIdBytes + + java.lang.Object + locConsistentId + + + + value=rmtConsistentIdBytes + + java.lang.Object + rmtConsistentId + + + + + + + java.util.UUID + id + + + java.lang.String + tag + + + + + + + boolean + notifierEnabled + + + + + + + byte[] + dataBytes + + + + + + value=dataBytes + + java.util.Map<java.lang.String,java.io.Serializable> + data + + + + + + + int[] + enabledEvts + + + + + + + org.apache.ignite.internal.processors.cluster.DiscoveryDataClusterState + globalState + + + org.apache.ignite.internal.processors.cluster.BaselineTopologyHistory + recentHistory + + + + + + + java.util.List<org.apache.ignite.internal.processors.cluster.BaselineTopologyHistoryItem> + hist + + + + + + + int + id + + + java.util.List<java.lang.Long> + branchingHistory + + + + + + + org.apache.ignite.cluster.ClusterState + state + + + long + lastStateChangeTime + + + byte[] + baselineTopBytes + + + java.util.UUID + transitionReqId + + + org.apache.ignite.cluster.ClusterState + prevClusterState + + + java.util.Set<java.util.UUID> + transitionNodes + + + + + + value=baselineTopBytes + + org.apache.ignite.internal.processors.cluster.BaselineTopology + baselineTop + + + + + + + java.lang.String[] + keys + + + byte[][] + valBytes + + + + + + + int + bltId + + + long + dVerId + + + long + dVerHash + + + org.apache.ignite.internal.processors.metastorage.persistence.DistributedMetaStorageHistoryItemMessage[] + hist + + + + + + + long + dVerId + + + long + dVerHash + + + java.lang.String[] + fullDataKeys + + + byte[][] + fullDataValsBytes + + + org.apache.ignite.internal.processors.metastorage.persistence.DistributedMetaStorageHistoryItemMessage[] + hist + + + org.apache.ignite.internal.processors.metastorage.persistence.DistributedMetaStorageHistoryItemMessage[] + updates + + + + + + + org.apache.ignite.plugin.extensions.communication.Message[] + attrs + + + byte + idBitmap + + + + + + + java.util.UUID + subjId + + + + + + + int + rangeStartInclusive + + + int + rangeEndInclusive + + + org.apache.ignite.internal.util.GridIntList + sparseSuffix + + + + + + + org.apache.ignite.lang.IgniteProductVersion + ver + + + org.apache.ignite.internal.processors.rollingupgrade.feature.IgniteFeatureSet + features + + + + + + + org.apache.ignite.lang.IgniteProductVersion + ver + + + org.apache.ignite.internal.processors.rollingupgrade.feature.IgniteFeatureSet + features + + + java.lang.String + compName + + + + + + + boolean + isVersionUpgradeEnabled + + + java.util.UUID + curFinalizeProcId + + + org.apache.ignite.internal.processors.rollingupgrade.feature.IgniteNodeFeatureSet + activeFeatures + + + org.apache.ignite.internal.processors.rollingupgrade.feature.IgniteNodeFeatureSet + prevActiveFeatures + + + + + + + org.apache.ignite.internal.processors.rollingupgrade.feature.IgniteComponentFeatureSet[] + features + + + + + diff --git a/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/MessageCompatibilityTestSuite.java b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/MessageCompatibilityTestSuite.java new file mode 100644 index 0000000000000..099ca67e46e8d --- /dev/null +++ b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/MessageCompatibilityTestSuite.java @@ -0,0 +1,32 @@ +/* + * 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.tools.compatibility.messages; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; + +/** Test suite for message compatibility tools. */ +@RunWith(Suite.class) +@Suite.SuiteClasses({ + MessageSchemaReaderTest.class, + MessageTableCollectorTest.class, + MessageTableTest.class, + XmlTableWriterTest.class +}) +public class MessageCompatibilityTestSuite { +} diff --git a/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/MessageSchemaReaderTest.java b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/MessageSchemaReaderTest.java new file mode 100644 index 0000000000000..e9efa4fa30d20 --- /dev/null +++ b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/MessageSchemaReaderTest.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.tools.compatibility.messages; + +import java.util.List; +import org.apache.ignite.internal.Compress; +import org.apache.ignite.internal.CustomMapper; +import org.apache.ignite.internal.JdkMarshalled; +import org.apache.ignite.internal.Marshalled; +import org.apache.ignite.internal.NioField; +import org.apache.ignite.internal.Order; +import org.apache.ignite.tools.compatibility.messages.dto.AnnotationRepresentation; +import org.apache.ignite.tools.compatibility.messages.dto.FieldRepresentation; +import org.apache.ignite.tools.compatibility.messages.messages.TestChildMessage; +import org.apache.ignite.tools.compatibility.messages.messages.TestEmptyMessage; +import org.apache.ignite.tools.compatibility.messages.messages.TestInvalidOrderMessage; +import org.apache.ignite.tools.compatibility.messages.messages.TestParentMessage; +import org.apache.ignite.tools.compatibility.messages.messages.TestUnannotatedMessage; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +/** Verifies field schemas read from bytecode rather than compiler output resources. */ +public class MessageSchemaReaderTest { + /** CLASS annotations are invisible to reflection but available through the compiler model. */ + @Test public void testCompiledFields() throws Exception { + assertNull(TestParentMessage.class.getDeclaredField("id").getAnnotation(Order.class)); + + try (MessageSchemaReader reader = new MessageSchemaReader()) { + assertEquals(List.of(new AnnotationRepresentation(JdkMarshalled.class.getName(), null)), + reader.read(TestChildMessage.class).annotations()); + assertEquals(List.of(), reader.read(TestEmptyMessage.class).annotations()); + assertEquals(List.of( + new FieldRepresentation(0, "int", "id", List.of()), + new FieldRepresentation(1, "byte[]", "parentValueBytes", List.of()), + new FieldRepresentation(2, "byte[]", "id", List.of( + new AnnotationRepresentation(Compress.class.getName(), null), + new AnnotationRepresentation(NioField.class.getName(), null))), + new FieldRepresentation(3, TestChildMessage.Mode.class.getCanonicalName(), "mode", + List.of(new AnnotationRepresentation(CustomMapper.class.getName(), "example.Mapper"))), + new FieldRepresentation(null, "java.lang.Object", "parentValue", + List.of(new AnnotationRepresentation(Marshalled.class.getName(), "value=parentValueBytes"))), + new FieldRepresentation(null, "java.util.List", "payload", + List.of(new AnnotationRepresentation(Marshalled.class.getName(), "value=id"))) + ), reader.read(TestChildMessage.class).fields()); + assertEquals(List.of(), reader.read(TestEmptyMessage.class).fields()); + assertEquals(List.of(), reader.read(TestUnannotatedMessage.class).fields()); + assertEquals( + List.of(new FieldRepresentation(1, "int", "id", List.of())), + reader.read(TestInvalidOrderMessage.class).fields() + ); + } + } + +} diff --git a/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/MessageTableCollectorTest.java b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/MessageTableCollectorTest.java new file mode 100644 index 0000000000000..99ca4e4a60cb8 --- /dev/null +++ b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/MessageTableCollectorTest.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.tools.compatibility.messages; + +import java.util.List; +import org.apache.ignite.internal.CoreMessagesProvider; +import org.apache.ignite.plugin.extensions.communication.MessageFactoryProvider; +import org.apache.ignite.tools.compatibility.messages.dto.MessageRepresentation; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +/** Tests message collection independently of XML writing. */ +public class MessageTableCollectorTest { + /** Collects registrations and compiled schemas without XML serialization. */ + @Test public void testCollect() throws Exception { + MessageFactoryProvider[] providers = {new CoreMessagesProvider()}; + MessageTableCollector collector = new MessageTableCollector(providers); + List msgs = collector.collect(); + + assertEquals(msgs, collector.collect()); + assertFalse(msgs.isEmpty()); + + int prevId = Integer.MIN_VALUE; + boolean compressedFound = false; + + for (MessageRepresentation msg : msgs) { + assertTrue(msg.id() > prevId); + prevId = msg.id(); + + if (msg.id() == 5000) { + compressedFound = true; + assertEquals("org.apache.ignite.internal.managers.communication.CompressedMessage", msg.className()); + assertTrue(msg.schema().fields().isEmpty()); + assertTrue(msg.schema().annotations().isEmpty()); + } + } + + assertTrue(compressedFound); + } +} diff --git a/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/MessageTableTest.java b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/MessageTableTest.java new file mode 100644 index 0000000000000..12b406d1cf19e --- /dev/null +++ b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/MessageTableTest.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.tools.compatibility.messages; + +import java.nio.file.Files; +import java.nio.file.Path; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; + +import static org.junit.Assert.assertEquals; + +/** Tests the message table command. */ +public class MessageTableTest { + /** Temporary output directory. */ + @Rule public TemporaryFolder tmp = new TemporaryFolder(); + + /** The command writes the collected table and preserves the checked-in format. */ + @Test public void testMain() throws Exception { + Path out = tmp.getRoot().toPath().resolve("result/table.xml"); + + MessageTable.main(new String[] {out.toString()}); + + String table = Files.readString(out); + + assertEquals(Files.readString(Path.of("src/main/resources/messages/table.xml")), table); + + try (var files = Files.list(out.getParent())) { + assertEquals(1, files.count()); + } + } +} diff --git a/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/XmlTableWriterTest.java b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/XmlTableWriterTest.java new file mode 100644 index 0000000000000..c5b2085941290 --- /dev/null +++ b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/XmlTableWriterTest.java @@ -0,0 +1,109 @@ +/* + * 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.tools.compatibility.messages; + +import java.util.List; +import org.apache.ignite.internal.Compress; +import org.apache.ignite.internal.CustomMapper; +import org.apache.ignite.internal.JdkMarshalled; +import org.apache.ignite.internal.Marshalled; +import org.apache.ignite.tools.compatibility.messages.dto.AnnotationRepresentation; +import org.apache.ignite.tools.compatibility.messages.dto.FieldRepresentation; +import org.apache.ignite.tools.compatibility.messages.dto.MessageRepresentation; +import org.apache.ignite.tools.compatibility.messages.dto.Schema; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +/** Tests XML output using data without loading message classes. */ +public class XmlTableWriterTest { + /** Writes synthetic data, including escaping, field order, empty fields and a message-level marker. */ + @Test public void testWrite() throws Exception { + List msgs = List.of( + new MessageRepresentation((short)7, "example.Message", new Schema( + List.of(new AnnotationRepresentation(JdkMarshalled.class.getName(), null)), List.of( + new FieldRepresentation(2, "java.util.List", "names", List.of( + new AnnotationRepresentation("since", "2.18.0"), + new AnnotationRepresentation(CustomMapper.class.getName(), "A&B"), + new AnnotationRepresentation(Compress.class.getName(), null) + )), + new FieldRepresentation(3, "int", "count", List.of()), + new FieldRepresentation(null, "java.lang.Object", "data", + List.of(new AnnotationRepresentation(Marshalled.class.getName(), "value=dataBytes"))) + ))), + new MessageRepresentation((short)8, "example.Empty", new Schema(List.of(), List.of())) + ); + + String expected = """ + + + + + + + + + + + + + A&B + 2.18.0 + + java.util.List<java.lang.String> + names + + + int + count + + + + + + value=dataBytes + + java.lang.Object + data + + + + + + + + """; + + assertEquals(expected, new XmlTableWriter().toXml(msgs)); + } +} diff --git a/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/messages/TestChildMessage.java b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/messages/TestChildMessage.java new file mode 100644 index 0000000000000..6d0647d2a9468 --- /dev/null +++ b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/messages/TestChildMessage.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.tools.compatibility.messages.messages; + +import java.util.List; +import org.apache.ignite.internal.Compress; +import org.apache.ignite.internal.CustomMapper; +import org.apache.ignite.internal.Marshalled; +import org.apache.ignite.internal.NioField; +import org.apache.ignite.internal.Order; + +/** Declaration order is deliberately different from serialization order. */ +public class TestChildMessage extends TestParentMessage { + /** Enum mapped by a named mapper. */ + @Order(1) + @CustomMapper("example.Mapper") + private Mode mode; + + /** Child field hides the parent's field. */ + @Order(0) + @Compress + @NioField + private byte[] id; + + /** Logical value mapped to a wire field. */ + @Marshalled("id") + private List payload; + + /** Ordinary, non-wire field. */ + private int ignored; + + /** Ordinary methods do not become schema entries. */ + int ignored() { + return ignored; + } + + /** Fixture enum. */ + public enum Mode { + /** Single fixture value. */ + ONE + } +} diff --git a/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/messages/TestEmptyMessage.java b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/messages/TestEmptyMessage.java new file mode 100644 index 0000000000000..62b653974d665 --- /dev/null +++ b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/messages/TestEmptyMessage.java @@ -0,0 +1,27 @@ +/* + * 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.tools.compatibility.messages.messages; + +import org.apache.ignite.internal.EmptyMessage; +import org.apache.ignite.plugin.extensions.communication.Message; + +/** Empty message fixture. */ +@EmptyMessage +public class TestEmptyMessage implements Message { + // No-op. +} diff --git a/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/messages/TestInvalidOrderMessage.java b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/messages/TestInvalidOrderMessage.java new file mode 100644 index 0000000000000..58d0e7322bbf8 --- /dev/null +++ b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/messages/TestInvalidOrderMessage.java @@ -0,0 +1,28 @@ +/* + * 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.tools.compatibility.messages.messages; + +import org.apache.ignite.internal.Order; +import org.apache.ignite.plugin.extensions.communication.Message; + +/** Message fixture with an invalid local order. */ +public class TestInvalidOrderMessage implements Message { + /** Missing preceding field. */ + @Order(1) + private int id; +} diff --git a/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/messages/TestParentMessage.java b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/messages/TestParentMessage.java new file mode 100644 index 0000000000000..b9738c270af44 --- /dev/null +++ b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/messages/TestParentMessage.java @@ -0,0 +1,39 @@ +/* + * 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.tools.compatibility.messages.messages; + +import org.apache.ignite.internal.JdkMarshalled; +import org.apache.ignite.internal.Marshalled; +import org.apache.ignite.internal.Order; +import org.apache.ignite.plugin.extensions.communication.Message; + +/** Parent fields precede child fields, and marshaller selection is inherited. */ +@JdkMarshalled +public class TestParentMessage implements Message { + /** Parent field. */ + @Order(0) + private int id; + + /** Parent companion field. */ + @Order(1) + private byte[] parentValueBytes; + + /** Parent logical value mapped to a wire field. */ + @Marshalled("parentValueBytes") + private Object parentValue; +} diff --git a/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/messages/TestUnannotatedMessage.java b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/messages/TestUnannotatedMessage.java new file mode 100644 index 0000000000000..6f26411da81d3 --- /dev/null +++ b/modules/compatibility-check/src/test/java/org/apache/ignite/tools/compatibility/messages/messages/TestUnannotatedMessage.java @@ -0,0 +1,25 @@ +/* + * 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.tools.compatibility.messages.messages; + +import org.apache.ignite.plugin.extensions.communication.Message; + +/** Message fixture without field annotations. */ +public class TestUnannotatedMessage implements Message { + // No-op. +} diff --git a/pom.xml b/pom.xml index 6e7fe06a8dac0..b03d54e9802d1 100644 --- a/pom.xml +++ b/pom.xml @@ -75,6 +75,7 @@ modules/control-utility modules/calcite modules/compatibility + modules/compatibility-check