diff --git a/modules/codegen2/src/main/java/org/apache/ignite/internal/MessageSerializerGenerator.java b/modules/codegen2/src/main/java/org/apache/ignite/internal/MessageSerializerGenerator.java index 03420b425ccf7..a253c05897098 100644 --- a/modules/codegen2/src/main/java/org/apache/ignite/internal/MessageSerializerGenerator.java +++ b/modules/codegen2/src/main/java/org/apache/ignite/internal/MessageSerializerGenerator.java @@ -60,15 +60,15 @@ * Generates serializer class for given {@code Message} class. The generated serializer follows the naming convention: * {@code org.apache.ignite.internal.codegen.[MessageClassName]Serializer}. */ -class MessageSerializerGenerator { +public class MessageSerializerGenerator { /** */ private static final String EMPTY = ""; /** */ - private static final String TAB = " "; + public static final String TAB = " "; /** */ - private static final String NL = System.lineSeparator(); + public static final String NL = System.lineSeparator(); /** */ private static final String PKG_NAME = "org.apache.ignite.internal.codegen"; @@ -81,7 +81,7 @@ class MessageSerializerGenerator { " */"; /** */ - private static final String METHOD_JAVADOC = "/** */"; + public static final String METHOD_JAVADOC = "/** */"; /** */ private static final String RETURN_FALSE_STMT = "return false;"; @@ -119,10 +119,11 @@ void generate(TypeElement type, List fields) throws Exception { imports.add(type.getQualifiedName().toString()); String serClsName = type.getSimpleName() + "Serializer"; + String serFqnClsName = PKG_NAME + "." + serClsName; String serCode = generateSerializerCode(serClsName); try { - JavaFileObject file = env.getFiler().createSourceFile(PKG_NAME + "." + serClsName); + JavaFileObject file = env.getFiler().createSourceFile(serFqnClsName); try (Writer writer = file.openWriter()) { writer.append(serCode); @@ -136,7 +137,7 @@ void generate(TypeElement type, List fields) throws Exception { // all Run commands to Maven. However, this significantly slows down test startup time. // This hack checks whether the content of a generating file is identical to already existed file, and skips // handling this class if it is. - if (!identicalFileIsAlreadyGenerated(serCode, serClsName)) { + if (!identicalFileIsAlreadyGenerated(env, serCode, serFqnClsName)) { env.getMessager().printMessage( Diagnostic.Kind.ERROR, "MessageSerializer " + serClsName + " is already generated. Try 'mvn clean install' to fix the issue."); @@ -403,7 +404,7 @@ else if (assignableFrom(erasedType(type), type(Collection.class.getName()))) { "MessageCollectionItemType." + messageCollectionItemType(typeArgs.get(0))); } - else if (enumType(type)) { + else if (enumType(env, type)) { Element element = env.getTypeUtils().asElement(type); imports.add(element.toString()); @@ -609,8 +610,7 @@ else if (assignableFrom(erasedType(type), type(Collection.class.getName()))) { returnFalseIfReadFailed(name, collectionReader, "MessageCollectionItemType." + messageCollectionItemType(typeArgs.get(0))); } - - else if (enumType(type)) { + else if (enumType(env, type)) { String fieldPrefix = typeNameToFieldName(env.getTypeUtils().asElement(type).getSimpleName().toString()); boolean hasCustMapperAnn = field.getAnnotation(CustomMapper.class) != null; @@ -856,7 +856,7 @@ private boolean assignableFrom(TypeMirror type, TypeMirror superType) { } /** */ - private boolean enumType(TypeMirror type) { + public static boolean enumType(ProcessingEnvironment env, TypeMirror type) { Element element = env.getTypeUtils().asElement(type); return element != null && element.getKind() == ElementKind.ENUM; @@ -882,9 +882,9 @@ private String capitalizeOnlyFirst(String input) { } /** @return {@code true} if trying to generate file with the same content. */ - private boolean identicalFileIsAlreadyGenerated(String srcCode, String clsName) { + public static boolean identicalFileIsAlreadyGenerated(ProcessingEnvironment env, String srcCode, String fqnClsName) { try { - String fileName = PKG_NAME.replace('.', '/') + '/' + clsName + ".java"; + String fileName = fqnClsName.replace('.', '/') + ".java"; FileObject prevFile = env.getFiler().getResource(StandardLocation.SOURCE_OUTPUT, "", fileName); String prevFileContent; @@ -904,7 +904,7 @@ private boolean identicalFileIsAlreadyGenerated(String srcCode, String clsName) } /** */ - private String content(Reader reader) throws IOException { + private static String content(Reader reader) throws IOException { BufferedReader br = new BufferedReader(reader); StringBuilder sb = new StringBuilder(); String line; diff --git a/modules/codegen2/src/main/java/org/apache/ignite/internal/idto/IDTOSerializerGenerator.java b/modules/codegen2/src/main/java/org/apache/ignite/internal/idto/IDTOSerializerGenerator.java new file mode 100644 index 0000000000000..b3d3e82bdd578 --- /dev/null +++ b/modules/codegen2/src/main/java/org/apache/ignite/internal/idto/IDTOSerializerGenerator.java @@ -0,0 +1,385 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.idto; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.ObjectInput; +import java.io.ObjectOutput; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.io.Writer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; +import java.util.function.Function; +import javax.annotation.processing.FilerException; +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.NestingKind; +import javax.lang.model.element.PackageElement; +import javax.lang.model.element.TypeElement; +import javax.lang.model.element.VariableElement; +import javax.lang.model.type.ArrayType; +import javax.lang.model.type.PrimitiveType; +import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; +import javax.tools.Diagnostic; +import javax.tools.JavaFileObject; +import org.apache.ignite.internal.util.typedef.F; +import org.apache.ignite.lang.IgniteBiTuple; + +import static org.apache.ignite.internal.MessageSerializerGenerator.NL; +import static org.apache.ignite.internal.MessageSerializerGenerator.TAB; +import static org.apache.ignite.internal.MessageSerializerGenerator.enumType; +import static org.apache.ignite.internal.MessageSerializerGenerator.identicalFileIsAlreadyGenerated; + +/** + * Generates serializer class for given {@code IgniteDataTransferObject} extension. + * The generated serializer follows the naming convention: + * {@code org.apache.ignite.internal.codegen.[IDTOClassName]Serializer}. + */ +public class IDTOSerializerGenerator { + /** Serializer interface. */ + public static final String DTO_SERDES_INTERFACE = "org.apache.ignite.internal.dto.IgniteDataTransferObjectSerializer"; + + /** Class javadoc */ + static final String CLS_JAVADOC = "/** " + NL + + " * This class is generated automatically." + NL + + " *" + NL + + " * @see org.apache.ignite.internal.dto.IgniteDataTransferObject" + NL + + " */"; + + /** Type name to write/read code for the type. */ + private static final Map> TYPE_SERDES = new HashMap<>(); + + { + TYPE_SERDES.put(boolean.class.getName(), F.t("out.writeBoolean(obj.${f});", "obj.${f} = in.readBoolean();")); + TYPE_SERDES.put(byte.class.getName(), F.t("out.write(obj.${f});", "obj.${f} = in.read();")); + TYPE_SERDES.put(short.class.getName(), F.t("out.writeShort(obj.${f});", "obj.${f} = in.readShort();")); + TYPE_SERDES.put(int.class.getName(), F.t("out.writeInt(obj.${f});", "obj.${f} = in.readInt();")); + TYPE_SERDES.put(long.class.getName(), F.t("out.writeLong(obj.${f});", "obj.${f} = in.readLong();")); + TYPE_SERDES.put(float.class.getName(), F.t("out.writeFloat(obj.${f});", "obj.${f} = in.readFloat();")); + TYPE_SERDES.put(double.class.getName(), F.t("out.writeDouble(obj.${f});", "obj.${f} = in.readDouble();")); + + IgniteBiTuple objSerdes = F.t("out.writeObject(obj.${f});", "obj.${f} = (${c})in.readObject();"); + + TYPE_SERDES.put(Boolean.class.getName(), objSerdes); + TYPE_SERDES.put(Byte.class.getName(), objSerdes); + TYPE_SERDES.put(Short.class.getName(), objSerdes); + TYPE_SERDES.put(Integer.class.getName(), objSerdes); + TYPE_SERDES.put(Long.class.getName(), objSerdes); + TYPE_SERDES.put(Float.class.getName(), objSerdes); + TYPE_SERDES.put(Double.class.getName(), objSerdes); + + TYPE_SERDES.put(String.class.getName(), F.t("U.writeString(out, obj.${f});", "obj.${f} = U.readString(in);")); + TYPE_SERDES.put(UUID.class.getName(), F.t("U.writeUuid(out, obj.${f});", "obj.${f} = U.readUuid(in);")); + TYPE_SERDES.put("org.apache.ignite.lang.IgniteUuid", F.t("U.writeIgniteUuid(out, obj.${f});", "obj.${f} = U.readIgniteUuid(in);")); + TYPE_SERDES.put("org.apache.ignite.internal.processors.cache.version.GridCacheVersion", objSerdes); + + TYPE_SERDES.put(Map.class.getName(), F.t("U.writeMap(out, obj.${f});", "obj.${f} = U.readMap(in);")); + } + + /** Write/Read code for enum. */ + private static final IgniteBiTuple ENUM_SERDES = + F.t("U.writeEnum(out, obj.${f});", "obj.${f} = U.readEnum(in, ${c}.class);"); + + /** Write/Read code for array. */ + private static final IgniteBiTuple OBJ_ARRAY_SERDES = + F.t("U.writeArray(out, obj.${f});", "obj.${f} = U.readArray(in, ${c}.class);"); + + /** Type name to write/read code for the array of type. */ + private static final Map> ARRAY_TYPE_SERDES = new HashMap<>(); + + { + ARRAY_TYPE_SERDES.put(byte.class.getName(), F.t("U.writeByteArray(out, obj.${f});", "obj.${f} = U.readByteArray(in);")); + ARRAY_TYPE_SERDES.put(int.class.getName(), F.t("U.writeIntArray(out, obj.${f});", "obj.${f} = U.readIntArray(in);")); + ARRAY_TYPE_SERDES.put(long.class.getName(), F.t("U.writeLongArray(out, obj.${f});", "obj.${f} = U.readLongArray(in);")); + ARRAY_TYPE_SERDES.put(String.class.getName(), OBJ_ARRAY_SERDES); + ARRAY_TYPE_SERDES.put(UUID.class.getName(), OBJ_ARRAY_SERDES); + } + + /** Environment. */ + private final ProcessingEnvironment env; + + /** Type to generated serializer for. */ + private final TypeElement type; + + /** Serializer imports. */ + private final Set imports = new HashSet<>(); + + /** + * @param env Environment. + * @param type Type to generate serializer for. + */ + public IDTOSerializerGenerator(ProcessingEnvironment env, TypeElement type) { + this.env = env; + this.type = type; + } + + /** @return Fully qualified name for generated class. */ + public String serializerFQN() { + TypeElement topLevelCls = type; + + while (topLevelCls.getNestingKind() != NestingKind.TOP_LEVEL) + topLevelCls = (TypeElement)topLevelCls.getEnclosingElement(); + + PackageElement pkg = (PackageElement)topLevelCls.getEnclosingElement(); + + return pkg.getQualifiedName().toString() + "." + serializerName(); + } + + /** + * @return {@code True} if generation succeed. + * @throws Exception in case of error. + */ + public boolean generate() throws Exception { + String fqnClsName = serializerFQN(); + String serCode = generateSerializerCode(); + + try { + JavaFileObject file = env.getFiler().createSourceFile(fqnClsName); + + try (Writer writer = file.openWriter()) { + writer.append(serCode); + writer.flush(); + } + + return true; + } + catch (FilerException e) { + // IntelliJ IDEA parses Ignite's pom.xml and configures itself to use this annotation processor on each Run. + // During a Run, it invokes the processor and may fail when attempting to generate sources that already exist. + // There is no a setting to disable this invocation. The IntelliJ community suggests a workaround — delegating + // all Run commands to Maven. However, this significantly slows down test startup time. + // This hack checks whether the content of a generating file is identical to already existed file, and skips + // handling this class if it is. + if (!identicalFileIsAlreadyGenerated(env, serCode, fqnClsName)) { + env.getMessager().printMessage( + Diagnostic.Kind.ERROR, + fqnClsName + " is already generated. Try 'mvn clean install' to fix the issue."); + + throw e; + } + + return false; + } + } + + /** @return Code for the calss implementing {@code org.apache.ignite.internal.dto.IgniteDataTransferObjectSerializer}. */ + private String generateSerializerCode() throws IOException { + imports.add(DTO_SERDES_INTERFACE); + imports.add(ObjectOutput.class.getName()); + imports.add(ObjectInput.class.getName()); + imports.add(IOException.class.getName()); + imports.add("org.apache.ignite.internal.util.typedef.internal.U"); + + if (type.getNestingKind() != NestingKind.TOP_LEVEL) + imports.add(type.getQualifiedName().toString()); + + String simpleClsName = String.valueOf(type.getSimpleName()); + + List flds = fields(type); + + List write = generateWrite(simpleClsName, flds); + List read = generateRead(simpleClsName, flds); + + try (Writer writer = new StringWriter()) { + writeClassHeader(writer, simpleClsName); + + for (String line : write) { + writer.write(TAB); + writer.write(line); + writer.write(NL); + } + + writer.write(NL); + for (String line : read) { + writer.write(TAB); + writer.write(line); + writer.write(NL); + } + + writer.write("}"); + writer.write(NL); + + return writer.toString(); + } + } + + /** + * @param writer Writer to write class to. + * @param simpleClsName Class name + * @throws IOException In case of error. + */ + private void writeClassHeader(Writer writer, String simpleClsName) throws IOException { + try (InputStream in = getClass().getClassLoader().getResourceAsStream("license.txt"); + BufferedReader reader = new BufferedReader(new InputStreamReader(in))) { + + PrintWriter out = new PrintWriter(writer); + + String line; + + while ((line = reader.readLine()) != null) + out.println(line); + } + + writer.write(NL); + writer.write("package " + env.getElementUtils().getPackageOf(type).toString() + ";" + NL + NL); + + for (String regularImport: imports) + writer.write("import " + regularImport + ";" + NL); + + writer.write(NL); + writer.write(CLS_JAVADOC); + writer.write(NL); + writer.write("public class " + serializerName() + " implements " + simpleName(DTO_SERDES_INTERFACE) + + "<" + simpleClsName + "> {" + NL); + } + + /** @return Lines for generated {@code IgniteDataTransferObjectSerializer#writeExternal(T, ObjectOutput)} method. */ + private List generateWrite(String clsName, List flds) { + List code = new ArrayList<>(); + + code.add("/** {@inheritDoc} */"); + code.add("@Override public void writeExternal(" + clsName + " obj, ObjectOutput out) throws IOException {"); + + fieldsSerdes(flds, IgniteBiTuple::get1).forEach(line -> code.add(TAB + line)); + + code.add("}"); + + return code; + } + + /** @return Lines for generated {@code IgniteDataTransferObjectSerializer#readExternal(T, ObjectInput)} method. */ + private List generateRead(String clsName, List flds) { + List code = new ArrayList<>(); + + code.add("/** {@inheritDoc} */"); + code.add("@Override public void readExternal(" + clsName + " obj, ObjectInput in) throws IOException, ClassNotFoundException {"); + fieldsSerdes(flds, IgniteBiTuple::get2).forEach(line -> code.add(TAB + line)); + code.add("}"); + + return code; + } + + /** + * @param flds Fields to generated serdes for. + * @param lineProvider Function to generated serdes code for the field. + * @return Lines to serdes fields. + */ + private List fieldsSerdes( + List flds, + Function, String> lineProvider + ) { + List code = new ArrayList<>(); + + for (VariableElement fld : flds) { + TypeMirror type = fld.asType(); + TypeMirror comp = null; + + IgniteBiTuple serDes; + + if (type.getKind() == TypeKind.ARRAY) { + comp = ((ArrayType)type).getComponentType(); + + serDes = enumType(env, comp) ? OBJ_ARRAY_SERDES : ARRAY_TYPE_SERDES.get(className(comp)); + } + else + serDes = enumType(env, type) ? ENUM_SERDES : TYPE_SERDES.get(className(type)); + + if (serDes != null) { + String pattern = lineProvider.apply(serDes); + + code.add(pattern + .replaceAll("\\$\\{f}", fld.getSimpleName().toString()) + .replaceAll("\\$\\{c}", simpleClassName(comp == null ? type : comp))); + } + else + throw new IllegalStateException("Unsupported type: " + type); + } + + return code; + } + + /** @return List of non-static and non-transient field for given {@code type}. */ + private List fields(TypeElement type) { + List res = new ArrayList<>(); + + while (type != null) { + for (Element el: type.getEnclosedElements()) { + if (el.getKind() != ElementKind.FIELD) + continue; + + if (el.getModifiers().contains(Modifier.STATIC) || el.getModifiers().contains(Modifier.TRANSIENT)) + continue; + + res.add((VariableElement)el); + } + + Element superType = env.getTypeUtils().asElement(type.getSuperclass()); + + type = (TypeElement)superType; + } + + return res; + } + + /** @return FQN of {@code comp}. */ + private static String className(TypeMirror comp) { + String n = comp.toString(); + int genIdx = n.indexOf('<'); + + return genIdx == -1 ? n : n.substring(0, genIdx); + } + + /** @return Serializer class name. */ + private String serializerName() { + return type.getSimpleName() + "Serializer"; + } + + /** + * Adds to imports if class need to be imported explicitly. + * + * @return Simple class name. + */ + private String simpleClassName(TypeMirror type) { + if (type instanceof PrimitiveType) + return className(type); + + String fqn = className(type); + + if (!fqn.startsWith("java.lang")) + imports.add(fqn); + + return simpleName(fqn); + } + + /** @return Simple class name. */ + public static String simpleName(String fqn) { + return fqn.substring(fqn.lastIndexOf('.') + 1); + } +} diff --git a/modules/codegen2/src/main/java/org/apache/ignite/internal/idto/IgniteDataTransferObjectProcessor.java b/modules/codegen2/src/main/java/org/apache/ignite/internal/idto/IgniteDataTransferObjectProcessor.java new file mode 100644 index 0000000000000..df9f23c561f1e --- /dev/null +++ b/modules/codegen2/src/main/java/org/apache/ignite/internal/idto/IgniteDataTransferObjectProcessor.java @@ -0,0 +1,390 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.idto; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.io.Writer; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; +import javax.annotation.processing.AbstractProcessor; +import javax.annotation.processing.FilerException; +import javax.annotation.processing.RoundEnvironment; +import javax.annotation.processing.SupportedAnnotationTypes; +import javax.annotation.processing.SupportedSourceVersion; +import javax.lang.model.SourceVersion; +import javax.lang.model.element.AnnotationMirror; +import javax.lang.model.element.Element; +import javax.lang.model.element.ElementKind; +import javax.lang.model.element.Modifier; +import javax.lang.model.element.NestingKind; +import javax.lang.model.element.TypeElement; +import javax.lang.model.type.TypeMirror; +import javax.tools.Diagnostic; +import javax.tools.JavaFileObject; + +import static org.apache.ignite.internal.MessageSerializerGenerator.NL; +import static org.apache.ignite.internal.MessageSerializerGenerator.TAB; +import static org.apache.ignite.internal.MessageSerializerGenerator.identicalFileIsAlreadyGenerated; +import static org.apache.ignite.internal.idto.IDTOSerializerGenerator.CLS_JAVADOC; +import static org.apache.ignite.internal.idto.IDTOSerializerGenerator.DTO_SERDES_INTERFACE; +import static org.apache.ignite.internal.idto.IDTOSerializerGenerator.simpleName; + +/** + * Generates implementations of {@code IgniteDataTransferObjectSerializer} for all supported classes. + * Generates factory {@code IDTOSerializerFactory} to get instance of serializer for given class. + * See, {@code IgniteDataTransferObject#writeExternal(ObjectOutput)} and {@code IgniteDataTransferObject#writeExternal(ObjectInput)} to get + * insight of using serializers. + */ +@SupportedAnnotationTypes("org.apache.ignite.internal.management.api.Argument") +@SupportedSourceVersion(SourceVersion.RELEASE_11) +public class IgniteDataTransferObjectProcessor extends AbstractProcessor { + /** Package for serializers. */ + private static final String FACTORY_PKG_NAME = "org.apache.ignite.internal.codegen.idto"; + + /** Base class that every dto must extend. */ + private static final String DTO_CLASS = "org.apache.ignite.internal.dto.IgniteDataTransferObject"; + + /** + * Annotation used in management commands. + * For now, we restrict set of generated serdes to all management commands argument classes. + * Because, they strictly follows Ignite codestyle convention. + * Providing support of all other inheritor of {@code IgniteDataTransferObject} is matter of following improvements. + */ + private static final String ARG_ANNOTATION = "org.apache.ignite.internal.management.api.Argument"; + + /** Factory class name. */ + public static final String FACTORY_CLASS = "IDTOSerializerFactory"; + + /** Generated classes. */ + private final Map genSerDes = new HashMap<>(); + + /** + * Processes all classes extending the {@code IgniteDataTransferObject} and generates corresponding serializer code. + */ + @Override public boolean process(Set annotations, RoundEnvironment roundEnv) { + if (roundEnv.errorRaised()) + return true; + + genSerDes.clear(); + + roundEnv.getRootElements().forEach(this::generateSingle); + + // IDE recompile only modified classes. Don't want to touch factory in the case no matching classes was recompiled. + if (genSerDes.isEmpty()) + return true; + + generateFactory(genSerDes); + + return true; + } + + /** + * @param el Element to generate code for. + */ + private void generateSingle(Element el) { + if (el.getKind() != ElementKind.CLASS) + return; + + TypeMirror dtoCls = processingEnv.getElementUtils().getTypeElement(DTO_CLASS).asType(); + TypeMirror argAnnotation = processingEnv.getElementUtils().getTypeElement(ARG_ANNOTATION).asType(); + + TypeElement clazz = (TypeElement)el; + + // Generate code for inner classes. + clazz.getEnclosedElements().forEach(this::generateSingle); + + if (!processingEnv.getTypeUtils().isAssignable(clazz.asType(), dtoCls)) + return; + + if (clazz.getModifiers().contains(Modifier.ABSTRACT)) + return; + + if (!clazz.getModifiers().contains(Modifier.PUBLIC)) + return; + + if (clazz.getNestingKind() != NestingKind.TOP_LEVEL && clazz.getNestingKind() != NestingKind.MEMBER) + return; + + if (!hasArgumentFields(clazz, argAnnotation)) + return; + + try { + IDTOSerializerGenerator gen = new IDTOSerializerGenerator(processingEnv, clazz); + + if (gen.generate()) + genSerDes.put(clazz, gen.serializerFQN()); + } + catch (Exception e) { + processingEnv.getMessager().printMessage( + Diagnostic.Kind.ERROR, + "Failed to generate a dto serializer:" + e.getMessage(), + clazz + ); + } + } + + /** + * Generates and writes factory. + * @param genSerDes Generated serdes classes. + */ + private void generateFactory(Map genSerDes) { + try { + String factoryFQN = FACTORY_PKG_NAME + "." + FACTORY_CLASS; + String factoryCode = factoryCode(genSerDes); + + try { + JavaFileObject file = processingEnv.getFiler().createSourceFile(factoryFQN); + + try (Writer writer = file.openWriter()) { + writer.append(factoryCode); + writer.flush(); + } + } + catch (FilerException e) { + // IntelliJ IDEA parses Ignite's pom.xml and configures itself to use this annotation processor on each Run. + // During a Run, it invokes the processor and may fail when attempting to generate sources that already exist. + // There is no a setting to disable this invocation. The IntelliJ community suggests a workaround — delegating + // all Run commands to Maven. However, this significantly slows down test startup time. + // This hack checks whether the content of a generating file is identical to already existed file, and skips + // handling this class if it is. + if (!identicalFileIsAlreadyGenerated(processingEnv, factoryCode, FACTORY_PKG_NAME + "." + FACTORY_CLASS)) { + processingEnv.getMessager().printMessage( + Diagnostic.Kind.ERROR, + FACTORY_CLASS + " is already generated. Try 'mvn clean install' to fix the issue."); + + throw e; + } + } + } + catch (Exception e) { + processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Failed to generate a dto factory: " + e.getMessage()); + } + } + + /** + * @param genSerDes Generated serdes classes. + * @return Factory code. + * @throws IOException In case of error. + */ + private String factoryCode(Map genSerDes) throws IOException { + try (Writer writer = new StringWriter()) { + writeClassHeader(writer, genSerDes); + + writer.write(TAB); + writer.write("/** */"); + writer.write(NL); + writer.write(TAB); + writer.write("private static final " + FACTORY_CLASS + " instance = new " + FACTORY_CLASS + "();"); + writer.write(NL); + writer.write(NL); + + writer.write(TAB); + writer.write("/** */"); + writer.write(NL); + writer.write(TAB); + writer.write("private final Map, " + simpleName(DTO_SERDES_INTERFACE) + "> serdes " + + "= new HashMap<>();"); + writer.write(NL); + writer.write(NL); + + constructor(writer, genSerDes); + writer.write(NL); + + getInstance(writer); + writer.write(NL); + + serializer(writer); + + writer.write("}"); + writer.write(NL); + + return writer.toString(); + } + } + + /** + * Generates class header. + * + * @param writer Writer to write code to. + * @param dtoClss DTO classes to import. + * @throws IOException In case of error. + */ + private void writeClassHeader(Writer writer, Map dtoClss) throws IOException { + try (InputStream in = getClass().getClassLoader().getResourceAsStream("license.txt"); + BufferedReader reader = new BufferedReader(new InputStreamReader(in))) { + + PrintWriter out = new PrintWriter(writer); + + String line; + + while ((line = reader.readLine()) != null) + out.println(line); + } + + writer.write(NL); + writer.write("package " + FACTORY_PKG_NAME + ";" + NL + NL); + + for (Map.Entry e : dtoClss.entrySet()) { + writer.write("import " + e.getKey().getQualifiedName() + ";" + NL); + writer.write("import " + e.getValue() + ";" + NL); + } + + writer.write("import " + Map.class.getName() + ";" + NL); + writer.write("import " + HashMap.class.getName() + ";" + NL); + writer.write("import " + DTO_SERDES_INTERFACE + ";" + NL); + writer.write("import " + DTO_CLASS + ";" + NL); + writer.write("import org.apache.ignite.internal.util.typedef.internal.U;" + NL); + + writer.write(NL); + writer.write(CLS_JAVADOC); + writer.write(NL); + writer.write("public class " + FACTORY_CLASS + " {" + NL); + } + + /** + * Generates static {@code getInstance} method. + * + * @param writer Writer to write code to. + * @throws IOException In case of error. + */ + private static void getInstance(Writer writer) throws IOException { + writer.write(TAB); + writer.write("/** */"); + writer.write(NL); + writer.write(TAB); + writer.write("public static " + FACTORY_CLASS + " getInstance() {"); + writer.write(NL); + writer.write(TAB); + writer.write(TAB); + writer.write("return instance;"); + writer.write(NL); + writer.write(TAB); + writer.write("}"); + writer.write(NL); + } + + /** + * Generates private constructor. + * + * @param writer Writer to write code to. + * @param genSerDes Serdes to support in factory. + * @throws IOException In case of error. + */ + private static void constructor(Writer writer, Map genSerDes) throws IOException { + writer.write(TAB); + writer.write("/** */"); + writer.write(NL); + writer.write(TAB); + writer.write("private " + FACTORY_CLASS + "() {"); + writer.write(NL); + + for (Map.Entry e : genSerDes.entrySet()) { + writer.write(TAB); + writer.write(TAB); + writer.write("serdes.put(" + e.getKey().getSimpleName() + ".class, new " + simpleName(e.getValue()) + "());"); + writer.write(NL); + } + + writer.write(TAB); + writer.write("}"); + writer.write(NL); + } + + /** + * Generates method to get serializer from factory. + * + * @param writer Writer to write code to. + * @throws IOException In case of error. + */ + private void serializer(Writer writer) throws IOException { + writer.write(TAB); + writer.write("/** */"); + writer.write(NL); + writer.write(TAB); + + String genericType = ""; + + writer.write("public " + genericType + " " + simpleName(DTO_SERDES_INTERFACE) + " serializer(Class cls) {"); + writer.write(NL); + writer.write(TAB); + writer.write(TAB); + writer.write("IgniteDataTransferObjectSerializer res = (IgniteDataTransferObjectSerializer)serdes.get(cls);"); + writer.write(NL); + writer.write(NL); + writer.write(TAB); + writer.write(TAB); + writer.write("if (res == null) {"); + writer.write(NL); + writer.write(TAB); + writer.write(TAB); + writer.write(TAB); + // IDE can invoke partial recompile during development. + // In this case there will be only part (one) of serdes in the map initially. + // We want to be able to load serializer dynamically if it is missing in the map but class file itself is presented in classpath. + // Other case to do it custom commands. + writer.write("res = U.loadSerializer(cls);"); + writer.write(NL); + writer.write(NL); + writer.write(TAB); + writer.write(TAB); + writer.write(TAB); + writer.write("serdes.put(cls, res);"); + writer.write(NL); + writer.write(TAB); + writer.write(TAB); + writer.write("}"); + writer.write(NL); + writer.write(NL); + writer.write(TAB); + writer.write(TAB); + writer.write("return res;"); + writer.write(NL); + writer.write(TAB); + writer.write("}"); + writer.write(NL); + } + + /** + * @param type Type to analyze. + * @param argAnnotation Annotation to find. + * @return {@code True} if type has fields annotated with the {@code argAnnotation}, {@code false} otherwise. + */ + private boolean hasArgumentFields(TypeElement type, TypeMirror argAnnotation) { + while (type != null) { + for (Element el: type.getEnclosedElements()) { + if (el.getKind() != ElementKind.FIELD) + continue; + + for (AnnotationMirror am : el.getAnnotationMirrors()) { + if (am.getAnnotationType().equals(argAnnotation)) + return true; + } + } + + type = (TypeElement)processingEnv.getTypeUtils().asElement(type.getSuperclass()); + } + + return false; + } +} diff --git a/modules/core/pom.xml b/modules/core/pom.xml index 536bfb760197d..0175c77aeb24b 100644 --- a/modules/core/pom.xml +++ b/modules/core/pom.xml @@ -386,6 +386,7 @@ ${ignite.generated.source.path} org.apache.ignite.internal.MessageProcessor + org.apache.ignite.internal.idto.IgniteDataTransferObjectProcessor -Xmaxerrs diff --git a/modules/core/src/main/java/org/apache/ignite/internal/dto/IgniteDataTransferObject.java b/modules/core/src/main/java/org/apache/ignite/internal/dto/IgniteDataTransferObject.java index 2013554e55038..b8af7dfc938bc 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/dto/IgniteDataTransferObject.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/dto/IgniteDataTransferObject.java @@ -26,6 +26,8 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.Set; +import org.apache.ignite.internal.codegen.idto.IDTOSerializerFactory; +import org.apache.ignite.internal.util.IgniteUtils; import org.jetbrains.annotations.Nullable; /** @@ -68,14 +70,25 @@ public abstract class IgniteDataTransferObject implements Externalizable { * @param out Output object to write data content. * @throws IOException If I/O errors occur. */ - protected abstract void writeExternalData(ObjectOutput out) throws IOException; + protected void writeExternalData(ObjectOutput out) throws IOException { + throw new UnsupportedOperationException("Please, implement custom method or provide support in " + + "IDTOSerializerGenerator for " + getClass()); + } /** {@inheritDoc} */ @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(MAGIC); try (IgniteDataTransferObjectOutput dtout = new IgniteDataTransferObjectOutput(out)) { - writeExternalData(dtout); + IgniteDataTransferObjectSerializer serializer = IDTOSerializerFactory.getInstance().serializer(getClass()); + + if (serializer == IgniteUtils.EMPTY_DTO_SERIALIZER) { + writeExternalData(dtout); + + return; + } + + serializer.writeExternal(this, dtout); } } @@ -86,7 +99,10 @@ public abstract class IgniteDataTransferObject implements Externalizable { * @throws IOException If I/O errors occur. * @throws ClassNotFoundException If the class for an object being restored cannot be found. */ - protected abstract void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException; + protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { + throw new UnsupportedOperationException("Please, implement custom method or provide support in " + + "IDTOSerializerGenerator for " + getClass()); + } /** {@inheritDoc} */ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { @@ -97,7 +113,15 @@ public abstract class IgniteDataTransferObject implements Externalizable { "[actual=" + Integer.toHexString(hdr) + ", expected=" + Integer.toHexString(MAGIC) + "]"); try (IgniteDataTransferObjectInput dtin = new IgniteDataTransferObjectInput(in)) { - readExternalData(dtin); + IgniteDataTransferObjectSerializer serializer = IDTOSerializerFactory.getInstance().serializer(getClass()); + + if (serializer == IgniteUtils.EMPTY_DTO_SERIALIZER) { + readExternalData(dtin); + + return; + } + + serializer.readExternal(this, dtin); } } } diff --git a/modules/core/src/main/java/org/apache/ignite/internal/dto/IgniteDataTransferObjectSerializer.java b/modules/core/src/main/java/org/apache/ignite/internal/dto/IgniteDataTransferObjectSerializer.java new file mode 100644 index 0000000000000..7a83d06510d46 --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/dto/IgniteDataTransferObjectSerializer.java @@ -0,0 +1,45 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.dto; + +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; + +/** + * @param Type of specific IgniteDataTransferObject this serializer works with. + */ +public interface IgniteDataTransferObjectSerializer { + /** + * + * @param instance Instance of IgniteDataTransferObject to serialize. + * @param out Output stream to write object to. + * @throws IOException If write operation failed. + */ + void writeExternal(T instance, ObjectOutput out) throws IOException; + + /** + * + * @param instance Instance of an IgniteDataTransferObject to read data to. + * @param in Input stream to read object from. + * @return + * @throws IOException If read operation failed. + * @throws ClassNotFoundException If class not found. + */ + void readExternal(T instance, ObjectInput in) throws IOException, ClassNotFoundException; +} diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/ChangeTagCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/ChangeTagCommandArg.java index 9080445578b65..1d75cdd0fa811 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/ChangeTagCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/ChangeTagCommandArg.java @@ -17,15 +17,11 @@ package org.apache.ignite.internal.management; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.CliConfirmArgument; import org.apache.ignite.internal.management.api.Positional; import org.apache.ignite.internal.util.typedef.F; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @CliConfirmArgument @@ -36,17 +32,7 @@ public class ChangeTagCommandArg extends IgniteDataTransferObject { /** */ @Positional @Argument(example = "newTagValue") - private String newTagValue; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, newTagValue); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - newTagValue = U.readString(in); - } + String newTagValue; /** */ public String newTagValue() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/DeactivateCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/DeactivateCommandArg.java index 31a53374aa265..989fc9d97bedd 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/DeactivateCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/DeactivateCommandArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.CliConfirmArgument; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @CliConfirmArgument @@ -33,22 +29,10 @@ public class DeactivateCommandArg extends IgniteDataTransferObject { /** */ @Argument(optional = true) - private boolean force; + boolean force; /** */ - private String clusterName; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - out.writeBoolean(force); - U.writeString(out, clusterName); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - force = in.readBoolean(); - clusterName = U.readString(in); - } + String clusterName; /** */ public boolean force() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/SetStateCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/SetStateCommandArg.java index 10b9ae80ba574..5b003d1c12787 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/SetStateCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/SetStateCommandArg.java @@ -17,16 +17,12 @@ package org.apache.ignite.internal.management; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.cluster.ClusterState; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.CliConfirmArgument; import org.apache.ignite.internal.management.api.EnumDescription; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @CliConfirmArgument @@ -49,28 +45,14 @@ public class SetStateCommandArg extends IgniteDataTransferObject { "Activate cluster. Cache updates are denied" } ) - private ClusterState state; + ClusterState state; /** */ @Argument(optional = true, description = "If true, cluster deactivation will be forced") - private boolean force; + boolean force; /** */ - private String clusterName; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeEnum(out, state); - out.writeBoolean(force); - U.writeString(out, clusterName); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - state = U.readEnum(in, ClusterState.class); - force = in.readBoolean(); - clusterName = U.readString(in); - } + String clusterName; /** */ public ClusterState state() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/ShutdownPolicyCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/ShutdownPolicyCommandArg.java index d3fcf55d8323c..fdf85d21e57bd 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/ShutdownPolicyCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/ShutdownPolicyCommandArg.java @@ -17,15 +17,11 @@ package org.apache.ignite.internal.management; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.ShutdownPolicy; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.EnumDescription; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class ShutdownPolicyCommandArg extends IgniteDataTransferObject { @@ -45,17 +41,7 @@ public class ShutdownPolicyCommandArg extends IgniteDataTransferObject { "Node will stop if and only if it does not store any unique partitions, that don't have another copies in the cluster" } ) - private ShutdownPolicy shutdownPolicy; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeEnum(out, shutdownPolicy); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - shutdownPolicy = U.readEnum(in, ShutdownPolicy.class); - } + ShutdownPolicy shutdownPolicy; /** */ public ShutdownPolicy shutdownPolicy() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/SystemViewCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/SystemViewCommandArg.java index e7c7c78cb0b51..bc15cc485bcc7 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/SystemViewCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/SystemViewCommandArg.java @@ -17,15 +17,11 @@ package org.apache.ignite.internal.management; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.ArgumentGroup; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @ArgumentGroup(value = {"nodeIds", "nodeId", "allNodes"}, optional = true, onlyOneOf = true) @@ -38,14 +34,14 @@ public class SystemViewCommandArg extends IgniteDataTransferObject { @Argument(description = "Name of the system view which content should be printed." + " Both \"SQL\" and \"Java\" styles of system view name are supported" + " (e.g. SQL_TABLES and sql.tables will be handled similarly)") - private String systemViewName; + String systemViewName; /** */ @Argument( description = "ID of the node to get the system view from (deprecated. Use --node-ids instead). " + "If not set, random node will be chosen" ) - private UUID nodeId; + UUID nodeId; /** ID of the nodes to get the system view content from. */ @Argument( @@ -53,27 +49,11 @@ public class SystemViewCommandArg extends IgniteDataTransferObject { "If not set, random node will be chosen", example = "nodeId1,nodeId2,.." ) - private UUID[] nodeIds; + UUID[] nodeIds; /** Flag to get the system view from all nodes. */ @Argument(description = "Get the system view from all nodes. If not set, random node will be chosen") - private boolean allNodes; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, systemViewName); - U.writeUuid(out, nodeId); - U.writeArray(out, nodeIds); - out.writeBoolean(allNodes); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - systemViewName = U.readString(in); - nodeId = U.readUuid(in); - nodeIds = U.readArray(in, UUID.class); - allNodes = in.readBoolean(); - } + boolean allNodes; /** */ public String systemViewName() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineAddCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineAddCommandArg.java index 1561f0df71f1e..e138d40a9cce9 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineAddCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineAddCommandArg.java @@ -17,14 +17,10 @@ package org.apache.ignite.internal.management.baseline; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.CliConfirmArgument; import org.apache.ignite.internal.management.api.Positional; import org.apache.ignite.internal.management.baseline.BaselineCommand.BaselineTaskArg; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @CliConfirmArgument @@ -35,21 +31,7 @@ public class BaselineAddCommandArg extends BaselineTaskArg { /** */ @Positional @Argument(example = "consistentId1[,consistentId2,....,consistentIdN]") - private String[] consistentIDs; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - super.writeExternalData(out); - - U.writeArray(out, consistentIDs); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - super.readExternalData(in); - - consistentIDs = U.readArray(in, String.class); - } + String[] consistentIDs; /** */ public String[] consistentIDs() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineAutoAdjustCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineAutoAdjustCommandArg.java index bc39c4b131992..37346f88e5aa6 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineAutoAdjustCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineAutoAdjustCommandArg.java @@ -17,16 +17,12 @@ package org.apache.ignite.internal.management.baseline; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.ArgumentGroup; import org.apache.ignite.internal.management.api.CliConfirmArgument; import org.apache.ignite.internal.management.api.EnumDescription; import org.apache.ignite.internal.management.api.Positional; import org.apache.ignite.internal.management.baseline.BaselineCommand.BaselineTaskArg; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @CliConfirmArgument @@ -48,11 +44,11 @@ public class BaselineAutoAdjustCommandArg extends BaselineTaskArg { "Disable baseline auto adjust" } ) - private Enabled enabled; + Enabled enabled; /** */ @Argument(optional = true, example = "", withoutPrefix = true) - private Long timeout; + Long timeout; /** */ public enum Enabled { @@ -63,22 +59,6 @@ public enum Enabled { ENABLE } - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - super.writeExternalData(out); - - U.writeEnum(out, enabled); - out.writeObject(timeout); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - super.readExternalData(in); - - enabled = U.readEnum(in, Enabled.class); - timeout = (Long)in.readObject(); - } - /** */ public Enabled enabled() { return enabled; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineCommand.java b/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineCommand.java index 06f3e7968e228..cedeea0bbbed5 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineCommand.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineCommand.java @@ -17,9 +17,6 @@ package org.apache.ignite.internal.management.baseline; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.Collection; import java.util.function.Consumer; import org.apache.ignite.cluster.ClusterNode; @@ -82,17 +79,7 @@ public BaselineCommand() { public abstract static class BaselineTaskArg extends IgniteDataTransferObject { /** */ @Argument(optional = true, description = "Show the full list of node ips") - private boolean verbose; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - out.writeBoolean(verbose); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - verbose = in.readBoolean(); - } + boolean verbose; /** */ public boolean verbose() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineVersionCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineVersionCommandArg.java index 3441d8b1b8da4..b8a424b5c4476 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineVersionCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/baseline/BaselineVersionCommandArg.java @@ -17,9 +17,6 @@ package org.apache.ignite.internal.management.baseline; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.CliConfirmArgument; import org.apache.ignite.internal.management.api.Positional; @@ -34,21 +31,7 @@ public class BaselineVersionCommandArg extends BaselineTaskArg { /** */ @Positional @Argument(example = "topologyVersion") - private long topologyVersion; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - super.writeExternalData(out); - - out.writeLong(topologyVersion); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - super.readExternalData(in); - - topologyVersion = in.readLong(); - } + long topologyVersion; /** */ public long topologyVersion() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheClearCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheClearCommandArg.java index 9a01eed153e3c..1d662c2432407 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheClearCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheClearCommandArg.java @@ -17,12 +17,8 @@ package org.apache.ignite.internal.management.cache; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class CacheClearCommandArg extends IgniteDataTransferObject { @@ -31,17 +27,7 @@ public class CacheClearCommandArg extends IgniteDataTransferObject { /** */ @Argument(description = "specifies a comma-separated list of cache names to be cleared") - private String[] caches; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeArray(out, caches); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - caches = U.readArray(in, String.class); - } + String[] caches; /** */ public String[] caches() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheContentionCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheContentionCommandArg.java index 0c16176b72209..245d7d1130868 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheContentionCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheContentionCommandArg.java @@ -17,14 +17,10 @@ package org.apache.ignite.internal.management.cache; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class CacheContentionCommandArg extends IgniteDataTransferObject { @@ -34,31 +30,17 @@ public class CacheContentionCommandArg extends IgniteDataTransferObject { /** Min queue size. */ @Positional @Argument(example = "minQueueSize") - private int minQueueSize; + int minQueueSize; /** Node id. */ @Positional @Argument(optional = true, example = "nodeId") - private UUID nodeId; + UUID nodeId; /** Max print. */ @Positional @Argument(optional = true, example = "maxPrint") - private int maxPrint = 10; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - out.writeInt(minQueueSize); - U.writeUuid(out, nodeId); - out.writeInt(maxPrint); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - minQueueSize = in.readInt(); - nodeId = U.readUuid(in); - maxPrint = in.readInt(); - } + int maxPrint = 10; /** */ public UUID nodeId() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheCreateCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheCreateCommandArg.java index 1a88b048b10b0..2570550464183 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheCreateCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheCreateCommandArg.java @@ -19,8 +19,6 @@ import java.io.File; import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.IgniteException; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; @@ -34,14 +32,14 @@ public class CacheCreateCommandArg extends IgniteDataTransferObject { /** */ @Argument(description = "Path to the Spring XML configuration that contains " + "'org.apache.ignite.configuration.CacheConfiguration' beans to create caches from", example = "springXmlConfigPath") - private String springxmlconfig; + String springxmlconfig; /** */ @Argument(description = "Optional flag to skip existing caches", optional = true) - private boolean skipExisting; + boolean skipExisting; /** */ - private String fileContent; + String fileContent; /** */ private void readFile() { @@ -59,20 +57,6 @@ private void readFile() { } } - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, springxmlconfig); - U.writeString(out, fileContent); - out.writeBoolean(skipExisting); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - springxmlconfig = U.readString(in); - fileContent = U.readString(in); - skipExisting = in.readBoolean(); - } - /** */ public String springxmlconfig() { return springxmlconfig; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheDestroyCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheDestroyCommandArg.java index f5d880d31d98f..ad54ac3a2fa16 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheDestroyCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheDestroyCommandArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management.cache; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.ArgumentGroup; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @ArgumentGroup(value = {"destroyAllCaches", "caches"}, onlyOneOf = true, optional = false) @@ -34,23 +30,11 @@ public class CacheDestroyCommandArg extends IgniteDataTransferObject { /** */ @Argument(description = "specifies a comma-separated list of cache names to be destroyed", example = "cache1,...,cacheN") - private String[] caches; + String[] caches; /** */ @Argument(description = "permanently destroy all user-created caches") - private boolean destroyAllCaches; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeArray(out, caches); - out.writeBoolean(destroyAllCaches); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - caches = U.readArray(in, String.class); - destroyAllCaches = in.readBoolean(); - } + boolean destroyAllCaches; /** */ public boolean destroyAllCaches() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheDistributionCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheDistributionCommandArg.java index 2f942ee7db3c0..eb4fae387ec5e 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheDistributionCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheDistributionCommandArg.java @@ -17,15 +17,11 @@ package org.apache.ignite.internal.management.cache; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.CommandUtils; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class CacheDistributionCommandArg extends IgniteDataTransferObject { @@ -35,35 +31,19 @@ public class CacheDistributionCommandArg extends IgniteDataTransferObject { /** */ @Positional @Argument(example = "nodeId|null") - private String nodeIdOrNull; + String nodeIdOrNull; /** */ @Positional @Argument(optional = true, example = "cacheName1,...,cacheNameN") - private String[] caches; + String[] caches; /** */ - private UUID nodeId; + UUID nodeId; /** */ @Argument(optional = true, example = "attrName1,...,attrNameN") - private String[] userAttributes; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, nodeIdOrNull); - U.writeArray(out, caches); - U.writeUuid(out, nodeId); - U.writeArray(out, userAttributes); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - nodeIdOrNull = U.readString(in); - caches = U.readArray(in, String.class); - nodeId = U.readUuid(in); - userAttributes = U.readArray(in, String.class); - } + String[] userAttributes; /** */ private void parse(String value) { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheFindGarbageCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheFindGarbageCommandArg.java index f842abf797613..f093611ad6c56 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheFindGarbageCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheFindGarbageCommandArg.java @@ -17,15 +17,11 @@ package org.apache.ignite.internal.management.cache; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.CommandUtils; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class CacheFindGarbageCommandArg extends IgniteDataTransferObject { @@ -35,22 +31,22 @@ public class CacheFindGarbageCommandArg extends IgniteDataTransferObject { /** */ @Positional @Argument(optional = true, example = "groupName1,...,groupNameN") - private String value; + String value; /** */ @Positional @Argument(optional = true, example = "nodeId") - private String value2; + String value2; /** */ - private String[] groups; + String[] groups; /** */ - private UUID[] nodeIds; + UUID[] nodeIds; /** */ @Argument(optional = true) - private boolean delete; + boolean delete; /** */ private void parse(String value) { @@ -66,24 +62,6 @@ private void parse(String value) { groups = CommandUtils.parseVal(value, String[].class); } - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, value); - U.writeString(out, value2); - U.writeArray(out, groups); - U.writeArray(out, nodeIds); - out.writeBoolean(delete); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - value = U.readString(in); - value2 = U.readString(in); - groups = U.readArray(in, String.class); - nodeIds = U.readArray(in, UUID.class); - delete = in.readBoolean(); - } - /** */ public UUID[] nodeIds() { return nodeIds; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIdleVerifyCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIdleVerifyCommandArg.java index 894cb0e2b3609..27ca7cd04eb1f 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIdleVerifyCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIdleVerifyCommandArg.java @@ -17,9 +17,6 @@ package org.apache.ignite.internal.management.cache; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; import org.apache.ignite.IgniteException; @@ -27,7 +24,6 @@ import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.EnumDescription; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; import static java.lang.String.format; @@ -39,20 +35,20 @@ public class CacheIdleVerifyCommandArg extends IgniteDataTransferObject { /** */ @Positional @Argument(optional = true, example = "cacheName1,...,cacheNameN") - private String[] caches; + String[] caches; /** */ @Argument(optional = true) - private boolean skipZeros; + boolean skipZeros; /** */ @Argument(description = "check the CRC-sum of pages stored on disk before verifying data consistency " + "in partitions between primary and backup nodes", optional = true) - private boolean checkCrc; + boolean checkCrc; /** */ @Argument(optional = true, example = "cacheName1,...,cacheNameN") - private String[] excludeCaches; + String[] excludeCaches; /** */ @Argument(optional = true, description = "Type of cache(s)") @@ -74,12 +70,15 @@ public class CacheIdleVerifyCommandArg extends IgniteDataTransferObject { "All" } ) - private CacheFilterEnum cacheFilter = CacheFilterEnum.DEFAULT; + CacheFilterEnum cacheFilter = CacheFilterEnum.DEFAULT; /** * @param string To validate that given name is valed regex. */ private void validateRegexes(String[] string) { + if (string == null) + return; + for (String s : string) { try { Pattern.compile(s); @@ -90,24 +89,6 @@ private void validateRegexes(String[] string) { } } - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeArray(out, caches); - out.writeBoolean(skipZeros); - out.writeBoolean(checkCrc); - U.writeArray(out, excludeCaches); - U.writeEnum(out, cacheFilter); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - caches = U.readArray(in, String.class); - skipZeros = in.readBoolean(); - checkCrc = in.readBoolean(); - excludeCaches = U.readArray(in, String.class); - cacheFilter = U.readEnum(in, CacheFilterEnum.class); - } - /** */ public String[] caches() { return caches; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIndexesForceRebuildCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIndexesForceRebuildCommandArg.java index a124a3c6802cb..c9aece2862342 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIndexesForceRebuildCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIndexesForceRebuildCommandArg.java @@ -17,14 +17,10 @@ package org.apache.ignite.internal.management.cache; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.ArgumentGroup; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @ArgumentGroup(value = {"nodeIds", "allNodes", "nodeId"}, onlyOneOf = true, optional = false) @@ -36,46 +32,28 @@ public class CacheIndexesForceRebuildCommandArg extends IgniteDataTransferObject /** */ @Argument(description = "Specify node for indexes rebuild (deprecated. Use --node-ids or --all-nodes instead)", example = "nodeId") - private UUID nodeId; + UUID nodeId; /** */ @Argument( description = "Comma-separated list of nodes ids to run index rebuild on", example = "nodeId1,...nodeIdN" ) - private UUID[] nodeIds; + UUID[] nodeIds; /** Flag to launch index rebuild on all nodes. */ @Argument(description = "Rebuild index on all nodes") - private boolean allNodes; + boolean allNodes; /** */ @Argument(description = "Comma-separated list of cache names for which indexes should be rebuilt", example = "cacheName1,...cacheNameN") - private String[] cacheNames; + String[] cacheNames; /** */ @Argument(description = "Comma-separated list of cache group names for which indexes should be rebuilt", example = "groupName1,...groupNameN") - private String[] groupNames; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeUuid(out, nodeId); - U.writeArray(out, cacheNames); - U.writeArray(out, groupNames); - U.writeArray(out, nodeIds); - out.writeBoolean(allNodes); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - nodeId = U.readUuid(in); - cacheNames = U.readArray(in, String.class); - groupNames = U.readArray(in, String.class); - nodeIds = U.readArray(in, UUID.class); - allNodes = in.readBoolean(); - } + String[] groupNames; /** */ public UUID nodeId() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIndexesListCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIndexesListCommandArg.java index 812dd52e3adbf..867f24de8395b 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIndexesListCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIndexesListCommandArg.java @@ -17,15 +17,11 @@ package org.apache.ignite.internal.management.cache; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class CacheIndexesListCommandArg extends IgniteDataTransferObject { @@ -37,28 +33,28 @@ public class CacheIndexesListCommandArg extends IgniteDataTransferObject { example = "nodeId", optional = true, description = "Specify node for job execution. If not specified explicitly, node will be chosen by grid") - private UUID nodeId; + UUID nodeId; /** */ @Argument( example = "grpRegExp", optional = true, description = "Regular expression allowing filtering by cache group name") - private String groupName; + String groupName; /** */ @Argument( example = "cacheRegExp", optional = true, description = "Regular expression allowing filtering by cache name") - private String cacheName; + String cacheName; /** */ @Argument( example = "idxNameRegExp", optional = true, description = "Regular expression allowing filtering by index name") - private String indexName; + String indexName; /** * @param regex Regex to validate @@ -75,22 +71,6 @@ private boolean validateRegEx(String name, String regex) { } } - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeUuid(out, nodeId); - U.writeString(out, groupName); - U.writeString(out, cacheName); - U.writeString(out, indexName); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - nodeId = U.readUuid(in); - groupName = U.readString(in); - cacheName = U.readString(in); - indexName = U.readString(in); - } - /** */ public UUID nodeId() { return nodeId; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIndexesRebuildStatusCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIndexesRebuildStatusCommandArg.java index 1c84bdbef3296..7c4316ea284e4 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIndexesRebuildStatusCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheIndexesRebuildStatusCommandArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management.cache; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class CacheIndexesRebuildStatusCommandArg extends IgniteDataTransferObject { @@ -35,17 +31,7 @@ public class CacheIndexesRebuildStatusCommandArg extends IgniteDataTransferObjec description = "Specify node for job execution. If not specified explicitly, info will be gathered from all nodes", example = "nodeId", optional = true) - private UUID nodeId; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeUuid(out, nodeId); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - nodeId = U.readUuid(in); - } + UUID nodeId; /** */ public UUID nodeId() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheListCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheListCommandArg.java index eedaac2da3355..d29292a67ced6 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheListCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheListCommandArg.java @@ -17,15 +17,11 @@ package org.apache.ignite.internal.management.cache; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.ArgumentGroup; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @ArgumentGroup(value = {"groups", "seq"}, onlyOneOf = true, optional = true) @@ -36,50 +32,30 @@ public class CacheListCommandArg extends IgniteDataTransferObject { /** */ @Positional @Argument(example = "regexPattern") - private String regex; + String regex; /** */ @Argument(description = "print all configuration parameters for each cache", optional = true) - private boolean config; + boolean config; /** */ @Positional @Argument(optional = true, example = "nodeId") - private UUID nodeId; + UUID nodeId; /** */ @Argument(description = "print configuration parameters per line. " + "This option has effect only when used with --config and without [--groups|--seq]", example = "multi-line", optional = true) - private String outputFormat; + String outputFormat; /** */ @Argument(description = "print information about groups") - private boolean groups; + boolean groups; /** */ @Argument(description = "print information about sequences") - private boolean seq; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, regex); - out.writeBoolean(config); - U.writeUuid(out, nodeId); - U.writeString(out, outputFormat); - out.writeBoolean(groups); - out.writeBoolean(seq); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - regex = U.readString(in); - config = in.readBoolean(); - nodeId = U.readUuid(in); - outputFormat = U.readString(in); - groups = in.readBoolean(); - seq = in.readBoolean(); - } + boolean seq; /** */ public String regex() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheMetricsCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheMetricsCommandArg.java index 624f7757f09df..786ead3b64fc1 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheMetricsCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheMetricsCommandArg.java @@ -17,15 +17,11 @@ package org.apache.ignite.internal.management.cache; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.ArgumentGroup; import org.apache.ignite.internal.management.api.EnumDescription; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @ArgumentGroup(value = {"caches", "allCaches"}, onlyOneOf = true, optional = false) @@ -48,30 +44,16 @@ public class CacheMetricsCommandArg extends IgniteDataTransferObject { "Status" } ) - private CacheMetricsOperation operation; + CacheMetricsOperation operation; /** */ @Argument(description = "specifies a comma-separated list of cache names to which operation should be applied", example = "cache1[,...,cacheN]") - private String[] caches; + String[] caches; /** */ @Argument(description = "applies operation to all user caches") - private boolean allCaches; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeEnum(out, operation); - U.writeArray(out, caches); - out.writeBoolean(allCaches); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - operation = U.readEnum(in, CacheMetricsOperation.class); - caches = U.readArray(in, String.class); - allCaches = in.readBoolean(); - } + boolean allCaches; /** */ public CacheMetricsOperation operation() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheResetLostPartitionsCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheResetLostPartitionsCommandArg.java index 391b615651937..8b0029016303b 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheResetLostPartitionsCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheResetLostPartitionsCommandArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management.cache; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class CacheResetLostPartitionsCommandArg extends IgniteDataTransferObject { @@ -33,17 +29,7 @@ public class CacheResetLostPartitionsCommandArg extends IgniteDataTransferObject /** */ @Positional @Argument(example = "cacheName1,...,cacheNameN") - private String[] caches; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeArray(out, caches); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - caches = U.readArray(in, String.class); - } + String[] caches; /** */ public String[] caches() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheScheduleIndexesRebuildCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheScheduleIndexesRebuildCommandArg.java index 3fc90052e1556..1f87a92395fac 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheScheduleIndexesRebuildCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheScheduleIndexesRebuildCommandArg.java @@ -17,9 +17,6 @@ package org.apache.ignite.internal.management.cache; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; @@ -33,7 +30,6 @@ import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.ArgumentGroup; import org.apache.ignite.internal.util.typedef.F; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @ArgumentGroup(value = {"nodeIds", "allNodes", "nodeId"}, onlyOneOf = true, optional = true) @@ -50,54 +46,34 @@ public class CacheScheduleIndexesRebuildCommandArg extends IgniteDataTransferObj description = "(Optional) Specify node for indexes rebuild. If not specified, schedules rebuild on all nodes " + "(deprecated. Use --node-ids or --all-nodes instead)", example = "nodeId") - private UUID nodeId; + UUID nodeId; /** */ @Argument( description = "Comma-separated list of nodes ids to schedule index rebuild on", example = "nodeId1,...nodeIdN" ) - private UUID[] nodeIds; + UUID[] nodeIds; /** Flag to launch index rebuild on all nodes. */ @Argument(description = "Rebuild index on all nodes") - private boolean allNodes; + boolean allNodes; /** */ @Argument(description = "Comma-separated list of cache names with optionally specified indexes. " + "If indexes are not specified then all indexes of the cache will be scheduled for the rebuild operation. " + "Can be used simultaneously with cache group names", example = "cacheName[index1,...indexN],cacheName2,cacheName3[index1]") - private String cacheNames; + String cacheNames; /** */ @Argument(description = "Comma-separated list of cache group names for which indexes should be scheduled for the " + "rebuild. Can be used simultaneously with cache names", example = "groupName1,groupName2,...groupNameN") - private String[] groupNames; + String[] groupNames; /** Cache name -> indexes. */ - private Map> cacheToIndexes; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeUuid(out, nodeId); - U.writeString(out, cacheNames); - U.writeArray(out, groupNames); - U.writeMap(out, cacheToIndexes); - U.writeArray(out, nodeIds); - out.writeBoolean(allNodes); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - nodeId = U.readUuid(in); - cacheNames = U.readString(in); - groupNames = U.readArray(in, String.class); - cacheToIndexes = U.readMap(in); - nodeIds = U.readArray(in, UUID.class); - allNodes = in.readBoolean(); - } + Map> cacheToIndexes; /** */ private void parse() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheValidateIndexesCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheValidateIndexesCommandArg.java index c186e436f7187..4db4893e64177 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheValidateIndexesCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/CacheValidateIndexesCommandArg.java @@ -17,15 +17,11 @@ package org.apache.ignite.internal.management.cache; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.CommandUtils; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class CacheValidateIndexesCommandArg extends IgniteDataTransferObject { @@ -35,34 +31,34 @@ public class CacheValidateIndexesCommandArg extends IgniteDataTransferObject { /** */ @Positional @Argument(example = "cacheName1,...,cacheNameN", optional = true) - private String value; + String value; /** */ @Positional @Argument(example = "nodeId", optional = true) - private String value2; + String value2; /** */ - private String[] caches; + String[] caches; /** */ - private UUID[] nodeIds; + UUID[] nodeIds; /** */ @Argument(example = "N", description = "validate only the first N keys", optional = true) - private int checkFirst = -1; + int checkFirst = -1; /** */ @Argument(example = "K", description = "validate every Kth key", optional = true) - private int checkThrough = -1; + int checkThrough = -1; /** */ @Argument(description = "check the CRC-sum of pages stored on disk", optional = true) - private boolean checkCrc; + boolean checkCrc; /** */ @Argument(description = "check that index size and cache size are the same", optional = true) - private boolean checkSizes; + boolean checkSizes; /** */ private static void ensurePositive(int numVal, String arg) { @@ -84,30 +80,6 @@ private void parse(String value) { caches = CommandUtils.parseVal(value, String[].class); } - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, value); - U.writeString(out, value2); - U.writeArray(out, caches); - U.writeArray(out, nodeIds); - out.writeInt(checkFirst); - out.writeInt(checkThrough); - out.writeBoolean(checkCrc); - out.writeBoolean(checkSizes); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - value = U.readString(in); - value2 = U.readString(in); - caches = U.readArray(in, String.class); - nodeIds = U.readArray(in, UUID.class); - checkFirst = in.readInt(); - checkThrough = in.readInt(); - checkCrc = in.readBoolean(); - checkSizes = in.readBoolean(); - } - /** */ public String value2() { return value2; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/scan/CacheScanCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/scan/CacheScanCommandArg.java index 3af1c1c821c0f..2c352b54c518a 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cache/scan/CacheScanCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cache/scan/CacheScanCommandArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management.cache.scan; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class CacheScanCommandArg extends IgniteDataTransferObject { @@ -36,29 +32,15 @@ public class CacheScanCommandArg extends IgniteDataTransferObject { /** */ @Positional @Argument(example = "cacheName") - private String cacheName; + String cacheName; /** */ @Argument(description = "Pluggable output format. 'default', 'table' exists by default", example = "table", optional = true) - private String outputFormat; + String outputFormat; /** */ @Argument(description = "limit count of entries to scan (" + DFLT_LIMIT + " by default)", example = "N", optional = true) - private int limit = DFLT_LIMIT; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, cacheName); - U.writeString(out, outputFormat); - out.writeInt(limit); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - cacheName = U.readString(in); - outputFormat = U.readString(in); - limit = in.readInt(); - } + int limit = DFLT_LIMIT; /** */ public String outputFormat() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cdc/CdcDeleteLostSegmentLinksCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cdc/CdcDeleteLostSegmentLinksCommandArg.java index 86a011020dbe0..2608e5ca6b9c8 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cdc/CdcDeleteLostSegmentLinksCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cdc/CdcDeleteLostSegmentLinksCommandArg.java @@ -17,14 +17,10 @@ package org.apache.ignite.internal.management.cdc; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.CliConfirmArgument; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @CliConfirmArgument @@ -35,17 +31,7 @@ public class CdcDeleteLostSegmentLinksCommandArg extends IgniteDataTransferObjec /** */ @Argument(optional = true, description = "ID of the node to delete lost segment links from. " + "If not set, the command will affect all server nodes") - private UUID nodeId; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeUuid(out, nodeId); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - nodeId = U.readUuid(in); - } + UUID nodeId; /** */ public UUID nodeId() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/cdc/CdcResendCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/cdc/CdcResendCommandArg.java index b2fa30bf59e19..c1dbbdaf7c39d 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/cdc/CdcResendCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/cdc/CdcResendCommandArg.java @@ -17,12 +17,8 @@ package org.apache.ignite.internal.management.cdc; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class CdcResendCommandArg extends IgniteDataTransferObject { @@ -34,17 +30,7 @@ public class CdcResendCommandArg extends IgniteDataTransferObject { description = "specifies a comma-separated list of cache names", example = "cache1,...,cacheN" ) - private String[] caches; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeArray(out, caches); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - caches = U.readArray(in, String.class); - } + String[] caches; /** */ public String[] caches() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/checkpoint/CheckpointCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/checkpoint/CheckpointCommandArg.java index f5f40c9a54961..620318a1b151d 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/checkpoint/CheckpointCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/checkpoint/CheckpointCommandArg.java @@ -17,12 +17,8 @@ package org.apache.ignite.internal.management.checkpoint; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; -import org.apache.ignite.internal.util.typedef.internal.U; /** Checkpoint command arguments. */ public class CheckpointCommandArg extends IgniteDataTransferObject { @@ -31,29 +27,15 @@ public class CheckpointCommandArg extends IgniteDataTransferObject { /** */ @Argument(description = "Reason (visible in logs)", optional = true) - private String reason; + String reason; /** */ @Argument(description = "Wait for checkpoint to finish", optional = true) - private boolean waitForFinish; + boolean waitForFinish; /** */ @Argument(description = "Timeout in milliseconds", optional = true) - private long timeout = -1; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, reason); - out.writeBoolean(waitForFinish); - out.writeLong(timeout); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - reason = U.readString(in); - waitForFinish = in.readBoolean(); - timeout = in.readLong(); - } + long timeout = -1; /** */ public String reason() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/consistency/ConsistencyRepairCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/consistency/ConsistencyRepairCommandArg.java index dba4bd6f74154..f71218aa3d370 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/consistency/ConsistencyRepairCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/consistency/ConsistencyRepairCommandArg.java @@ -17,14 +17,10 @@ package org.apache.ignite.internal.management.consistency; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.cache.ReadRepairStrategy; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.EnumDescription; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class ConsistencyRepairCommandArg extends IgniteDataTransferObject { @@ -33,11 +29,11 @@ public class ConsistencyRepairCommandArg extends IgniteDataTransferObject { /** */ @Argument(description = "Cache to be checked/repaired") - private String cache; + String cache; /** */ @Argument(description = "Cache's partition to be checked/repaired", example = "partition") - private int[] partitions; + int[] partitions; /** Strategy. */ @Argument(description = "Repair strategy") @@ -61,7 +57,7 @@ public class ConsistencyRepairCommandArg extends IgniteDataTransferObject { /** */ @Argument(description = "Run concurrently on each node", optional = true) - private boolean parallel; + boolean parallel; /** */ public void ensureParams() { @@ -72,22 +68,6 @@ public void ensureParams() { } } - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, cache); - U.writeIntArray(out, partitions); - U.writeEnum(out, strategy); - out.writeBoolean(parallel); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - cache = U.readString(in); - partitions = U.readIntArray(in); - strategy = U.readEnum(in, ReadRepairStrategy.class); - parallel = in.readBoolean(); - } - /** */ public int[] partitions() { return partitions; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/defragmentation/DefragmentationScheduleCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/defragmentation/DefragmentationScheduleCommandArg.java index 682e2f9d2cb0c..21b6612d19932 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/defragmentation/DefragmentationScheduleCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/defragmentation/DefragmentationScheduleCommandArg.java @@ -17,12 +17,8 @@ package org.apache.ignite.internal.management.defragmentation; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.defragmentation.DefragmentationCommand.DefragmentationStatusCommandArg; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class DefragmentationScheduleCommandArg extends DefragmentationStatusCommandArg { @@ -31,27 +27,11 @@ public class DefragmentationScheduleCommandArg extends DefragmentationStatusComm /** */ @Argument(example = "consistentId0,consistentId1") - private String[] nodes; + String[] nodes; /** */ @Argument(example = "cache1,cache2,cache3", optional = true) - private String[] caches; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - super.writeExternalData(out); - - U.writeArray(out, nodes); - U.writeArray(out, caches); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - super.readExternalData(in); - - nodes = U.readArray(in, String.class); - caches = U.readArray(in, String.class); - } + String[] caches; /** */ public String[] nodes() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/diagnostic/DiagnosticPagelocksCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/diagnostic/DiagnosticPagelocksCommandArg.java index 8bb42454571dc..de30e8f726059 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/diagnostic/DiagnosticPagelocksCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/diagnostic/DiagnosticPagelocksCommandArg.java @@ -17,15 +17,11 @@ package org.apache.ignite.internal.management.diagnostic; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.ArgumentGroup; import org.apache.ignite.internal.management.api.EnumDescription; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; import static org.apache.ignite.internal.management.diagnostic.Operation.DUMP_LOG; @@ -48,22 +44,22 @@ public class DiagnosticPagelocksCommandArg extends IgniteDataTransferObject { "Print page locks dump to console" } ) - private Operation operation = DUMP_LOG; + Operation operation = DUMP_LOG; /** */ @Argument(optional = true) - private String path; + String path; /** Run command for all nodes. */ @Argument(description = "Run for all nodes") - private boolean all; + boolean all; /** */ @Argument( description = "Comma separated list of node ids or consistent ids", example = "node_id1[,node_id2....node_idN]|consistend_id1[,consistent_id2,....,consistent_idN]" ) - private String[] nodes; + String[] nodes; /** */ private void ensureOperationAndPath(Operation op, String path) { @@ -71,22 +67,6 @@ private void ensureOperationAndPath(Operation op, String path) { throw new IllegalArgumentException("Path can be specified only in DUMP mode."); } - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeEnum(out, operation); - U.writeString(out, path); - out.writeBoolean(all); - U.writeArray(out, nodes); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - operation = U.readEnum(in, Operation.class); - path = U.readString(in); - all = in.readBoolean(); - nodes = U.readArray(in, String.class); - } - /** */ public String[] nodes() { return nodes; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/encryption/EncryptionCacheGroupArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/encryption/EncryptionCacheGroupArg.java index acc5661baaf98..90673574cb19a 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/encryption/EncryptionCacheGroupArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/encryption/EncryptionCacheGroupArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management.encryption; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class EncryptionCacheGroupArg extends IgniteDataTransferObject { @@ -33,17 +29,7 @@ public class EncryptionCacheGroupArg extends IgniteDataTransferObject { /** */ @Positional @Argument(example = "cacheGroupName") - private String cacheGroupName; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, cacheGroupName); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - cacheGroupName = U.readString(in); - } + String cacheGroupName; /** */ public String cacheGroupName() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/encryption/EncryptionChangeMasterKeyCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/encryption/EncryptionChangeMasterKeyCommandArg.java index 1afd5d321a5d9..dbc92e7868be0 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/encryption/EncryptionChangeMasterKeyCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/encryption/EncryptionChangeMasterKeyCommandArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management.encryption; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class EncryptionChangeMasterKeyCommandArg extends IgniteDataTransferObject { @@ -33,17 +29,7 @@ public class EncryptionChangeMasterKeyCommandArg extends IgniteDataTransferObjec /** */ @Positional @Argument(example = "newMasterKeyName") - private String newMasterKeyName; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, newMasterKeyName); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - newMasterKeyName = U.readString(in); - } + String newMasterKeyName; /** */ public String newMasterKeyName() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/encryption/EncryptionReencryptionRateLimitCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/encryption/EncryptionReencryptionRateLimitCommandArg.java index 60dc932f02672..02c76cd9cd350 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/encryption/EncryptionReencryptionRateLimitCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/encryption/EncryptionReencryptionRateLimitCommandArg.java @@ -17,9 +17,6 @@ package org.apache.ignite.internal.management.encryption; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; @@ -32,17 +29,7 @@ public class EncryptionReencryptionRateLimitCommandArg extends IgniteDataTransfe /** */ @Positional @Argument(optional = true, description = "Decimal value to change re-encryption rate limit (MB/s)") - private Double newLimit; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - out.writeObject(newLimit); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - newLimit = (Double)in.readObject(); - } + Double newLimit; /** */ public Double newLimit() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/encryption/EncryptionReencryptionStatusCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/encryption/EncryptionReencryptionStatusCommandArg.java deleted file mode 100644 index e418d6594969c..0000000000000 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/encryption/EncryptionReencryptionStatusCommandArg.java +++ /dev/null @@ -1,47 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.ignite.internal.management.encryption; - -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; -import org.apache.ignite.internal.dto.IgniteDataTransferObject; -import org.apache.ignite.internal.management.api.Argument; -import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; - -/** */ -public class EncryptionReencryptionStatusCommandArg extends IgniteDataTransferObject { - /** */ - private static final long serialVersionUID = 0; - - /** */ - @Positional - @Argument(example = "cacheGroupName") - private String cacheGroupName; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, cacheGroupName); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - cacheGroupName = U.readString(in); - } -} diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillClientCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillClientCommandArg.java index 57cf89df4e20c..abd4d9d0579a4 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillClientCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillClientCommandArg.java @@ -17,14 +17,10 @@ package org.apache.ignite.internal.management.kill; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class KillClientCommandArg extends IgniteDataTransferObject { @@ -34,23 +30,11 @@ public class KillClientCommandArg extends IgniteDataTransferObject { /** */ @Positional @Argument(description = "Connection identifier or ALL") - private String connectionId; + String connectionId; /** */ @Argument(description = "Node id to drop connection from", optional = true) - private UUID nodeId; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, connectionId); - U.writeUuid(out, nodeId); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - connectionId = U.readString(in); - nodeId = U.readUuid(in); - } + UUID nodeId; /** */ public String connectionId() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillComputeCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillComputeCommandArg.java index 7dcd9f63fe83e..0e901e6e6a96a 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillComputeCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillComputeCommandArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management.kill; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.lang.IgniteUuid; /** */ @@ -34,17 +30,7 @@ public class KillComputeCommandArg extends IgniteDataTransferObject { /** */ @Positional @Argument(description = "Session identifier") - private IgniteUuid sessionId; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeIgniteUuid(out, sessionId); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - sessionId = U.readIgniteUuid(in); - } + IgniteUuid sessionId; /** */ public IgniteUuid sessionId() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillContinuousCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillContinuousCommandArg.java index 01c8be66db5bf..5d08942a0b38b 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillContinuousCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillContinuousCommandArg.java @@ -17,14 +17,10 @@ package org.apache.ignite.internal.management.kill; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class KillContinuousCommandArg extends IgniteDataTransferObject { @@ -34,24 +30,12 @@ public class KillContinuousCommandArg extends IgniteDataTransferObject { /** */ @Positional @Argument(description = "Originating node id") - private UUID originNodeId; + UUID originNodeId; /** */ @Positional @Argument(description = "Routine identifier") - private UUID routineId; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeUuid(out, originNodeId); - U.writeUuid(out, routineId); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - originNodeId = U.readUuid(in); - routineId = U.readUuid(in); - } + UUID routineId; /** */ public UUID originNodeId() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillScanCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillScanCommandArg.java index f71484f9a21f7..63b463436ca13 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillScanCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillScanCommandArg.java @@ -17,14 +17,10 @@ package org.apache.ignite.internal.management.kill; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class KillScanCommandArg extends IgniteDataTransferObject { @@ -34,31 +30,17 @@ public class KillScanCommandArg extends IgniteDataTransferObject { /** */ @Positional @Argument(description = "Originating node id") - private UUID originNodeId; + UUID originNodeId; /** */ @Positional @Argument(description = "Cache name") - private String cacheName; + String cacheName; /** */ @Positional @Argument(description = "Query identifier") - private long queryId; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeUuid(out, originNodeId); - U.writeString(out, cacheName); - out.writeLong(queryId); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - originNodeId = U.readUuid(in); - cacheName = U.readString(in); - queryId = in.readLong(); - } + long queryId; /** */ public UUID originNodeId() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillServiceCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillServiceCommandArg.java index 45fbcf7e63a75..70228b69442ee 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillServiceCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillServiceCommandArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management.kill; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class KillServiceCommandArg extends IgniteDataTransferObject { @@ -33,17 +29,7 @@ public class KillServiceCommandArg extends IgniteDataTransferObject { /** */ @Positional @Argument(description = "Service name") - private String name; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, name); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - name = U.readString(in); - } + String name; /** */ public String name() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillSnapshotCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillSnapshotCommandArg.java index d24c494b984a8..cd727bb6115bf 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillSnapshotCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillSnapshotCommandArg.java @@ -17,14 +17,10 @@ package org.apache.ignite.internal.management.kill; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; import org.apache.ignite.internal.management.kill.SnapshotCancelTask.CancelSnapshotArg; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class KillSnapshotCommandArg extends CancelSnapshotArg { @@ -34,22 +30,10 @@ public class KillSnapshotCommandArg extends CancelSnapshotArg { /** */ @Positional @Argument(description = "Request id") - private UUID requestId; + UUID requestId; /** */ - private String snapshotName; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeUuid(out, requestId); - U.writeString(out, snapshotName); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - requestId = U.readUuid(in); - snapshotName = U.readString(in); - } + String snapshotName; /** {@inheritDoc} */ @Override public UUID requestId() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillSqlCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillSqlCommandArg.java index 95bcbc0dc374c..a06b265bdbf3d 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillSqlCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillSqlCommandArg.java @@ -17,15 +17,12 @@ package org.apache.ignite.internal.management.kill; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; import org.apache.ignite.internal.util.typedef.T2; -import org.apache.ignite.internal.util.typedef.internal.U; + import static org.apache.ignite.internal.QueryMXBeanImpl.EXPECTED_GLOBAL_QRY_ID_FORMAT; import static org.apache.ignite.internal.sql.command.SqlKillQueryCommand.parseGlobalQueryId; @@ -37,27 +34,13 @@ public class KillSqlCommandArg extends IgniteDataTransferObject { /** */ @Positional @Argument(description = "Query identifier") - private String queryId; + String queryId; /** */ - private UUID nodeId; + UUID nodeId; /** */ - private long qryId; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, queryId); - U.writeUuid(out, nodeId); - out.writeLong(qryId); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - queryId = U.readString(in); - nodeId = U.readUuid(in); - qryId = in.readLong(); - } + long qryId; /** */ public UUID nodeId() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillTransactionCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillTransactionCommandArg.java index 16aff9e5d4999..916028aa43450 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillTransactionCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/kill/KillTransactionCommandArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management.kill; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class KillTransactionCommandArg extends IgniteDataTransferObject { @@ -33,17 +29,7 @@ public class KillTransactionCommandArg extends IgniteDataTransferObject { /** */ @Positional @Argument(description = "Transaction identifier") - private String xid; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, xid); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - xid = U.readString(in); - } + String xid; /** */ public String xid() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/meta/MetaDetailsCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/meta/MetaDetailsCommandArg.java index fb72f57cb0c57..e280e4a2af5b2 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/meta/MetaDetailsCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/meta/MetaDetailsCommandArg.java @@ -17,13 +17,10 @@ package org.apache.ignite.internal.management.meta; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.ArgumentGroup; -import org.apache.ignite.internal.util.typedef.internal.U; + import static org.apache.ignite.internal.management.meta.MetaListCommand.printInt; /** */ @@ -34,23 +31,11 @@ public class MetaDetailsCommandArg extends IgniteDataTransferObject { /** */ @Argument(optional = true, example = "", javaStyleName = true) - private int typeId; + int typeId; /** */ @Argument(optional = true, example = "", javaStyleName = true) - private String typeName; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - out.writeInt(typeId); - U.writeString(out, typeName); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - typeId = in.readInt(); - typeName = U.readString(in); - } + String typeName; /** */ public int typeId() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/meta/MetaRemoveCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/meta/MetaRemoveCommandArg.java index 8231eea68dd37..6b343c9cbc5ef 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/meta/MetaRemoveCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/meta/MetaRemoveCommandArg.java @@ -18,15 +18,12 @@ package org.apache.ignite.internal.management.meta; import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.io.OutputStream; import java.nio.file.FileSystems; import java.nio.file.Files; import java.nio.file.Path; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.ArgumentGroup; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @ArgumentGroup(value = {"typeId", "typeName"}, onlyOneOf = true, optional = false) @@ -36,21 +33,7 @@ public class MetaRemoveCommandArg extends MetaDetailsCommandArg { /** */ @Argument(optional = true, example = "") - private String out; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - super.writeExternalData(out); - - U.writeString(out, this.out); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - super.readExternalData(in); - - out = U.readString(in); - } + String out; /** */ public String out() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/meta/MetaUpdateCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/meta/MetaUpdateCommandArg.java index 811b5a042fed2..5e3ceabeb8a93 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/meta/MetaUpdateCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/meta/MetaUpdateCommandArg.java @@ -20,8 +20,6 @@ import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.nio.file.FileSystems; import java.nio.file.Files; import java.nio.file.Path; @@ -36,22 +34,10 @@ public class MetaUpdateCommandArg extends IgniteDataTransferObject { /** */ @Argument(example = "") - private String in; + String in; /** Marshaled metadata. */ - private byte[] metaMarshalled; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, in); - U.writeByteArray(out, metaMarshalled); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - this.in = U.readString(in); - metaMarshalled = U.readByteArray(in); - } + byte[] metaMarshalled; /** */ public byte[] metaMarshalled() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricCommandArg.java index 560e867b0fa6a..2725723fa7543 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricCommandArg.java @@ -17,14 +17,10 @@ package org.apache.ignite.internal.management.metric; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class MetricCommandArg extends IgniteDataTransferObject { @@ -34,23 +30,11 @@ public class MetricCommandArg extends IgniteDataTransferObject { /** */ @Argument(description = "Name of the metric") @Positional - private String name; + String name; /** */ @Argument(description = "Node id", optional = true) - private UUID nodeId; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, name); - U.writeUuid(out, nodeId); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - name = U.readString(in); - nodeId = U.readUuid(in); - } + UUID nodeId; /** */ public UUID nodeId() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricConfigureHistogramCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricConfigureHistogramCommandArg.java index 793e07beb3b0c..cfedb633f9672 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricConfigureHistogramCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricConfigureHistogramCommandArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management.metric; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; import org.apache.ignite.internal.util.typedef.F; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class MetricConfigureHistogramCommandArg extends MetricCommandArg { @@ -33,21 +29,7 @@ public class MetricConfigureHistogramCommandArg extends MetricCommandArg { /** */ @Argument(description = "Comma-separated list of longs to configure histogram", example = "newBounds") @Positional - private long[] newBounds; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - super.writeExternalData(out); - - U.writeLongArray(out, newBounds); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - super.readExternalData(in); - - newBounds = U.readLongArray(in); - } + long[] newBounds; /** */ public long[] newBounds() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricConfigureHitrateCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricConfigureHitrateCommandArg.java index a54f52b592233..4e9ea0286a6b5 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricConfigureHitrateCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricConfigureHitrateCommandArg.java @@ -17,9 +17,6 @@ package org.apache.ignite.internal.management.metric; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; @@ -31,21 +28,7 @@ public class MetricConfigureHitrateCommandArg extends MetricCommandArg { /** */ @Argument(description = "Rate time interval of hitrate", example = "newRateTimeInterval") @Positional - private long newRateTimeInterval; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - super.writeExternalData(out); - - out.writeLong(newRateTimeInterval); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - super.readExternalData(in); - - newRateTimeInterval = in.readLong(); - } + long newRateTimeInterval; /** */ public long newRateTimeInterval() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricConfigureMaxValueCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricConfigureMaxValueCommandArg.java index 09ae7ee95a07b..abd93cac7468e 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricConfigureMaxValueCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/metric/MetricConfigureMaxValueCommandArg.java @@ -31,7 +31,7 @@ public class MetricConfigureMaxValueCommandArg extends MetricCommandArg { /** */ @Argument(description = "Time interval of the metric", example = "newTimeInterval") @Positional - private long newTimeInterval; + long newTimeInterval; /** {@inheritDoc} */ @Override protected void writeExternalData(ObjectOutput out) throws IOException { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/persistence/PersistenceBackupCachesTaskArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/persistence/PersistenceBackupCachesTaskArg.java index 579de355f7be3..0d834ef41f247 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/persistence/PersistenceBackupCachesTaskArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/persistence/PersistenceBackupCachesTaskArg.java @@ -17,12 +17,8 @@ package org.apache.ignite.internal.management.persistence; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class PersistenceBackupCachesTaskArg extends PersistenceCommand.PersistenceTaskArg { @@ -32,21 +28,7 @@ public class PersistenceBackupCachesTaskArg extends PersistenceCommand.Persisten /** */ @Positional @Argument(example = "cache1,cache2,cache3") - private String[] caches; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - super.writeExternalData(out); - - U.writeArray(out, caches); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - super.readExternalData(in); - - caches = U.readArray(in, String.class); - } + String[] caches; /** */ public String[] caches() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/persistence/PersistenceCleanCachesTaskArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/persistence/PersistenceCleanCachesTaskArg.java index 2d503799d702c..f0b537f0d732e 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/persistence/PersistenceCleanCachesTaskArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/persistence/PersistenceCleanCachesTaskArg.java @@ -17,12 +17,8 @@ package org.apache.ignite.internal.management.persistence; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class PersistenceCleanCachesTaskArg extends PersistenceCommand.PersistenceTaskArg { @@ -32,21 +28,7 @@ public class PersistenceCleanCachesTaskArg extends PersistenceCommand.Persistenc /** */ @Positional @Argument(example = "cache1,cache2,cache3") - private String[] caches; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - super.writeExternalData(out); - - U.writeArray(out, caches); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - super.readExternalData(in); - - caches = U.readArray(in, String.class); - } + String[] caches; /** */ public String[] caches() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/property/PropertyGetCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/property/PropertyGetCommandArg.java index 3c3a7adc658d7..6aae6f9adae4b 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/property/PropertyGetCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/property/PropertyGetCommandArg.java @@ -17,12 +17,8 @@ package org.apache.ignite.internal.management.property; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class PropertyGetCommandArg extends IgniteDataTransferObject { @@ -31,17 +27,7 @@ public class PropertyGetCommandArg extends IgniteDataTransferObject { /** */ @Argument(example = "") - private String name; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, name); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - name = U.readString(in); - } + String name; /** */ public String name() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/property/PropertyListCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/property/PropertyListCommandArg.java index 6f7ecfd8d1f90..7997c8164c191 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/property/PropertyListCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/property/PropertyListCommandArg.java @@ -17,9 +17,6 @@ package org.apache.ignite.internal.management.property; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; @@ -30,17 +27,7 @@ public class PropertyListCommandArg extends IgniteDataTransferObject { /** */ @Argument(optional = true, description = "Print detailed information: name, value, description") - private boolean info; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - out.writeBoolean(info); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - info = in.readBoolean(); - } + boolean info; /** */ public boolean info() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/property/PropertySetCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/property/PropertySetCommandArg.java index 01d777af16032..6954e770995da 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/property/PropertySetCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/property/PropertySetCommandArg.java @@ -17,11 +17,7 @@ package org.apache.ignite.internal.management.property; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.management.api.Argument; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class PropertySetCommandArg extends PropertyGetCommandArg { @@ -30,21 +26,7 @@ public class PropertySetCommandArg extends PropertyGetCommandArg { /** */ @Argument(example = "") - private String val; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - super.writeExternalData(out); - - U.writeString(out, val); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - super.readExternalData(in); - - val = U.readString(in); - } + String val; /** */ public String val() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/rollingupgrade/RollingUpgradeEnableCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/rollingupgrade/RollingUpgradeEnableCommandArg.java index 16cccf4eafe67..b11016a052e0b 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/rollingupgrade/RollingUpgradeEnableCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/rollingupgrade/RollingUpgradeEnableCommandArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management.rollingupgrade; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** Rolling upgrade enable command argument. */ public class RollingUpgradeEnableCommandArg extends IgniteDataTransferObject { @@ -34,12 +30,12 @@ public class RollingUpgradeEnableCommandArg extends IgniteDataTransferObject { @Positional @Argument(description = "Target Ignite version. The target version can be one minor higher if its maintenance version is zero, " + "or one maintenance version higher (e.g. 2.18.0 -> 2.18.1 or 2.18.1 -> 2.19.0)") - private String targetVersion; + String targetVersion; /** Force flag. */ @Argument(description = "Enable rolling upgrade without target version checks." + " Use only when required, if the upgrade cannot proceed otherwise", optional = true) - private boolean force; + boolean force; /** */ public String targetVersion() { @@ -60,16 +56,4 @@ public boolean force() { public void force(boolean force) { this.force = force; } - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, targetVersion); - out.writeBoolean(force); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - targetVersion = U.readString(in); - force = in.readBoolean(); - } } diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotCancelCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotCancelCommandArg.java index 68462aead81f8..58ea346dff7ce 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotCancelCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotCancelCommandArg.java @@ -17,14 +17,10 @@ package org.apache.ignite.internal.management.snapshot; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.UUID; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.ArgumentGroup; import org.apache.ignite.internal.management.kill.SnapshotCancelTask.CancelSnapshotArg; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @ArgumentGroup(value = {"id", "name"}, optional = false, onlyOneOf = true) @@ -34,23 +30,11 @@ public class SnapshotCancelCommandArg extends CancelSnapshotArg { /** */ @Argument(description = "Snapshot operation request ID", optional = true) - private UUID id; + UUID id; /** */ @Argument(description = "Snapshot name (deprecated)", optional = true) - private String name; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeUuid(out, id); - U.writeString(out, name); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - id = U.readUuid(in); - name = U.readString(in); - } + String name; /** */ public UUID id() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotCheckCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotCheckCommandArg.java index 294fa54f7749f..3ef670e98e55c 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotCheckCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotCheckCommandArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management.snapshot; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class SnapshotCheckCommandArg extends IgniteDataTransferObject { @@ -34,33 +30,19 @@ public class SnapshotCheckCommandArg extends IgniteDataTransferObject { @Positional @Argument(description = "Snapshot name. " + "In case incremental snapshot (--incremental) full snapshot name must be provided") - private String snapshotName; + String snapshotName; /** */ @Argument(example = "path", optional = true, description = "Path to the directory where the snapshot files are located. " + "If not specified, the default configured snapshot directory will be used") - private String src; + String src; /** */ @Argument(example = "incrementIndex", optional = true, description = "Incremental snapshot index. " + "The command will check incremental snapshots sequentially from 1 to the specified index") - private int increment; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, snapshotName); - U.writeString(out, src); - out.writeInt(increment); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - snapshotName = U.readString(in); - src = U.readString(in); - increment = in.readInt(); - } + int increment; /** */ public String snapshotName() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotCreateCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotCreateCommandArg.java index f933cc4c67135..74f6617b17e31 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotCreateCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotCreateCommandArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management.snapshot; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class SnapshotCreateCommandArg extends IgniteDataTransferObject { @@ -34,40 +30,24 @@ public class SnapshotCreateCommandArg extends IgniteDataTransferObject { @Positional @Argument(description = "Snapshot name. " + "In the case of incremental snapshot (--incremental) full snapshot name must be provided") - private String snapshotName; + String snapshotName; /** */ @Argument(example = "path", optional = true, description = "Path to the directory where the snapshot will be saved. " + "If not specified, the default configured snapshot directory will be used") - private String dest; + String dest; /** */ @Argument(optional = true, description = "Run the operation synchronously, " + "the command will wait for the entire operation to complete. " + "Otherwise, it will be performed in the background, and the command will immediately return control") - private boolean sync; + boolean sync; /** */ @Argument(optional = true, description = "Create an incremental snapshot for previously created full snapshot. " + "Full snapshot must be accessible via --dest and snapshot_name") - private boolean incremental; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, snapshotName); - U.writeString(out, dest); - out.writeBoolean(sync); - out.writeBoolean(incremental); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - snapshotName = U.readString(in); - dest = U.readString(in); - sync = in.readBoolean(); - incremental = in.readBoolean(); - } + boolean incremental; /** */ public String snapshotName() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotRestoreCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotRestoreCommandArg.java index 4b79fd77ca2db..7ae6da790f995 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotRestoreCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/snapshot/SnapshotRestoreCommandArg.java @@ -17,14 +17,10 @@ package org.apache.ignite.internal.management.snapshot; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.ArgumentGroup; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @@ -37,45 +33,45 @@ public class SnapshotRestoreCommandArg extends IgniteDataTransferObject { @Positional @Argument(description = "Snapshot name. " + "In the case of incremental snapshot (--incremental) full snapshot name must be provided") - private String snapshotName; + String snapshotName; /** */ @Argument(optional = true, example = "incrementIndex", description = "Incremental snapshot index. " + "The command will restore snapshot and after that all its increments sequentially from 1 to the specified index") - private int increment; + int increment; /** */ @Argument(optional = true, description = "Cache group names", example = "group1,...groupN") - private String[] groups; + String[] groups; /** */ @Argument(example = "path", optional = true, description = "Path to the directory where the snapshot files are located. " + "If not specified, the default configured snapshot directory will be used") - private String src; + String src; /** */ @Argument(optional = true, description = "Run the operation synchronously, " + "the command will wait for the entire operation to complete. " + "Otherwise, it will be performed in the background, and the command will immediately return control") - private boolean sync; + boolean sync; /** */ @Argument(optional = true, description = "Check snapshot data integrity before restore (slow!). Similar to the \"check\" command") - private boolean check; + boolean check; /** */ @Argument(description = "Snapshot restore operation status (Command deprecated. Use '--snapshot status' instead)") - private boolean status; + boolean status; /** */ @Argument(description = "Cancel snapshot restore operation (Command deprecated. Use '--snapshot cancel' instead)") - private boolean cancel; + boolean cancel; /** */ @Argument(description = "Start snapshot restore operation (Default action)") - private boolean start; + boolean start; /** */ public void ensureOptions() { @@ -89,32 +85,6 @@ public void ensureOptions() { throw new IllegalArgumentException("--sync and --status can't be used together"); } - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, snapshotName); - out.writeInt(increment); - U.writeArray(out, groups); - U.writeString(out, src); - out.writeBoolean(sync); - out.writeBoolean(check); - out.writeBoolean(status); - out.writeBoolean(cancel); - out.writeBoolean(start); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - snapshotName = U.readString(in); - increment = in.readInt(); - groups = U.readArray(in, String.class); - src = U.readString(in); - sync = in.readBoolean(); - check = in.readBoolean(); - status = in.readBoolean(); - cancel = in.readBoolean(); - start = in.readBoolean(); - } - /** */ public boolean start() { return start; diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationCommand.java b/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationCommand.java index 82dc5477a348f..afd2479ed9367 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationCommand.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationCommand.java @@ -17,9 +17,6 @@ package org.apache.ignite.internal.management.tracing; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.Collection; import java.util.function.Consumer; import org.apache.ignite.cluster.ClusterNode; @@ -79,16 +76,6 @@ public TracingConfigurationCommand() { public abstract static class TracingConfigurationCommandArg extends IgniteDataTransferObject { /** */ private static final long serialVersionUID = 0; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - // No-op. - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - // No-op. - } } /** */ diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationGetAllCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationGetAllCommandArg.java index 7eac6fbebb35e..fa014c3b49328 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationGetAllCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationGetAllCommandArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management.tracing; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.EnumDescription; import org.apache.ignite.internal.management.tracing.TracingConfigurationCommand.TracingConfigurationCommandArg; -import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.spi.tracing.Scope; /** */ @@ -49,21 +45,7 @@ public class TracingConfigurationGetAllCommandArg extends TracingConfigurationCo "SQL scope" } ) - private Scope scope; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - super.writeExternalData(out); - - U.writeEnum(out, scope); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - super.readExternalData(in); - - scope = U.readEnum(in, Scope.class); - } + Scope scope; /** */ public Scope scope() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationGetCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationGetCommandArg.java index 20218668a3b4a..559c2f6e314df 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationGetCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationGetCommandArg.java @@ -17,13 +17,9 @@ package org.apache.ignite.internal.management.tracing; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.EnumDescription; import org.apache.ignite.internal.management.tracing.TracingConfigurationCommand.TracingConfigurationCommandArg; -import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.spi.tracing.Scope; /** */ @@ -49,27 +45,11 @@ public class TracingConfigurationGetCommandArg extends TracingConfigurationComma "SQL scope" } ) - private Scope scope; + Scope scope; /** */ @Argument(optional = true) - private String label; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - super.writeExternalData(out); - - U.writeEnum(out, scope); - U.writeString(out, label); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - super.readExternalData(in); - - scope = U.readEnum(in, Scope.class); - label = U.readString(in); - } + String label; /** */ public Scope scope() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationSetCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationSetCommandArg.java index afe7be4147bfb..688959a7a5c04 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationSetCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/tracing/TracingConfigurationSetCommandArg.java @@ -17,12 +17,9 @@ package org.apache.ignite.internal.management.tracing; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.management.api.Argument; -import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.spi.tracing.Scope; + import static org.apache.ignite.spi.tracing.TracingConfigurationParameters.SAMPLING_RATE_ALWAYS; import static org.apache.ignite.spi.tracing.TracingConfigurationParameters.SAMPLING_RATE_NEVER; @@ -34,27 +31,11 @@ public class TracingConfigurationSetCommandArg extends TracingConfigurationGetCo /** */ @Argument(optional = true, example = "Decimal value between 0 and 1, where 0 means never and 1 means always. " + "More or less reflects the probability of sampling specific trace.") - private double samplingRate; + double samplingRate; /** */ @Argument(optional = true, example = "Set of scopes with comma as separator DISCOVERY|EXCHANGE|COMMUNICATION|TX|SQL") - private Scope[] includedScopes; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - super.writeExternalData(out); - - out.writeDouble(samplingRate); - U.writeArray(out, includedScopes); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - super.readExternalData(in); - - samplingRate = in.readDouble(); - includedScopes = U.readArray(in, Scope.class); - } + Scope[] includedScopes; /** */ public double samplingRate() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/tx/TxCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/tx/TxCommandArg.java index 307c4a98f4434..42d48d6be18e5 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/tx/TxCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/tx/TxCommandArg.java @@ -17,9 +17,6 @@ package org.apache.ignite.internal.management.tx; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; import org.apache.ignite.internal.management.api.Argument; @@ -27,7 +24,6 @@ import org.apache.ignite.internal.management.api.CliConfirmArgument; import org.apache.ignite.internal.management.api.EnumDescription; import org.apache.ignite.internal.util.typedef.internal.A; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @CliConfirmArgument @@ -38,35 +34,35 @@ public class TxCommandArg extends TxCommand.AbstractTxCommandArg { /** */ @Argument(example = "XID", optional = true) - private String xid; + String xid; /** */ @Argument(example = "SECONDS", optional = true) - private Long minDuration; + Long minDuration; /** */ @Argument(example = "SIZE", optional = true) - private Integer minSize; + Integer minSize; /** */ @Argument(example = "PATTERN_REGEX", optional = true) - private String label; + String label; /** */ @Argument - private boolean servers; + boolean servers; /** */ @Argument - private boolean clients; + boolean clients; /** */ @Argument(example = "consistentId1[,consistentId2,....,consistentIdN]") - private String[] nodes; + String[] nodes; /** */ @Argument(optional = true, example = "NUMBER") - private Integer limit; + Integer limit; /** */ @Argument(optional = true, description = "Output order") @@ -82,39 +78,11 @@ public class TxCommandArg extends TxCommand.AbstractTxCommandArg { "Sort by start time" } ) - private TxSortOrder order; + TxSortOrder order; /** */ @Argument(optional = true) - private boolean kill; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, xid); - out.writeObject(minDuration); - out.writeObject(minSize); - U.writeString(out, label); - out.writeBoolean(servers); - out.writeBoolean(clients); - U.writeArray(out, nodes); - out.writeObject(limit); - U.writeEnum(out, order); - out.writeBoolean(kill); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - xid = U.readString(in); - minDuration = (Long)in.readObject(); - minSize = (Integer)in.readObject(); - label = U.readString(in); - servers = in.readBoolean(); - clients = in.readBoolean(); - nodes = U.readArray(in, String.class); - limit = (Integer)in.readObject(); - order = U.readEnum(in, TxSortOrder.class); - kill = in.readBoolean(); - } + boolean kill; /** */ public String xid() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/tx/TxInfoCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/tx/TxInfoCommandArg.java index 2edf59b8cdcd7..d2f6dd31d6977 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/tx/TxInfoCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/tx/TxInfoCommandArg.java @@ -17,15 +17,11 @@ package org.apache.ignite.internal.management.tx; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.Positional; import org.apache.ignite.internal.processors.cache.version.GridCacheVersion; -import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.lang.IgniteUuid; /** */ @@ -38,27 +34,13 @@ public class TxInfoCommandArg extends TxCommand.AbstractTxCommandArg { @Argument( example = "|" + "") - private String value; + String value; /** */ - private IgniteUuid uuid; + IgniteUuid uuid; /** */ - private GridCacheVersion gridCacheVersion; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeString(out, value); - U.writeIgniteUuid(out, uuid); - out.writeObject(gridCacheVersion); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - value = U.readString(in); - uuid = U.readIgniteUuid(in); - gridCacheVersion = (GridCacheVersion)in.readObject(); - } + GridCacheVersion gridCacheVersion; /** */ public void uuid(IgniteUuid uuid) { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/wal/WalDeleteCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/wal/WalDeleteCommandArg.java index 47a486e15acbc..da45e8f262554 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/wal/WalDeleteCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/wal/WalDeleteCommandArg.java @@ -17,14 +17,10 @@ package org.apache.ignite.internal.management.wal; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; import org.apache.ignite.internal.management.api.CliConfirmArgument; import org.apache.ignite.internal.management.api.Positional; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ @CliConfirmArgument @@ -35,17 +31,7 @@ public class WalDeleteCommandArg extends IgniteDataTransferObject { /** */ @Positional @Argument(optional = true, example = "consistentId1,consistentId2,....,consistentIdN") - private String[] consistentIds; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeArray(out, consistentIds); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - consistentIds = U.readArray(in, String.class); - } + String[] consistentIds; /** */ public String[] consistentIds() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/management/wal/WalStateCommandArg.java b/modules/core/src/main/java/org/apache/ignite/internal/management/wal/WalStateCommandArg.java index 9cf59a5ff9f73..1042fa0547f99 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/management/wal/WalStateCommandArg.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/management/wal/WalStateCommandArg.java @@ -17,12 +17,8 @@ package org.apache.ignite.internal.management.wal; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; import org.apache.ignite.internal.dto.IgniteDataTransferObject; import org.apache.ignite.internal.management.api.Argument; -import org.apache.ignite.internal.util.typedef.internal.U; /** */ public class WalStateCommandArg extends IgniteDataTransferObject { @@ -34,17 +30,7 @@ public class WalStateCommandArg extends IgniteDataTransferObject { description = "Comma-separated list of cache groups. If not set action applied to all groups", optional = true ) - private String[] groups; - - /** {@inheritDoc} */ - @Override protected void writeExternalData(ObjectOutput out) throws IOException { - U.writeArray(out, groups); - } - - /** {@inheritDoc} */ - @Override protected void readExternalData(ObjectInput in) throws IOException, ClassNotFoundException { - groups = U.readArray(in, String.class); - } + String[] groups; /** */ public String[] groups() { diff --git a/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java b/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java index 0e175970852f0..65408e6ec0be9 100755 --- a/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/util/IgniteUtils.java @@ -180,6 +180,8 @@ import org.apache.ignite.internal.cluster.ClusterTopologyCheckedException; import org.apache.ignite.internal.compute.ComputeTaskCancelledCheckedException; import org.apache.ignite.internal.compute.ComputeTaskTimeoutCheckedException; +import org.apache.ignite.internal.dto.IgniteDataTransferObject; +import org.apache.ignite.internal.dto.IgniteDataTransferObjectSerializer; import org.apache.ignite.internal.events.DiscoveryCustomEvent; import org.apache.ignite.internal.logger.IgniteLoggerEx; import org.apache.ignite.internal.managers.communication.GridIoPolicy; @@ -8241,4 +8243,31 @@ public void clearAllListener() { listeners.clear(); } } + + /** */ + public static final IgniteDataTransferObjectSerializer EMPTY_DTO_SERIALIZER = new IgniteDataTransferObjectSerializer() { + /** {@inheritDoc} */ + @Override public void writeExternal(Object instance, ObjectOutput out) { + // No-op. + } + + /** {@inheritDoc} */ + @Override public void readExternal(Object instance, ObjectInput in) { + // No-op. + } + }; + + /** */ + public static IgniteDataTransferObjectSerializer loadSerializer(Class cls) { + try { + Class cls0 = IgniteUtils.class.getClassLoader() + .loadClass(cls.getPackage().getName() + "." + cls.getSimpleName() + "Serializer"); + + return (IgniteDataTransferObjectSerializer)cls0.getDeclaredConstructor().newInstance(); + } + catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | + InvocationTargetException e) { + return (IgniteDataTransferObjectSerializer)EMPTY_DTO_SERIALIZER; + } + } }