Examples with PdxType org.apache.geode.pdx.internal.PdxType used on opensource projects

Example 6 with PdxType

use of org.apache.geode.pdx.internal.PdxType in project geode by apache.

the class DataType method getDataType.

public static String getDataType(byte[] bytes) {
    final DataInput in = getDataInput(bytes);
    byte header = 0;
    try {
        header = in.readByte();
    } catch (IOException e) {
        return "IOException: " + e.getMessage();
    }
    try {
        switch(header) {
            case DS_FIXED_ID_BYTE:
                {
                    return "org.apache.geode.internal.DataSerializableFixedID:" + DSFIDFactory.create(in.readByte(), in).getClass().getName();
                }
            case DS_FIXED_ID_SHORT:
                {
                    return "org.apache.geode.internal.DataSerializableFixedID:" + DSFIDFactory.create(in.readShort(), in).getClass().getName();
                }
            case DS_FIXED_ID_INT:
                {
                    return "org.apache.geode.internal.DataSerializableFixedID:" + DSFIDFactory.create(in.readInt(), in).getClass().getName();
                }
            case DS_NO_FIXED_ID:
                return "org.apache.geode.internal.DataSerializableFixedID:" + DataSerializer.readClass(in).getName();
            case NULL:
                return "null";
            case NULL_STRING:
            case STRING:
            case HUGE_STRING:
            case STRING_BYTES:
            case HUGE_STRING_BYTES:
                return "java.lang.String";
            case CLASS:
                return "java.lang.Class";
            case DATE:
                return "java.util.Date";
            case FILE:
                return "java.io.File";
            case INET_ADDRESS:
                return "java.net.InetAddress";
            case BOOLEAN:
                return "java.lang.Boolean";
            case CHARACTER:
                return "java.lang.Character";
            case BYTE:
                return "java.lang.Byte";
            case SHORT:
                return "java.lang.Short";
            case INTEGER:
                return "java.lang.Integer";
            case LONG:
                return "java.lang.Long";
            case FLOAT:
                return "java.lang.Float";
            case DOUBLE:
                return "java.lang.Double";
            case BYTE_ARRAY:
                return "byte[]";
            case ARRAY_OF_BYTE_ARRAYS:
                return "byte[][]";
            case SHORT_ARRAY:
                return "short[]";
            case STRING_ARRAY:
                return "java.lang.String[]";
            case INT_ARRAY:
                return "int[]";
            case LONG_ARRAY:
                return "long[]";
            case FLOAT_ARRAY:
                return "float[]";
            case DOUBLE_ARRAY:
                return "double[]";
            case BOOLEAN_ARRAY:
                return "boolean[]";
            case CHAR_ARRAY:
                return "char[]";
            case OBJECT_ARRAY:
                return "java.lang.Object[]";
            case ARRAY_LIST:
                return "java.util.ArrayList";
            case LINKED_LIST:
                return "java.util.LinkedList";
            case HASH_SET:
                return "java.util.HashSet";
            case LINKED_HASH_SET:
                return "java.util.LinkedHashSet";
            case HASH_MAP:
                return "java.util.HashMap";
            case IDENTITY_HASH_MAP:
                return "java.util.IdentityHashMap";
            case HASH_TABLE:
                return "java.util.Hashtable";
            // return "java.util.concurrent.ConcurrentHashMap";
            case PROPERTIES:
                return "java.util.Properties";
            case TIME_UNIT:
                return "java.util.concurrent.TimeUnit";
            case USER_CLASS:
                byte userClassDSId = in.readByte();
                return "DataSerializer: with Id:" + userClassDSId;
            case USER_CLASS_2:
                short userClass2DSId = in.readShort();
                return "DataSerializer: with Id:" + userClass2DSId;
            case USER_CLASS_4:
                int userClass4DSId = in.readInt();
                return "DataSerializer: with Id:" + userClass4DSId;
            case VECTOR:
                return "java.util.Vector";
            case STACK:
                return "java.util.Stack";
            case TREE_MAP:
                return "java.util.TreeMap";
            case TREE_SET:
                return "java.util.TreeSet";
            case BOOLEAN_TYPE:
                return "java.lang.Boolean.class";
            case CHARACTER_TYPE:
                return "java.lang.Character.class";
            case BYTE_TYPE:
                return "java.lang.Byte.class";
            case SHORT_TYPE:
                return "java.lang.Short.class";
            case INTEGER_TYPE:
                return "java.lang.Integer.class";
            case LONG_TYPE:
                return "java.lang.Long.class";
            case FLOAT_TYPE:
                return "java.lang.Float.class";
            case DOUBLE_TYPE:
                return "java.lang.Double.class";
            case VOID_TYPE:
                return "java.lang.Void.class";
            case USER_DATA_SERIALIZABLE:
                {
                    Instantiator instantiator = InternalInstantiator.getInstantiator(in.readByte());
                    return "org.apache.geode.Instantiator:" + instantiator.getInstantiatedClass().getName();
                }
            case USER_DATA_SERIALIZABLE_2:
                {
                    Instantiator instantiator = InternalInstantiator.getInstantiator(in.readShort());
                    return "org.apache.geode.Instantiator:" + instantiator.getInstantiatedClass().getName();
                }
            case USER_DATA_SERIALIZABLE_4:
                {
                    Instantiator instantiator = InternalInstantiator.getInstantiator(in.readInt());
                    return "org.apache.geode.Instantiator:" + instantiator.getInstantiatedClass().getName();
                }
            case DATA_SERIALIZABLE:
                return "org.apache.geode.DataSerializable:" + DataSerializer.readClass(in).getName();
            case SERIALIZABLE:
                {
                    String name = null;
                    try {
                        Object obj = InternalDataSerializer.basicReadObject(getDataInput(bytes));
                        name = obj.getClass().getName();
                    } catch (ClassNotFoundException e) {
                        name = e.getMessage();
                    }
                    return "java.io.Serializable:" + name;
                }
            case PDX:
                {
                    int typeId = in.readInt();
                    try {
                        InternalCache gfc = GemFireCacheImpl.getForPdx("PDX registry is unavailable because the Cache has been closed.");
                        PdxType pdxType = gfc.getPdxRegistry().getType(typeId);
                        if (pdxType == null) {
                            // fix 52164
                            return "org.apache.geode.pdx.PdxInstance: unknown id=" + typeId;
                        }
                        return "org.apache.geode.pdx.PdxInstance:" + pdxType.getClassName();
                    } catch (CacheClosedException e) {
                        return "org.apache.geode.pdx.PdxInstance:PdxRegistryClosed";
                    }
                }
            case PDX_ENUM:
                {
                    int dsId = in.readByte();
                    int tmp = InternalDataSerializer.readArrayLength(in);
                    int enumId = (dsId << 24) | (tmp & 0xFFFFFF);
                    try {
                        InternalCache gfc = GemFireCacheImpl.getForPdx("PDX registry is unavailable because the Cache has been closed.");
                        EnumInfo enumInfo = gfc.getPdxRegistry().getEnumInfoById(enumId);
                        return "PdxRegistry/java.lang.Enum:" + enumInfo.getClassName();
                    } catch (CacheClosedException e) {
                        return "PdxRegistry/java.lang.Enum:PdxRegistryClosed";
                    }
                }
            case GEMFIRE_ENUM:
                {
                    String name = DataSerializer.readString(in);
                    return "java.lang.Enum:" + name;
                }
            case PDX_INLINE_ENUM:
                {
                    String name = DataSerializer.readString(in);
                    return "java.lang.Enum:" + name;
                }
            case BIG_INTEGER:
                return "java.math.BigInteger";
            case BIG_DECIMAL:
                return "java.math.BigDecimal";
            case UUID:
                return "java.util.UUID";
            case TIMESTAMP:
                return "java.sql.Timestamp";
            default:
        }
        return "Unknown header byte: " + header;
    } catch (IOException e) {
        throw new Error(e);
    } catch (ClassNotFoundException e) {
        throw new Error(e);
    }
}

Example 7 with PdxType

use of org.apache.geode.pdx.internal.PdxType in project geode by apache.

the class DiskStoreImpl method getPdxTypes.

private Collection<PdxType> getPdxTypes() throws IOException {
    // Since we are recovering a disk store, the cast from DiskRegionView -->
    // PlaceHolderDiskRegion
    // and from RegionEntry --> DiskEntry should be ok.
    // In offline mode, we need to schedule the regions to be recovered
    // explicitly.
    DiskRegionView foundPdx = null;
    for (DiskRegionView drv : getKnown()) {
        if (drv.getName().equals(PeerTypeRegistration.REGION_FULL_PATH)) {
            foundPdx = drv;
            scheduleForRecovery((PlaceHolderDiskRegion) drv);
        }
    }
    if (foundPdx == null) {
        return Collections.emptyList();
    // throw new IllegalStateException("The disk store does not contain any PDX types.");
    }
    recoverRegionsThatAreReady();
    ArrayList<PdxType> result = new ArrayList<PdxType>();
    for (RegionEntry re : foundPdx.getRecoveredEntryMap().regionEntries()) {
        Object value = re._getValueRetain(foundPdx, true);
        if (Token.isRemoved(value)) {
            continue;
        }
        if (value instanceof CachedDeserializable) {
            value = ((CachedDeserializable) value).getDeserializedForReading();
        }
        if (value instanceof PdxType) {
            PdxType type = (PdxType) value;
            result.add(type);
        }
    }
    Collections.sort(result, new Comparator<PdxType>() {

        @Override
        public int compare(PdxType o1, PdxType o2) {
            return o1.getClassName().compareTo(o2.getClassName());
        }
    });
    return result;
}

Example 8 with PdxType

use of org.apache.geode.pdx.internal.PdxType in project geode by apache.

the class DiskStoreImpl method dumpPdxTypes.

private void dumpPdxTypes(PrintStream printStream) {
    try {
        ArrayList<PdxType> types = new ArrayList<>();
        ArrayList<EnumInfo> enums = new ArrayList<>();
        for (Object i : getPdxTypesAndEnums()) {
            if (i instanceof PdxType) {
                types.add((PdxType) i);
            } else {
                enums.add((EnumInfo) i);
            }
        }
        types.sort(Comparator.comparing(PdxType::getClassName));
        enums.sort(EnumInfo::compareTo);
        printStream.println("PDX Types:");
        for (PdxType type : types) {
            type.toStream(printStream, true);
        }
        printStream.println("PDX Enums:");
        for (EnumInfo e : enums) {
            e.toStream(printStream);
        }
    } catch (IOException ignore) {
    }
}

Example 9 with PdxType

use of org.apache.geode.pdx.internal.PdxType in project geode by apache.

the class PdxQueryDUnitTest method testLocalMapInPeerTypePdxRegistry.

/**
   * In PeerTypeRegistration when a PdxType is updated, a local map of class => PdxTypes is
   * populated. This map is used to search a field for a class in different versions (PdxTypes) This
   * test verifies that the map is being updated by the cacheListener
   *
   * @throws CacheException
   */
@Test
public void testLocalMapInPeerTypePdxRegistry() throws CacheException {
    final Host host = Host.getHost(0);
    final VM vm0 = host.getVM(0);
    final VM vm1 = host.getVM(1);
    final VM vm2 = host.getVM(2);
    final VM vm3 = host.getVM(3);
    final int numberOfEntries = 10;
    final String name = "/" + regionName;
    final String[] qs = { "select * from " + name + " where pdxStatus = 'active'", "select pdxStatus from " + name + " where id > 4" };
    // Start server1
    final int port1 = (Integer) vm0.invoke(new SerializableCallable("Create Server1") {

        @Override
        public Object call() throws Exception {
            Region r1 = getCache().createRegionFactory(RegionShortcut.REPLICATE).create(regionName);
            CacheServer server = getCache().addCacheServer();
            int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
            server.setPort(port);
            server.start();
            return port;
        }
    });
    // Start server2
    final int port2 = (Integer) vm1.invoke(new SerializableCallable("Create Server2") {

        @Override
        public Object call() throws Exception {
            Region r1 = getCache().createRegionFactory(RegionShortcut.REPLICATE).create(regionName);
            CacheServer server = getCache().addCacheServer();
            int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
            server.setPort(port);
            server.start();
            return port;
        }
    });
    // client1 loads version 1 objects on server1
    vm2.invoke(new SerializableCallable("Create client") {

        @Override
        public Object call() throws Exception {
            ClientCacheFactory cf = new ClientCacheFactory();
            cf.addPoolServer(NetworkUtils.getServerHostName(vm0.getHost()), port1);
            ClientCache cache = getClientCache(cf);
            Region region = cache.createClientRegionFactory(ClientRegionShortcut.PROXY).create(regionName);
            // Load version 1 objects
            for (int i = 0; i < numberOfEntries; i++) {
                PdxInstanceFactory pdxInstanceFactory = PdxInstanceFactoryImpl.newCreator("PdxVersionedNewPortfolio", false);
                pdxInstanceFactory.writeInt("id", i);
                pdxInstanceFactory.writeString("pdxStatus", (i % 2 == 0 ? "active" : "inactive"));
                PdxInstance pdxInstance = pdxInstanceFactory.create();
                region.put("key-" + i, pdxInstance);
            }
            return null;
        }
    });
    // client 2 loads version 2 objects on server2
    vm3.invoke(new SerializableCallable("Create client") {

        @Override
        public Object call() throws Exception {
            ClientCacheFactory cf = new ClientCacheFactory();
            cf.addPoolServer(NetworkUtils.getServerHostName(vm1.getHost()), port2);
            ClientCache cache = getClientCache(cf);
            Region region = cache.createClientRegionFactory(ClientRegionShortcut.PROXY).create(regionName);
            // Load version 2 objects
            for (int i = numberOfEntries; i < numberOfEntries * 2; i++) {
                PdxInstanceFactory pdxInstanceFactory = PdxInstanceFactoryImpl.newCreator("PdxVersionedNewPortfolio", false);
                pdxInstanceFactory.writeInt("id", i);
                pdxInstanceFactory.writeString("status", (i % 2 == 0 ? "active" : "inactive"));
                PdxInstance pdxInstance = pdxInstanceFactory.create();
                region.put("key-" + i, pdxInstance);
            }
            return null;
        }
    });
    // on server 1 verify local map in PeerTypeRegistration has fields
    vm0.invoke(new SerializableCallable("Create client") {

        @Override
        public Object call() throws Exception {
            TypeRegistration registration = GemFireCacheImpl.getForPdx("PDX registry is unavailable because the Cache has been closed.").getPdxRegistry().getTypeRegistration();
            Assert.assertTrue(registration instanceof PeerTypeRegistration);
            Map<String, Set<PdxType>> m = ((PeerTypeRegistration) registration).getClassToType();
            assertEquals(1, m.size());
            assertEquals("PdxVersionedNewPortfolio", m.keySet().iterator().next());
            assertEquals(2, m.values().iterator().next().size());
            for (PdxType p : m.values().iterator().next()) {
                assertEquals("PdxVersionedNewPortfolio", p.getClassName());
            }
            return null;
        }
    });
    // on server 2 verify local map in PeerTypeRegistration has fields
    vm1.invoke(new SerializableCallable("Create client") {

        @Override
        public Object call() throws Exception {
            TypeRegistration registration = GemFireCacheImpl.getForPdx("PDX registry is unavailable because the Cache has been closed.").getPdxRegistry().getTypeRegistration();
            Assert.assertTrue(registration instanceof PeerTypeRegistration);
            Map<String, Set<PdxType>> m = ((PeerTypeRegistration) registration).getClassToType();
            assertEquals(1, m.size());
            assertEquals("PdxVersionedNewPortfolio", m.keySet().iterator().next());
            assertEquals(2, m.values().iterator().next().size());
            for (PdxType p : m.values().iterator().next()) {
                assertEquals("PdxVersionedNewPortfolio", p.getClassName());
            }
            return null;
        }
    });
    Invoke.invokeInEveryVM(DistributedTestCase.class, "disconnectFromDS");
}

Example 10 with PdxType

use of org.apache.geode.pdx.internal.PdxType in project geode by apache.

the class PdxQueryDUnitTest method testClientForFieldInOtherVersion.

/**
   * 2 servers(replicated) and 2 clients. client2 puts version1 and version2 objects on server1
   * client1 had registered interest to server2, hence gets the pdx objects for both versions Test
   * local query on client1 Test if client1 fetched pdxtypes from server
   * 
   * @throws CacheException
   */
@Test
public void testClientForFieldInOtherVersion() throws CacheException {
    final Host host = Host.getHost(0);
    final VM vm0 = host.getVM(0);
    final VM vm1 = host.getVM(1);
    final VM vm2 = host.getVM(2);
    final VM vm3 = host.getVM(3);
    final int numberOfEntries = 10;
    final String name = "/" + regionName;
    final String[] qs = { "select pdxStatus from " + name + " where pdxStatus = 'active'", "select status from " + name + " where id > 8 and id < 14" };
    // Start server1
    final int port1 = (Integer) vm0.invoke(new SerializableCallable("Create Server1") {

        @Override
        public Object call() throws Exception {
            Region r1 = getCache().createRegionFactory(RegionShortcut.REPLICATE).create(regionName);
            CacheServer server = getCache().addCacheServer();
            int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
            server.setPort(port);
            server.start();
            return port;
        }
    });
    // Start server2
    final int port2 = (Integer) vm1.invoke(new SerializableCallable("Create Server2") {

        @Override
        public Object call() throws Exception {
            Region r1 = getCache().createRegionFactory(RegionShortcut.REPLICATE).create(regionName);
            CacheServer server = getCache().addCacheServer();
            int port = AvailablePortHelper.getRandomAvailablePortForDUnitSite();
            server.setPort(port);
            server.start();
            return port;
        }
    });
    // client 1 registers interest for server2
    vm2.invoke(new SerializableCallable("Create client") {

        @Override
        public Object call() throws Exception {
            ClientCacheFactory cf = new ClientCacheFactory();
            cf.setPoolSubscriptionEnabled(true);
            cf.addPoolServer(NetworkUtils.getServerHostName(vm1.getHost()), port2);
            ClientCache cache = getClientCache(cf);
            Region region = cache.createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY).create(regionName);
            region.registerInterest("ALL_KEYS");
            return null;
        }
    });
    // client2 loads both version objects on server1
    vm3.invoke(new SerializableCallable("Create client") {

        @Override
        public Object call() throws Exception {
            ClientCacheFactory cf = new ClientCacheFactory();
            cf.addPoolServer(NetworkUtils.getServerHostName(vm0.getHost()), port1);
            ClientCache cache = getClientCache(cf);
            Region region = cache.createClientRegionFactory(ClientRegionShortcut.PROXY).create(regionName);
            // Load version 1 objects
            for (int i = 0; i < numberOfEntries; i++) {
                PdxInstanceFactory pdxFactory = cache.createPdxInstanceFactory("PdxPortfolio");
                pdxFactory.writeString("pdxStatus", (i % 2 == 0 ? "active" : "inactive"));
                pdxFactory.writeInt("id", i);
                PdxInstance pdxInstance = pdxFactory.create();
                region.put("key-" + i, pdxInstance);
            }
            ;
            // Load version 2 objects
            for (int i = numberOfEntries; i < numberOfEntries * 2; i++) {
                PdxInstanceFactory pdxFactory = cache.createPdxInstanceFactory("PdxPortfolio");
                pdxFactory.writeString("status", i % 2 == 0 ? "active" : "inactive");
                pdxFactory.writeInt("id", i);
                PdxInstance pdxInstance = pdxFactory.create();
                region.put("key-" + i, pdxInstance);
            }
            return null;
        }
    });
    // query locally on client 1 which has registered interest
    vm2.invoke(new SerializableCallable("Create client") {

        @Override
        public Object call() throws Exception {
            GemFireCacheImpl cache = (GemFireCacheImpl) getCache();
            cache.setReadSerialized(true);
            QueryService localQueryService = null;
            // Execute query remotely
            try {
                localQueryService = ((ClientCache) getCache()).getLocalQueryService();
            } catch (Exception e) {
                Assert.fail("Failed to get QueryService.", e);
            }
            for (int i = 0; i < qs.length; i++) {
                try {
                    SelectResults sr = (SelectResults) localQueryService.newQuery(qs[i]).execute();
                    assertEquals(5, sr.size());
                    if (i == 1) {
                        for (Object o : sr) {
                            if (o == null) {
                            } else if (o instanceof String) {
                            } else {
                                fail("Result should be either null or String and not " + o.getClass());
                            }
                        }
                    }
                } catch (Exception e) {
                    Assert.fail("Failed executing " + qs[i], e);
                }
            }
            // check if the types registered on server are fetched by the client
            TypeRegistration registration = GemFireCacheImpl.getForPdx("PDX registry is unavailable because the Cache has been closed.").getPdxRegistry().getTypeRegistration();
            Assert.assertTrue(registration instanceof ClientTypeRegistration);
            Map<Integer, PdxType> m = ((ClientTypeRegistration) registration).types();
            assertEquals(2, m.size());
            for (PdxType type : m.values()) {
                assertEquals("PdxPortfolio", type.getClassName());
            }
            return null;
        }
    });
    Invoke.invokeInEveryVM("Disconnecting from the Distributed system", () -> disconnectFromDS());
}