| /* |
| * 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 javaobject; |
| |
| import java.io.DataInput; |
| import java.io.DataOutput; |
| import java.io.IOException; |
| import java.util.Properties; |
| import java.util.Arrays; |
| |
| import org.apache.geode.internal.cache.GemFireCacheImpl; |
| import org.apache.geode.DataSerializable; |
| import org.apache.geode.Delta; |
| import org.apache.geode.DataSerializer; |
| import org.apache.geode.cache.Declarable; |
| import org.apache.geode.InvalidDeltaException; |
| import org.apache.geode.Instantiator; |
| |
| /** |
| * Sample test class which implements Delta. |
| * |
| * @since 6.1 |
| */ |
| public class DeltaTestImpl implements DataSerializable, Delta, Declarable { |
| |
| static { |
| Instantiator.register(new Instantiator(DeltaTestImpl.class, (byte) 30) { |
| public DataSerializable newInstance() { |
| return new DeltaTestImpl(); |
| } |
| }); |
| } |
| |
| private static final byte INT_MASK = 0x1; |
| private static final byte STR_MASK = 0x2; |
| private static final byte DOUBLE_MASK = 0x4; |
| private static final byte BYTE_ARR_MASK = 0x8; |
| private static final byte TEST_OBJ_MASK = 0x10; |
| private static final byte COMPLETE_MASK = 0x1F; |
| |
| /***************************************************************************** |
| * Below fields are not part of standard Delta implementation but are used for |
| * testing purpose. |
| */ |
| public static final String ERRONEOUS_STRING_FOR_FROM_DELTA = "ERRONEOUS_STRING"; |
| public static final int ERRONEOUS_INT_FOR_TO_DELTA = -101; |
| private static long fromDeltaInvokations; |
| private static long toDeltaInvokations; |
| private static long toDeltaFailure; |
| private static long fromDeltaFailure; |
| public static boolean NEED_TO_RESET_T0_DELTA = true; |
| /** *********************************************************************** */ |
| |
| // Actual data fields of this instance. |
| private int intVar = 0; // 0000 0001 |
| private String str = ""; // 0000 0010 |
| private Double doubleVar = new Double(0); // 0000 0100 |
| private byte[] byteArr = new byte[1]; // 0000 1000 |
| private TestObject1 testObj = new TestObject1(); // 0001 0000 |
| |
| /** |
| * Indicates the fields containing delta. |
| */ |
| private byte deltaBits = 0x0; |
| |
| private boolean hasDelta = false; |
| |
| public DeltaTestImpl() { |
| } |
| |
| public DeltaTestImpl(int intVal, String str) { |
| this.intVar = intVal; |
| this.str = str; |
| } |
| |
| public DeltaTestImpl(int intVal, String string, Double doubleVal, |
| byte[] bytes, TestObject1 testObj) { |
| this.intVar = intVal; |
| this.str = string; |
| this.doubleVar = doubleVal; |
| this.byteArr = bytes; |
| this.testObj = testObj; |
| } |
| |
| public void resetDeltaStatus() { |
| this.deltaBits = 0x0; |
| this.hasDelta = false; |
| } |
| |
| public byte[] getByteArr() { |
| return byteArr; |
| } |
| |
| public void setByteArr(byte[] bytes) { |
| this.byteArr = bytes; |
| this.deltaBits |= BYTE_ARR_MASK; |
| this.hasDelta = true; |
| } |
| |
| public Double getDoubleVar() { |
| return doubleVar; |
| } |
| |
| public void setDoubleVar(Double doubleVar) { |
| this.doubleVar = doubleVar; |
| this.deltaBits |= DOUBLE_MASK; |
| this.hasDelta = true; |
| } |
| |
| public int getIntVar() { |
| return intVar; |
| } |
| |
| public void setIntVar(int intVar) { |
| this.intVar = intVar; |
| this.deltaBits |= INT_MASK; |
| this.hasDelta = true; |
| } |
| |
| public String getStr() { |
| return str; |
| } |
| |
| public void setStr(String str) { |
| this.str = str; |
| this.deltaBits |= STR_MASK; |
| this.hasDelta = true; |
| } |
| |
| public TestObject1 getTestObj() { |
| return testObj; |
| } |
| |
| public void setTestObj(TestObject1 testObj) { |
| this.testObj = testObj; |
| this.deltaBits |= TEST_OBJ_MASK; |
| this.hasDelta = true; |
| } |
| |
| /***************************************************************************** |
| * Below methods are not part of standard Delta implementation but are used |
| * for testing purpose. |
| */ |
| public static void resetDeltaInvokationCounters() { |
| resetToDeltaCounter(); |
| resetFromDeltaCounter(); |
| resetFailureCounter(); |
| } |
| |
| public static void resetToDeltaCounter() { |
| toDeltaInvokations = 0; |
| } |
| |
| public static void resetFromDeltaCounter() { |
| fromDeltaInvokations = 0; |
| } |
| |
| public static void resetFailureCounter() { |
| toDeltaFailure = 0; |
| fromDeltaFailure = 0; |
| } |
| |
| public static Boolean deltaFeatureUsed() { |
| return (toDeltaInvokations > 0) || (fromDeltaInvokations > 0); |
| } |
| |
| public static Boolean toDeltaFeatureUsed() { |
| return (toDeltaInvokations > 0); |
| } |
| |
| public static Long getFromDeltaInvokations() { |
| return fromDeltaInvokations; |
| } |
| |
| public static Long getToDeltaInvokations() { |
| return toDeltaInvokations; |
| } |
| |
| public static Boolean fromDeltaFeatureUsed() { |
| return (fromDeltaInvokations > 0); |
| } |
| |
| public static Boolean isFromDeltaFailure() { |
| return (fromDeltaFailure > 0); |
| } |
| |
| public static Boolean isToDeltaFailure() { |
| return (toDeltaFailure > 0); |
| } |
| |
| public static Long getFromDeltaFailures() { |
| return fromDeltaFailure; |
| } |
| |
| public static Long getToDeltaFailures() { |
| return toDeltaFailure; |
| } |
| |
| protected void checkInvalidString(String str) { |
| if (ERRONEOUS_STRING_FOR_FROM_DELTA.equals(str)) { |
| fromDeltaFailure++; |
| throw new InvalidDeltaException("Delta could not be applied. " |
| + this); |
| } |
| } |
| |
| protected void checkInvalidInt(int intVal) { |
| if (ERRONEOUS_INT_FOR_TO_DELTA == intVal) { |
| toDeltaFailure++; |
| throw new InvalidDeltaException("Delta could not be extracted. " |
| + this); |
| } |
| } |
| |
| protected void checkInvalidInt2(int intVal) {} |
| /** ********************************************************************** */ |
| |
| public String toString() { |
| StringBuffer bytes = new StringBuffer(""); |
| if (byteArr != null) { |
| for (int i = 0; i < byteArr.length; i++) { |
| bytes.append(byteArr[i]); |
| } |
| } |
| return "DeltaTestImpl[hasDelta=" + this.hasDelta + ",int=" + this.intVar |
| + ",double=" + this.doubleVar + ",str=" + this.str + ",bytes={" |
| + bytes.toString() + "},testObj=" |
| + ((this.testObj != null) ? this.testObj.hashCode() : "") + "]"; |
| } |
| |
| public boolean equals(Object other) { |
| if (other == null || !(other instanceof DeltaTestImpl)) { |
| return false; |
| } |
| DeltaTestImpl delta = (DeltaTestImpl)other; |
| if (this.intVar == delta.intVar && this.doubleVar.equals(delta.doubleVar) |
| && Arrays.equals(this.byteArr, delta.byteArr) |
| && this.str.equals(delta.str)) { |
| return true; |
| } |
| return false; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.apache.geode.Delta#fromDelta(java.io.DataInput) |
| */ |
| public void fromDelta(DataInput in) throws IOException { |
| try { |
| |
| fromDeltaInvokations++; |
| boolean tempHasDelta = false; |
| byte tempDeltaBits = this.deltaBits; |
| byte[] tempByteArr = this.byteArr; |
| int tempIntVar = this.intVar; |
| double tempDoubleVar = this.doubleVar; |
| String tempStr = this.str; |
| TestObject1 tempTestObj = this.testObj; |
| |
| tempDeltaBits = DataSerializer.readByte(in); |
| if (tempDeltaBits != 0) { |
| tempHasDelta = true; |
| if ((tempDeltaBits & INT_MASK) == INT_MASK) { |
| tempIntVar = DataSerializer.readPrimitiveInt(in); |
| checkInvalidInt2(tempIntVar); |
| } |
| if ((tempDeltaBits & STR_MASK) == STR_MASK) { |
| tempStr = DataSerializer.readString(in); |
| checkInvalidString(tempStr); // Simulates exception |
| } |
| if ((tempDeltaBits & DOUBLE_MASK) == DOUBLE_MASK) { |
| tempDoubleVar = DataSerializer.readDouble(in); |
| } |
| if ((tempDeltaBits & BYTE_ARR_MASK) == BYTE_ARR_MASK) { |
| //tempByteArr = DataSerializer.readByteArray(in); |
| tempByteArr=(byte[])DataSerializer.readObject(in); |
| } |
| if ((tempDeltaBits & TEST_OBJ_MASK) == TEST_OBJ_MASK) { |
| tempTestObj = (TestObject1)DataSerializer.readObject(in); |
| } |
| if ((deltaBits | COMPLETE_MASK) != COMPLETE_MASK) { |
| throw new IllegalArgumentException("Unknown field code: " |
| + tempDeltaBits); |
| } |
| } |
| if (tempHasDelta) { |
| //this.hasDelta = true; |
| //this.deltaBits = tempDeltaBits; |
| this.intVar = tempIntVar; |
| this.str = tempStr; |
| this.doubleVar = tempDoubleVar; |
| this.byteArr = tempByteArr; |
| this.testObj = tempTestObj; |
| } |
| } |
| catch (IOException e) { |
| GemFireCacheImpl.getInstance().getLogger().warning( |
| "DeltaTestImpl.fromDelta(): " + e); |
| throw e; |
| } |
| catch (IllegalArgumentException iae) { |
| GemFireCacheImpl.getInstance().getLogger().warning( |
| "DeltaTestImpl.fromDelta(): " + iae); |
| throw new InvalidDeltaException(iae); |
| } |
| catch (ClassNotFoundException cnfe) { |
| GemFireCacheImpl.getInstance().getLogger().warning( |
| "DeltaTestImpl.fromDelta(): " + cnfe); |
| throw new InvalidDeltaException(cnfe); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.apache.geode.Delta#hasDelta() |
| */ |
| public boolean hasDelta() { |
| return this.hasDelta; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.apache.geode.Delta#toDelta(java.io.DataOutput) |
| */ |
| public void toDelta(DataOutput out) throws IOException { |
| try { |
| toDeltaInvokations++; |
| DataSerializer.writeByte(this.deltaBits, out); |
| |
| if (deltaBits != 0) { |
| if ((deltaBits & INT_MASK) == INT_MASK) { |
| DataSerializer.writePrimitiveInt(this.intVar, out); |
| checkInvalidInt(this.intVar); // Simulates exception |
| } |
| if ((deltaBits & STR_MASK) == STR_MASK) { |
| DataSerializer.writeString(this.str, out); |
| } |
| if ((deltaBits & DOUBLE_MASK) == DOUBLE_MASK) { |
| DataSerializer.writeDouble(this.doubleVar, out); |
| } |
| if ((deltaBits & BYTE_ARR_MASK) == BYTE_ARR_MASK) { |
| DataSerializer.writeByteArray(this.byteArr, out); |
| } |
| if ((deltaBits & TEST_OBJ_MASK) == TEST_OBJ_MASK) { |
| DataSerializer.writeObject(this.testObj, out); |
| } |
| if ((deltaBits | COMPLETE_MASK) != COMPLETE_MASK) { |
| throw new IllegalArgumentException("Unknown field code: " + deltaBits); |
| } |
| } |
| } |
| catch (IOException ioe) { |
| GemFireCacheImpl.getInstance().getLogger().warning( |
| "DeltaTestImpl.toDelta(): " + ioe); |
| throw ioe; |
| } |
| catch (IllegalArgumentException iae) { |
| GemFireCacheImpl.getInstance().getLogger().warning( |
| "DeltaTestImpl.toDelta(): " + iae); |
| throw new InvalidDeltaException(iae); |
| } |
| finally { |
| if (NEED_TO_RESET_T0_DELTA) {// No need to reset if secondary needs to |
| // send delta again upon receiving |
| // forceReattemptException |
| this.deltaBits = 0x0; |
| this.hasDelta = false; |
| } |
| } |
| } |
| |
| public void fromData(DataInput in) throws IOException, ClassNotFoundException { |
| //this.deltaBits = DataSerializer.readByte(in); |
| this.intVar = DataSerializer.readPrimitiveInt(in); |
| this.str = DataSerializer.readString(in); |
| this.doubleVar = DataSerializer.readDouble(in); |
| this.byteArr = (byte[])DataSerializer.readObject(in); |
| this.testObj = (TestObject1)DataSerializer.readObject(in); |
| //if (deltaBits != 0) { |
| // this.hasDelta = true; |
| //} |
| } |
| |
| public void toData(DataOutput out) throws IOException { |
| //DataSerializer.writeByte(this.deltaBits, out); |
| DataSerializer.writePrimitiveInt(this.intVar, out); |
| DataSerializer.writeString(this.str, out); |
| DataSerializer.writeDouble(this.doubleVar, out); |
| DataSerializer.writeObject(this.byteArr, out); |
| DataSerializer.writeObject(this.testObj, out); |
| } |
| |
| public void init(Properties props) { |
| } |
| } |