Search in sources :

Example 16 with InitParams

use of org.exoplatform.container.xml.InitParams in project kernel by exoplatform.

the class TestRPCServiceImpl method testCommands.

public void testCommands() throws Exception {
    InitParams params = new InitParams();
    ValueParam paramConf = new ValueParam();
    paramConf.setName(RPCServiceImpl.PARAM_JGROUPS_CONFIG);
    paramConf.setValue("jar:/conf/portal/udp.xml");
    params.addParameter(paramConf);
    RPCServiceImpl service = null;
    try {
        service = new RPCServiceImpl(container.getContext(), params, configManager);
        RemoteCommand fake = new RemoteCommand() {

            public String getId() {
                return "fake";
            }

            public String execute(Serializable[] args) throws Throwable {
                return null;
            }
        };
        RemoteCommand fake2 = new RemoteCommand() {

            public String getId() {
                return "fake2";
            }

            public String execute(Serializable[] args) throws Throwable {
                return null;
            }
        };
        RemoteCommand fake2_Unregistered = new RemoteCommand() {

            public String getId() {
                return "fake2";
            }

            public String execute(Serializable[] args) throws Throwable {
                return null;
            }
        };
        service.registerCommand(fake2);
        RemoteCommand Exception = new RemoteCommand() {

            public String getId() {
                return "Exception";
            }

            public String execute(Serializable[] args) throws Throwable {
                throw new Exception("MyException");
            }
        };
        service.registerCommand(Exception);
        RemoteCommand Error = new RemoteCommand() {

            public String getId() {
                return "Error";
            }

            public String execute(Serializable[] args) throws Throwable {
                throw new Error("MyError");
            }
        };
        service.registerCommand(Error);
        RemoteCommand StringValue = new RemoteCommand() {

            public String getId() {
                return "StringValue";
            }

            public String execute(Serializable[] args) throws Throwable {
                return "OK";
            }
        };
        service.registerCommand(StringValue);
        RemoteCommand NullValue = new RemoteCommand() {

            public String getId() {
                return "NullValue";
            }

            public String execute(Serializable[] args) throws Throwable {
                return null;
            }
        };
        service.registerCommand(NullValue);
        RemoteCommand LongTask = new RemoteCommand() {

            public String getId() {
                return "LongTask";
            }

            public String execute(Serializable[] args) throws Throwable {
                Thread.sleep(2000);
                return null;
            }
        };
        service.registerCommand(LongTask);
        service.start();
        try {
            service.executeCommandOnAllNodes(fake, true);
            fail("We expect a RPCException since the command is unknown");
        } catch (RPCException e) {
        // OK
        }
        try {
            service.executeCommandOnCoordinator(fake, true);
            fail("We expect a RPCException since the command is unknown");
        } catch (RPCException e) {
        // OK
        }
        try {
            service.executeCommandOnAllNodes(fake2_Unregistered, true);
            fail("We expect a RPCException since the command is unknown");
        } catch (RPCException e) {
        // OK
        }
        try {
            service.executeCommandOnCoordinator(fake2_Unregistered, true);
            fail("We expect a RPCException since the command is unknown");
        } catch (RPCException e) {
        // OK
        }
        List<Object> result;
        result = service.executeCommandOnAllNodes(Exception, true);
        assertTrue(result != null && result.size() == 1);
        assertTrue("We expect a RPCException since one node could not execute the command", result.get(0) instanceof RPCException);
        try {
            service.executeCommandOnCoordinator(Exception, true);
            fail("We expect a RPCException since one node could not execute the command");
        } catch (RPCException e) {
        // OK
        }
        result = service.executeCommandOnAllNodes(Error, true);
        assertTrue(result != null && result.size() == 1);
        assertTrue("We expect a RPCException since one node could not execute the command", result.get(0) instanceof RPCException);
        try {
            service.executeCommandOnCoordinator(Error, true);
            fail("We expect a RPCException since one node could not execute the command");
        } catch (RPCException e) {
        // OK
        }
        result = service.executeCommandOnAllNodes(LongTask, true);
        assertNotNull(result);
        assertTrue(result.size() == 1);
        assertNull(result.get(0));
        Object o = service.executeCommandOnCoordinator(LongTask, true);
        assertNull(o);
        result = service.executeCommandOnAllNodes(LongTask, 1000);
        assertNotNull(result);
        assertTrue(result.size() == 1);
        assertTrue("We expect an RPCException due to a Replication Timeout", result.get(0) instanceof RPCException);
        try {
            service.executeCommandOnCoordinator(LongTask, 1000);
            fail("We expect an RPCException due to a Replication Timeout");
        } catch (RPCException e) {
        // OK
        }
        result = service.executeCommandOnAllNodes(LongTask, false);
        assertNotNull(result);
        assertTrue(result.isEmpty());
        assertNull(service.executeCommandOnCoordinator(LongTask, false));
        result = service.executeCommandOnAllNodes(StringValue, true);
        assertNotNull(result);
        assertTrue(result.size() == 1);
        assertEquals("OK", result.get(0));
        o = service.executeCommandOnCoordinator(StringValue, true);
        assertEquals("OK", o);
        result = service.executeCommandOnAllNodes(NullValue, true);
        assertNotNull(result);
        assertTrue(result.size() == 1);
        assertNull(result.get(0));
        o = service.executeCommandOnCoordinator(NullValue, true);
        assertNull(o);
    } finally {
        if (service != null) {
            service.stop();
        }
    }
}
Also used : InitParams(org.exoplatform.container.xml.InitParams) RPCException(org.exoplatform.services.rpc.RPCException) RemoteCommand(org.exoplatform.services.rpc.RemoteCommand) ValueParam(org.exoplatform.container.xml.ValueParam) RPCServiceImpl(org.exoplatform.services.rpc.jgv3.RPCServiceImpl) RPCException(org.exoplatform.services.rpc.RPCException) MemberHasLeftException(org.exoplatform.services.rpc.impl.AbstractRPCService.MemberHasLeftException)

Example 17 with InitParams

use of org.exoplatform.container.xml.InitParams in project kernel by exoplatform.

the class TestRPCServiceImpl method testStates.

public void testStates() throws Exception {
    InitParams params = new InitParams();
    ValueParam paramConf = new ValueParam();
    paramConf.setName(RPCServiceImpl.PARAM_JGROUPS_CONFIG);
    paramConf.setValue("jar:/conf/portal/udp.xml");
    params.addParameter(paramConf);
    RPCServiceImpl service = null;
    RemoteCommand foo = new RemoteCommand() {

        public String getId() {
            return "foo";
        }

        public String execute(Serializable[] args) throws Throwable {
            return null;
        }
    };
    try {
        service = new RPCServiceImpl(container.getContext(), params, configManager);
        service.registerCommand(foo);
        try {
            service.executeCommandOnAllNodes(foo, true);
            fail("We expect a RPCException since the current state is not the expected one");
        } catch (RPCException e) {
        // OK
        }
        try {
            service.executeCommandOnAllNodes(foo, 10);
            fail("We expect a RPCException since the current state is not the expected one");
        } catch (RPCException e) {
        // OK
        }
        try {
            service.executeCommandOnCoordinator(foo, true);
            fail("We expect a RPCException since the current state is not the expected one");
        } catch (RPCException e) {
        // OK
        }
        try {
            service.executeCommandOnCoordinator(foo, 10);
            fail("We expect a RPCException since the current state is not the expected one");
        } catch (RPCException e) {
        // OK
        }
        try {
            service.isCoordinator();
            fail("We expect a RPCException since the current state is not the expected one");
        } catch (RPCException e) {
        // OK
        }
        service.start();
        assertEquals(true, service.isCoordinator());
        service.executeCommandOnAllNodes(foo, true);
        service.executeCommandOnAllNodes(foo, 10);
        service.executeCommandOnCoordinator(foo, true);
        service.executeCommandOnCoordinator(foo, 10);
    } finally {
        if (service != null) {
            service.stop();
        }
    }
    try {
        service.executeCommandOnAllNodes(foo, true);
        fail("We expect a RPCException since the current state is not the expected one");
    } catch (RPCException e) {
    // OK
    }
    try {
        service.executeCommandOnAllNodes(foo, 10);
        fail("We expect a RPCException since the current state is not the expected one");
    } catch (RPCException e) {
    // OK
    }
    try {
        service.executeCommandOnCoordinator(foo, true);
        fail("We expect a RPCException since the current state is not the expected one");
    } catch (RPCException e) {
    // OK
    }
    try {
        service.executeCommandOnCoordinator(foo, 10);
        fail("We expect a RPCException since the current state is not the expected one");
    } catch (RPCException e) {
    // OK
    }
}
Also used : InitParams(org.exoplatform.container.xml.InitParams) RPCException(org.exoplatform.services.rpc.RPCException) RemoteCommand(org.exoplatform.services.rpc.RemoteCommand) ValueParam(org.exoplatform.container.xml.ValueParam) RPCServiceImpl(org.exoplatform.services.rpc.jgv3.RPCServiceImpl)

Example 18 with InitParams

use of org.exoplatform.container.xml.InitParams in project kernel by exoplatform.

the class TestRPCServiceImpl method testSingleMethodCallCommand.

public void testSingleMethodCallCommand() throws Exception {
    try {
        new SingleMethodCallCommand(null, null);
        fail("we expect an IllegalArgumentException");
    } catch (IllegalArgumentException e) {
    // OK
    }
    MyService myService = new MyService();
    try {
        new SingleMethodCallCommand(myService, null);
        fail("we expect an IllegalArgumentException");
    } catch (IllegalArgumentException e) {
    // OK
    }
    try {
        new SingleMethodCallCommand(myService, "foo");
        fail("we expect an NoSuchMethodException");
    } catch (NoSuchMethodException e) {
    // OK
    }
    try {
        new SingleMethodCallCommand(myService, "getPrivateName");
        fail("we expect an IllegalArgumentException since only the public methods are allowed");
    } catch (IllegalArgumentException e) {
    // OK
    }
    InitParams params = new InitParams();
    ValueParam paramConf = new ValueParam();
    paramConf.setName(RPCServiceImpl.PARAM_JGROUPS_CONFIG);
    paramConf.setValue("jar:/conf/portal/udp.xml");
    params.addParameter(paramConf);
    RPCServiceImpl service = null;
    try {
        service = new RPCServiceImpl(container.getContext(), params, configManager);
        RemoteCommand getName = service.registerCommand(new SingleMethodCallCommand(myService, "getName"));
        RemoteCommand add = service.registerCommand(new SingleMethodCallCommand(myService, "add", int.class));
        RemoteCommand evaluate1 = service.registerCommand(new SingleMethodCallCommand(myService, "evaluate", int[].class));
        RemoteCommand evaluate2 = service.registerCommand(new SingleMethodCallCommand(myService, "evaluate", List.class));
        RemoteCommand total1 = service.registerCommand(new SingleMethodCallCommand(myService, "total", int.class));
        RemoteCommand total2 = service.registerCommand(new SingleMethodCallCommand(myService, "total", int.class, int.class));
        RemoteCommand total3 = service.registerCommand(new SingleMethodCallCommand(myService, "total", int[].class));
        RemoteCommand total4 = service.registerCommand(new SingleMethodCallCommand(myService, "total", String.class, long.class, int[].class));
        RemoteCommand testTypes1 = service.registerCommand(new SingleMethodCallCommand(myService, "testTypes", String[].class));
        RemoteCommand testTypes2 = service.registerCommand(new SingleMethodCallCommand(myService, "testTypes", int[].class));
        RemoteCommand testTypes3 = service.registerCommand(new SingleMethodCallCommand(myService, "testTypes", long[].class));
        RemoteCommand testTypes4 = service.registerCommand(new SingleMethodCallCommand(myService, "testTypes", byte[].class));
        RemoteCommand testTypes5 = service.registerCommand(new SingleMethodCallCommand(myService, "testTypes", short[].class));
        RemoteCommand testTypes6 = service.registerCommand(new SingleMethodCallCommand(myService, "testTypes", char[].class));
        RemoteCommand testTypes7 = service.registerCommand(new SingleMethodCallCommand(myService, "testTypes", double[].class));
        RemoteCommand testTypes8 = service.registerCommand(new SingleMethodCallCommand(myService, "testTypes", float[].class));
        RemoteCommand testTypes9 = service.registerCommand(new SingleMethodCallCommand(myService, "testTypes", boolean[].class));
        service.start();
        List<Object> result;
        assertEquals("name", service.executeCommandOnCoordinator(getName, true));
        result = service.executeCommandOnAllNodes(getName, true);
        assertTrue(result != null && result.size() == 1);
        assertEquals("name", result.get(0));
        assertEquals(10, service.executeCommandOnCoordinator(add, true, 10));
        result = service.executeCommandOnAllNodes(add, true, 10);
        assertTrue(result != null && result.size() == 1);
        assertEquals(20, result.get(0));
        assertEquals(100, service.executeCommandOnCoordinator(evaluate1, true, new int[] { 10, 10, 10, 30, 40 }));
        result = service.executeCommandOnAllNodes(evaluate1, true, new int[] { 10, 10, 10, 30, 40 });
        assertTrue(result != null && result.size() == 1);
        assertEquals(100, result.get(0));
        List<Integer> values = new ArrayList<Integer>();
        values.add(10);
        values.add(10);
        values.add(10);
        values.add(30);
        values.add(40);
        assertEquals(100, service.executeCommandOnCoordinator(evaluate2, true, (Serializable) values));
        result = service.executeCommandOnAllNodes(evaluate2, true, (Serializable) values);
        assertTrue(result != null && result.size() == 1);
        assertEquals(100, result.get(0));
        assertEquals(10, service.executeCommandOnCoordinator(total1, true, 10));
        result = service.executeCommandOnAllNodes(total1, true, 10);
        assertTrue(result != null && result.size() == 1);
        assertEquals(10, result.get(0));
        assertEquals(20, service.executeCommandOnCoordinator(total2, true, 10, 10));
        result = service.executeCommandOnAllNodes(total2, true, 10, 10);
        assertTrue(result != null && result.size() == 1);
        assertEquals(20, result.get(0));
        assertEquals(100, service.executeCommandOnCoordinator(total3, true, new int[] { 10, 10, 10, 30, 40 }));
        result = service.executeCommandOnAllNodes(total3, true, new int[] { 10, 10, 10, 30, 40 });
        assertTrue(result != null && result.size() == 1);
        assertEquals(100, result.get(0));
        assertEquals(100, service.executeCommandOnCoordinator(total4, true, "foo", 50, new int[] { 10, 10, 10, 30, 40 }));
        result = service.executeCommandOnAllNodes(total4, true, "foo", 50, new int[] { 10, 10, 10, 30, 40 });
        assertTrue(result != null && result.size() == 1);
        assertEquals(100, result.get(0));
        assertEquals(0, service.executeCommandOnCoordinator(total4, true, "foo", 50, null));
        result = service.executeCommandOnAllNodes(total4, true, "foo", 50, null);
        assertTrue(result != null && result.size() == 1);
        assertEquals(0, result.get(0));
        try {
            service.executeCommandOnCoordinator(total4, true, "foo", 50);
            fail("We expect a RPCException since the list of arguments mismatch with what is expected");
        } catch (RPCException e) {
        // OK
        }
        result = service.executeCommandOnAllNodes(total4, true, "foo", 50);
        assertTrue(result != null && result.size() == 1);
        assertTrue("We expect a RPCException since the list of arguments mismatch with what is expected", result.get(0) instanceof RPCException);
        assertEquals("foo", service.executeCommandOnCoordinator(testTypes1, true, (Serializable) new String[] { "foo" }));
        result = service.executeCommandOnAllNodes(testTypes1, true, (Serializable) new String[] { "foo" });
        assertTrue(result != null && result.size() == 1);
        assertEquals("foo", result.get(0));
        assertEquals(10, service.executeCommandOnCoordinator(testTypes2, true, new int[] { 10 }));
        result = service.executeCommandOnAllNodes(testTypes2, true, new int[] { 10 });
        assertTrue(result != null && result.size() == 1);
        assertEquals(10, result.get(0));
        assertEquals(11L, service.executeCommandOnCoordinator(testTypes3, true, new long[] { 10 }));
        result = service.executeCommandOnAllNodes(testTypes3, true, new long[] { 10 });
        assertTrue(result != null && result.size() == 1);
        assertEquals(11L, result.get(0));
        assertEquals((byte) 12, service.executeCommandOnCoordinator(testTypes4, true, new byte[] { 10 }));
        result = service.executeCommandOnAllNodes(testTypes4, true, new byte[] { 10 });
        assertTrue(result != null && result.size() == 1);
        assertEquals((byte) 12, result.get(0));
        assertEquals((short) 13, service.executeCommandOnCoordinator(testTypes5, true, new short[] { 10 }));
        result = service.executeCommandOnAllNodes(testTypes5, true, new short[] { 10 });
        assertTrue(result != null && result.size() == 1);
        assertEquals((short) 13, result.get(0));
        assertEquals('a', service.executeCommandOnCoordinator(testTypes6, true, new char[] { 'a' }));
        result = service.executeCommandOnAllNodes(testTypes6, true, new char[] { 'a' });
        assertTrue(result != null && result.size() == 1);
        assertEquals('a', result.get(0));
        assertEquals(10.5, service.executeCommandOnCoordinator(testTypes7, true, new double[] { 10 }));
        result = service.executeCommandOnAllNodes(testTypes7, true, new double[] { 10 });
        assertTrue(result != null && result.size() == 1);
        assertEquals(10.5, result.get(0));
        assertEquals((float) 11.5, service.executeCommandOnCoordinator(testTypes8, true, new float[] { 10 }));
        result = service.executeCommandOnAllNodes(testTypes8, true, new float[] { 10 });
        assertTrue(result != null && result.size() == 1);
        assertEquals((float) 11.5, result.get(0));
        assertEquals(true, service.executeCommandOnCoordinator(testTypes9, true, new boolean[] { true }));
        result = service.executeCommandOnAllNodes(testTypes9, true, new boolean[] { true });
        assertTrue(result != null && result.size() == 1);
        assertEquals(true, result.get(0));
    } finally {
        if (service != null) {
            service.stop();
        }
    }
}
Also used : InitParams(org.exoplatform.container.xml.InitParams) Serializable(java.io.Serializable) ArrayList(java.util.ArrayList) RPCException(org.exoplatform.services.rpc.RPCException) RemoteCommand(org.exoplatform.services.rpc.RemoteCommand) SingleMethodCallCommand(org.exoplatform.services.rpc.SingleMethodCallCommand) ArrayList(java.util.ArrayList) List(java.util.List) ValueParam(org.exoplatform.container.xml.ValueParam) RPCServiceImpl(org.exoplatform.services.rpc.jgv3.RPCServiceImpl)

Example 19 with InitParams

use of org.exoplatform.container.xml.InitParams in project kernel by exoplatform.

the class TestRPCServiceImpl method testSeveralNodes.

public void testSeveralNodes() throws Exception {
    InitParams params = new InitParams();
    ValueParam paramConf = new ValueParam();
    paramConf.setName(RPCServiceImpl.PARAM_JGROUPS_CONFIG);
    paramConf.setValue("jar:/conf/portal/udp.xml");
    params.addParameter(paramConf);
    RPCServiceImpl service1 = null, service2 = null;
    try {
        service1 = new RPCServiceImpl(container.getContext(), params, configManager);
        service2 = new RPCServiceImpl(container.getContext(), params, configManager);
        RemoteCommand CmdUnknownOnNode2 = new RemoteCommand() {

            public String getId() {
                return "CmdUnknownOnNode2";
            }

            public String execute(Serializable[] args) throws Throwable {
                return "OK";
            }
        };
        service1.registerCommand(CmdUnknownOnNode2);
        RemoteCommand ExceptionOnNode2 = new RemoteCommand() {

            public String getId() {
                return "ExceptionOnNode2";
            }

            public String execute(Serializable[] args) throws Throwable {
                return "OK";
            }
        };
        service1.registerCommand(ExceptionOnNode2);
        RemoteCommand ErrorOnNode2 = new RemoteCommand() {

            public String getId() {
                return "ErrorOnNode2";
            }

            public String execute(Serializable[] args) throws Throwable {
                return "OK";
            }
        };
        service1.registerCommand(ErrorOnNode2);
        RemoteCommand LongTaskOnNode2 = new RemoteCommand() {

            public String getId() {
                return "LongTaskOnNode2";
            }

            public String execute(Serializable[] args) throws Throwable {
                return "OK";
            }
        };
        service1.registerCommand(LongTaskOnNode2);
        service1.registerCommand(new RemoteCommand() {

            public String getId() {
                return "LongTask";
            }

            public String execute(Serializable[] args) throws Throwable {
                Thread.sleep(3000);
                return "OldCoordinator";
            }
        });
        service1.registerCommand(new RemoteCommand() {

            public String getId() {
                return "OK";
            }

            public String execute(Serializable[] args) throws Throwable {
                return "OK";
            }
        });
        service2.registerCommand(new RemoteCommand() {

            public String getId() {
                return "ExceptionOnNode2";
            }

            public String execute(Serializable[] args) throws Throwable {
                throw new Exception("MyException");
            }
        });
        service2.registerCommand(new RemoteCommand() {

            public String getId() {
                return "ErrorOnNode2";
            }

            public String execute(Serializable[] args) throws Throwable {
                throw new Error("MyError");
            }
        });
        service2.registerCommand(new RemoteCommand() {

            public String getId() {
                return "LongTaskOnNode2";
            }

            public String execute(Serializable[] args) throws Throwable {
                Thread.sleep(2000);
                return null;
            }
        });
        RemoteCommand OK = new RemoteCommand() {

            public String getId() {
                return "OK";
            }

            public String execute(Serializable[] args) throws Throwable {
                return "OK";
            }
        };
        service2.registerCommand(OK);
        final RemoteCommand LongTask = new RemoteCommand() {

            public String getId() {
                return "LongTask";
            }

            public String execute(Serializable[] args) throws Throwable {
                return "NewCoordinator";
            }
        };
        service2.registerCommand(LongTask);
        MyListener listener1 = new MyListener();
        service1.registerTopologyChangeListener(listener1);
        MyListener listener2 = new MyListener();
        service2.registerTopologyChangeListener(listener2);
        assertFalse(listener1.coordinatorHasChanged);
        assertFalse(listener1.isCoordinator);
        assertEquals(0, listener1.count);
        assertFalse(listener2.coordinatorHasChanged);
        assertFalse(listener2.isCoordinator);
        assertEquals(0, listener2.count);
        service1.start();
        assertFalse(listener1.coordinatorHasChanged);
        assertTrue(listener1.isCoordinator);
        assertEquals(1, listener1.count);
        assertFalse(listener2.coordinatorHasChanged);
        assertFalse(listener2.isCoordinator);
        assertEquals(0, listener2.count);
        service2.start();
        assertFalse(listener1.coordinatorHasChanged);
        assertTrue(listener1.isCoordinator);
        assertEquals(2, listener1.count);
        assertFalse(listener2.coordinatorHasChanged);
        assertFalse(listener2.isCoordinator);
        assertEquals(1, listener2.count);
        assertEquals(true, service1.isCoordinator());
        assertEquals(false, service2.isCoordinator());
        List<Object> result;
        Object o;
        result = service1.executeCommandOnAllNodes(CmdUnknownOnNode2, true);
        assertTrue(result != null && result.size() == 2);
        assertEquals("OK", result.get(0));
        assertTrue("We expect a RPCException since the command is unknown on node 2", result.get(1) instanceof RPCException);
        o = service1.executeCommandOnCoordinator(CmdUnknownOnNode2, true);
        assertEquals("OK", o);
        result = service1.executeCommandOnAllNodes(ExceptionOnNode2, true);
        assertTrue(result != null && result.size() == 2);
        assertEquals("OK", result.get(0));
        assertTrue("We expect a RPCException since the command fails on node 2", result.get(1) instanceof RPCException);
        o = service1.executeCommandOnCoordinator(ExceptionOnNode2, true);
        assertEquals("OK", o);
        result = service1.executeCommandOnAllNodes(ErrorOnNode2, true);
        assertTrue(result != null && result.size() == 2);
        assertEquals("OK", result.get(0));
        assertTrue("We expect a RPCException since the command fails on node 2", result.get(1) instanceof RPCException);
        o = service1.executeCommandOnCoordinator(ErrorOnNode2, true);
        assertEquals("OK", o);
        result = service1.executeCommandOnAllNodes(LongTaskOnNode2, 1000);
        assertNotNull(result);
        assertTrue(result.size() == 2);
        assertEquals("OK", result.get(0));
        assertTrue("We expect an RPCException due to a Replication Timeout", result.get(1) instanceof RPCException);
        o = service1.executeCommandOnCoordinator(LongTaskOnNode2, 1000);
        assertEquals("OK", o);
        List<Address> allMembers = service1.members;
        List<Address> coordinatorOnly = new ArrayList<Address>(1);
        coordinatorOnly.add(service1.coordinator);
        final RPCServiceImpl service = service2;
        final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
        final CountDownLatch doneSignal = new CountDownLatch(1);
        Thread t = new Thread() {

            @Override
            public void run() {
                try {
                    Object o = service.executeCommandOnCoordinator(LongTask, true);
                    assertEquals("NewCoordinator", o);
                } catch (Throwable e) {
                    error.set(e);
                    e.printStackTrace();
                } finally {
                    doneSignal.countDown();
                }
            }
        };
        t.start();
        service1.stop();
        listener2.waitTopologyChange();
        assertFalse(listener1.coordinatorHasChanged);
        assertTrue(listener1.isCoordinator);
        assertEquals(2, listener1.count);
        assertTrue(listener2.coordinatorHasChanged);
        assertTrue(listener2.isCoordinator);
        assertEquals(2, listener2.count);
        doneSignal.await();
        assertNull(error.get() != null ? error.get().getMessage() : "", error.get());
        result = service2.excecuteCommand(allMembers, OK, true, 0);
        assertNotNull(result);
        assertTrue(result.size() == 2);
        assertTrue("We expect an RPCException due to a member that has left", result.get(0) instanceof MemberHasLeftException);
        assertEquals("OK", result.get(1));
        result = service2.excecuteCommand(coordinatorOnly, OK, true, 0);
        assertNotNull(result);
        assertTrue(result.size() == 1);
        assertTrue("We expect an RPCException due to a member that has left", result.get(0) instanceof MemberHasLeftException);
        try {
            service1.isCoordinator();
            fail("We expect a RPCException since the current state is not the expected one");
        } catch (RPCException e) {
        // OK
        }
        assertEquals(true, service2.isCoordinator());
    } finally {
        if (service1 != null) {
            service1.stop();
        }
        if (service2 != null) {
            service2.stop();
        }
    }
}
Also used : InitParams(org.exoplatform.container.xml.InitParams) Serializable(java.io.Serializable) Address(org.jgroups.Address) ArrayList(java.util.ArrayList) AtomicReference(java.util.concurrent.atomic.AtomicReference) CountDownLatch(java.util.concurrent.CountDownLatch) RPCException(org.exoplatform.services.rpc.RPCException) MemberHasLeftException(org.exoplatform.services.rpc.impl.AbstractRPCService.MemberHasLeftException) RPCException(org.exoplatform.services.rpc.RPCException) RemoteCommand(org.exoplatform.services.rpc.RemoteCommand) ValueParam(org.exoplatform.container.xml.ValueParam) RPCServiceImpl(org.exoplatform.services.rpc.jgv3.RPCServiceImpl) MemberHasLeftException(org.exoplatform.services.rpc.impl.AbstractRPCService.MemberHasLeftException)

Example 20 with InitParams

use of org.exoplatform.container.xml.InitParams in project kernel by exoplatform.

the class TestPersistedQuartzScheduler method setUp.

public void setUp() throws Exception {
    manager = PortalContainer.getInstance();
    manager.getComponentInstanceOfType(InitialContextInitializer.class);
    DataSource dataSource = (DataSource) new InitialContext().lookup("jdbcjcr");
    connection = dataSource.getConnection();
    connection.setAutoCommit(true);
    st = connection.createStatement();
    /**
     *init quartz tables**
     */
    String scripts = IOUtil.getStreamContentAsString(PrivilegedFileHelper.getResourceAsStream("/quartz_hsqldb.sql"));
    for (String query : splitWithSQLDelimiter(scripts)) {
        st.executeUpdate(query);
    }
    /**
     *init QuartzSheduler Service**
     */
    InitParams initParams = new InitParams();
    ValueParam valueParam = new ValueParam();
    valueParam.setName("org.quartz.dataSource.quartzDS.jndiURL");
    valueParam.setValue("jdbcjcr");
    initParams.addParameter(valueParam);
    valueParam = new ValueParam();
    valueParam.setName("org.quartz.jobStore.driverDelegateClass");
    valueParam.setValue("org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
    initParams.addParameter(valueParam);
    valueParam = new ValueParam();
    valueParam.setName("org.quartz.jobStore.class");
    valueParam.setValue("org.quartz.impl.jdbcjobstore.JobStoreTX");
    initParams.addParameter(valueParam);
    valueParam = new ValueParam();
    valueParam.setName("org.quartz.threadPool.threadCount");
    valueParam.setValue("5");
    initParams.addParameter(valueParam);
    valueParam = new ValueParam();
    valueParam.setName("org.quartz.jobStore.dataSource");
    valueParam.setValue("quartzDS");
    initParams.addParameter(valueParam);
    valueParam = new ValueParam();
    valueParam.setName("org.quartz.jobStore.tablePrefix");
    valueParam.setValue("QRTZ_");
    initParams.addParameter(valueParam);
    valueParam = new ValueParam();
    valueParam.setName("org.quartz.jobStore.useProperties");
    valueParam.setValue("true");
    initParams.addParameter(valueParam);
    QueueTasks queueTasks = new QueueTasks();
    QuartzSheduler quartzSheduler = new QuartzSheduler(PortalContainer.getInstance().getContext(), initParams);
    jobSchedulerService = new JobSchedulerServiceImpl(quartzSheduler, queueTasks);
}
Also used : InitParams(org.exoplatform.container.xml.InitParams) QuartzSheduler(org.exoplatform.services.scheduler.impl.QuartzSheduler) ValueParam(org.exoplatform.container.xml.ValueParam) InitialContext(javax.naming.InitialContext) JobSchedulerServiceImpl(org.exoplatform.services.scheduler.impl.JobSchedulerServiceImpl) DataSource(javax.sql.DataSource)

Aggregations

InitParams (org.exoplatform.container.xml.InitParams)26 ValueParam (org.exoplatform.container.xml.ValueParam)16 RPCServiceImpl (org.exoplatform.services.rpc.jgv3.RPCServiceImpl)7 HashSet (java.util.HashSet)5 ConfigurationManagerImpl (org.exoplatform.container.configuration.ConfigurationManagerImpl)5 Component (org.exoplatform.container.xml.Component)5 PropertiesParam (org.exoplatform.container.xml.PropertiesParam)5 RemoteCommand (org.exoplatform.services.rpc.RemoteCommand)5 URL (java.net.URL)4 ArrayList (java.util.ArrayList)4 ObjectParameter (org.exoplatform.container.xml.ObjectParameter)4 RPCException (org.exoplatform.services.rpc.RPCException)4 ConfigurationManager (org.exoplatform.container.configuration.ConfigurationManager)3 Configuration (org.exoplatform.container.xml.Configuration)3 Serializable (java.io.Serializable)2 DataSource (javax.sql.DataSource)2 RootContainer (org.exoplatform.container.RootContainer)2 DataSourceProvider (org.exoplatform.services.jdbc.DataSourceProvider)2 MemberHasLeftException (org.exoplatform.services.rpc.impl.AbstractRPCService.MemberHasLeftException)2 InvocationTargetException (java.lang.reflect.InvocationTargetException)1