Re: Cannot start ignite nodes with shared memory - Ignite version 2.10.0

[sarahsamji]

public class SampleTest {
    static String localhost;
    private static Random random;
    final static int discPort = 36101;
    final static int commPort = 37601;
    final static int sharedMemPort = 37235;
    final static int clusterSize = 2;
    private static final int messageQueueLimit = 8192;
    private static final long tcpCommTimeout = 10_000L;
    private static final int igniteCommPortRange = 5;
    final static int igniteDiscPortRange = clusterSize * 2;
    final static  int igniteDiscMaxPort = discPort + igniteDiscPortRange;
    private static final long discoveryNetworkTimeout = 20_000L;
    private static final int default_threadpool_size = 8;
    private static final int igniteLongRunningThreadPoolSize = 8;
    private static final int igniteStreamerThreadPoolSize = 8;

    private static final String igniteDiscHost = "127.0.0.1";
    final static String tmpdir = System.getProperty("java.io.tmpdir");
    public static final int[] EVENT_TYPES = {
            EventType.EVT_CACHE_OBJECT_EXPIRED,
            EventType.EVT_NODE_JOINED,
            EventType.EVT_NODE_LEFT,
            EventType.EVT_NODE_SEGMENTED,
            EventType.EVT_CLIENT_NODE_DISCONNECTED,
            EventType.EVT_CLIENT_NODE_RECONNECTED,
            EventType.EVT_NODE_FAILED,
            EventType.EVT_CACHE_REBALANCE_PART_DATA_LOST};


    @BeforeAll
    static void beforeAll() {
        IgniteUtils.setCurrentIgniteName("");
        ThreadContext.clearAll();
        System.setProperty("ignite.cluster.encryption.disabled", "true");
    }

    @Test
    void test() {
        int httpPort = PortFinder.getRandomPort(37000, 37500);
        localhost = "localhost:" + httpPort;
        try {
            startCluster();
            final Ignite ignite = Ignition.ignite("NODE_I1");
            assertNotNull(ignite);
            TestDomainSvcImpl.resetCounters();
        } finally {
            IgniteUtils.setCurrentIgniteName(null);
            ThreadContext.clearAll();
        }
    }

    private static void startCluster() {
        random = new Random();
        Thread.interrupted();

        startNode("NODE_1");

        for (int i = 2; i <= clusterSize; i++) {
            startNode("NODE" + i);
        }

        Ignite i1 = Ignition.ignite("NODE_1");
        assertEquals(clusterSize, i1.cluster().nodes().size());
    }

    private static void startNode(String instanceName) {
        IgniteConfiguration igniteConfig = buildIgniteConfig(instanceName);
        Ignite ignite = Ignition.start(igniteConfig);
    }

    private static IgniteConfiguration buildIgniteConfig(String
instanceName) {
        IgniteConfiguration cfg = new IgniteConfigBuilder().build();
        return cfg
                .setIgniteInstanceName(instanceName)
                .setPeerClassLoadingEnabled(false)
                .setWorkDirectory(Paths.get(tmpdir, "firecracker", "ignite",
"work", String.valueOf(random.nextInt(1000000))).toString())
                .setFailureDetectionTimeout(30_000L)
                .setMetricsLogFrequency(300000L)
               
.setDataStorageConfiguration(createDataStorageConfiguration())
                .setIncludeEventTypes(EVENT_TYPES)
                .setCommunicationSpi(createCommunicationSpi())
                .setDiscoverySpi(createDiscoverySpi())
                .setPublicThreadPoolSize(default_threadpool_size)
                .setDataStreamerThreadPoolSize(igniteStreamerThreadPoolSize)
                .setSystemThreadPoolSize(default_threadpool_size)
                .setServiceThreadPoolSize(default_threadpool_size)
                .setStripedPoolSize(default_threadpool_size)
               
.setExecutorConfiguration(createExecutorConfig("IgniteLongRunning",
igniteLongRunningThreadPoolSize))
                .setConnectorConfiguration(null)
                .setClientConnectorConfiguration(null)
                .setBinaryConfiguration(createBinaryConfiguration())
                .setFailureHandler(new StopNodeOrHaltFailureHandler(false,
0));
    }

    static DataStorageConfiguration createDataStorageConfiguration() {

        int evictionThreshold = 90;
        String DEFAULT_MEMORY_REGION = "Default_Region";
        long memSize = 200 * 1024 * 1024;;

        DataRegionConfiguration regionConfig = new DataRegionConfiguration()
                .setName(DEFAULT_MEMORY_REGION)
                .setInitialSize(memSize)
                .setMaxSize(memSize)
                .setMetricsEnabled(true)
                .setPageEvictionMode(DataPageEvictionMode.DISABLED)     //
Only enable eviction if we can find a way to control it
                .setEvictionThreshold(evictionThreshold / 100);

        DataStorageConfiguration dataStorageConfiguration = new
DataStorageConfiguration()
                .setDefaultDataRegionConfiguration(regionConfig);

        dataStorageConfiguration.setMetricsEnabled(true);

        return dataStorageConfiguration;
    }

    static CommunicationSpi createCommunicationSpi() {

        return new TcpCommunicationSpi()
                .setSocketWriteTimeout(tcpCommTimeout)
                .setConnectTimeout(tcpCommTimeout)
                .setLocalPort(commPort)
                .setLocalPortRange(igniteCommPortRange)
                .setSharedMemoryPort(sharedMemPort)
                .setMessageQueueLimit(messageQueueLimit);
    }

    static DiscoverySpi createDiscoverySpi() {

        return new TcpDiscoverySpi()
                .setLocalPort(discPort)
                .setLocalPortRange(igniteDiscPortRange)
                .setNetworkTimeout(discoveryNetworkTimeout)
                .setIpFinder(createIpFinder(igniteDiscMaxPort));
    }

    static TcpDiscoveryIpFinder createIpFinder(final int igniteDiscMaxPort)
{
        return new
TcpDiscoveryVmIpFinder().setAddresses(List.of(igniteDiscHost + ":" +
discPort + ".." + igniteDiscMaxPort));
    }

    static ExecutorConfiguration createExecutorConfig(String name, int
threadCount) {
        return new ExecutorConfiguration(name)
                .setSize(threadCount);
    }

    static BinaryConfiguration createBinaryConfiguration() {
        return new BinaryConfiguration().setCompactFooter(false);
    }
}




--
Sent from: http://apache-ignite-users.70518.x6.nabble.com/