@SmackIntegrationTest public void waitForClosingStreamElementTest(XMPPTCPConnection connection) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { connection.disconnect(); Field closingStreamReceivedField = connection.getClass().getDeclaredField("closingStreamReceived"); closingStreamReceivedField.setAccessible(true); SynchronizationPoint<?> closingStreamReceived = (SynchronizationPoint<?>) closingStreamReceivedField.get(connection); Exception failureException = closingStreamReceived.getFailureException(); if (failureException != null) { throw new AssertionError("Sync poing yielded failure exception", failureException); } assertTrue(closingStreamReceived.wasSuccessful()); } }
protected SmackIntegrationTestEnvironment prepareEnvironment() throws SmackException, IOException, XMPPException, InterruptedException, KeyManagementException, NoSuchAlgorithmException { XMPPTCPConnection conOne = null; XMPPTCPConnection conTwo = null; XMPPTCPConnection conThree = null; try { conOne = getConnectedConnectionFor(AccountNum.One); conTwo = getConnectedConnectionFor(AccountNum.Two); conThree = getConnectedConnectionFor(AccountNum.Three); } catch (Exception e) { // TODO Reverse the order, i.e. conThree should be disconnected first. if (conOne != null) { conOne.disconnect(); } if (conTwo != null) { conTwo.disconnect(); } if (conThree != null) { conThree.disconnect(); } throw e; } return new SmackIntegrationTestEnvironment(conOne, conTwo, conThree, testRunResult.testRunId, config); }
public static void disconnectAndMaybeDelete(XMPPTCPConnection connection, Configuration config) throws InterruptedException { try { if (!config.isAccountRegistrationPossible()) { return; } Configuration.AccountRegistration accountDeletionMethod = config.accountRegistration; AccountManager accountManager = AccountManager.getInstance(connection); try { if (accountManager.isSupported()) { accountDeletionMethod = AccountRegistration.inBandRegistration; } } catch (NoResponseException | XMPPErrorException | NotConnectedException e) { LOGGER.log(Level.WARNING, "Could not test if XEP-0077 account deletion is possible", e); } switch (accountDeletionMethod) { case inBandRegistration: deleteViaIbr(connection); break; case serviceAdministration: deleteViaServiceAdministration(connection, config); break; default: throw new AssertionError(); } } finally { connection.disconnect(); } }
public static void deleteViaServiceAdministration(XMPPTCPConnection connection, Configuration config) { EntityBareJid accountToDelete = connection.getUser().asEntityBareJid(); final int maxAttempts = 3; int attempts; for (attempts = 0; attempts < maxAttempts; attempts++) { connection.disconnect(); try { connection.connect().login(config.adminAccountUsername, config.adminAccountPassword); } catch (XMPPException | SmackException | IOException | InterruptedException e) { LOGGER.log(Level.WARNING, "Exception deleting account for " + connection, e); continue; } ServiceAdministrationManager adminManager = ServiceAdministrationManager.getInstanceFor(connection); try { adminManager.deleteUser(accountToDelete); break; } catch (NoResponseException | XMPPErrorException | NotConnectedException | InterruptedException e) { LOGGER.log(Level.WARNING, "Exception deleting account for " + connection, e); continue; } } if (attempts > maxAttempts) { LOGGER.log(Level.SEVERE, "Could not delete account for connection: " + connection); } }
public static boolean supportsIbr(DomainBareJid xmppDomain) throws SmackException, IOException, XMPPException, InterruptedException, KeyManagementException, NoSuchAlgorithmException { XMPPTCPConnectionConfiguration.Builder configBuilder = XMPPTCPConnectionConfiguration.builder() .setXmppDomain(xmppDomain); TLSUtils.acceptAllCertificates(configBuilder); XMPPTCPConnectionConfiguration config = configBuilder.build(); XMPPTCPConnection connection = new XMPPTCPConnection(config); connection.connect(); try { return supportsIbr(connection); } finally { connection.disconnect(); } }
public static UsernameAndPassword registerAccountViaAdmin(XMPPTCPConnection connection, String username, String password, String adminAccountUsername, String adminAccountPassword) throws InterruptedException, XMPPException, SmackException, IOException { connection.login(adminAccountUsername, adminAccountPassword); ServiceAdministrationManager adminManager = ServiceAdministrationManager.getInstanceFor(connection); EntityBareJid userJid = JidCreate.entityBareFrom(Localpart.from(username), connection.getXMPPServiceDomain()); adminManager.addUser(userJid, password); connection.disconnect(); connection.connect(); return new UsernameAndPassword(username, password); }
public static boolean createAccount(DomainBareJid xmppDomain, Localpart username, String password) throws KeyManagementException, NoSuchAlgorithmException, SmackException, IOException, XMPPException, InterruptedException { XMPPTCPConnectionConfiguration.Builder configBuilder = XMPPTCPConnectionConfiguration.builder() .setXmppDomain(xmppDomain); TLSUtils.acceptAllCertificates(configBuilder); XMPPTCPConnectionConfiguration config = configBuilder.build(); XMPPTCPConnection connection = new XMPPTCPConnection(config); connection.connect(); try { if (!supportsIbr(connection)) return false; AccountManager accountManager = AccountManager.getInstance(connection); accountManager.createAccount(username, password); return true; } finally { connection.disconnect(); } } }
@SmackIntegrationTest public void testPresenceEventListenersOffline(final XMPPTCPConnection conOne, final XMPPTCPConnection conTwo) throws TimeoutException, Exception { IntegrationTestRosterUtil.ensureBothAccountsAreNotInEachOthersRoster(conOne, conTwo); final Roster rosterOne = Roster.getInstanceFor(conOne); final Roster rosterTwo = Roster.getInstanceFor(conTwo); // TODO create Roster.createEntry() with boolean flag for subscribe or not. rosterOne.createEntry(conTwo.getUser().asBareJid(), "Con Two", null); rosterTwo.createEntry(conOne.getUser().asBareJid(), "Con One", null); // TODO Change timeout form '5000' to something configurable. final long timeout = 5000; IntegrationTestRosterUtil.ensureBothAccountsAreSubscribedToEachOther(conOne, conTwo, timeout); final SimpleResultSyncPoint offlineTriggered = new SimpleResultSyncPoint(); rosterOne.addPresenceEventListener(new AbstractPresenceEventListener() { @Override public void presenceUnavailable(FullJid jid, Presence presence) { if (!jid.equals(conTwo.getUser())) { return; } offlineTriggered.signal(); } }); // Disconnect conTwo, this should cause an 'unavailable' presence to be send from conTwo to // conOne. conTwo.disconnect(); Boolean result = offlineTriggered.waitForResult(timeout); if (!result) { throw new Exception("presenceUnavailable() was not called"); } }
+ " received closing </stream> element." + " Server wants to terminate the connection, calling disconnect()"); disconnect();
connection.disconnect(); connection.connect();
public static void iotScenario(String dataThingJidString, String dataThingPassword, String readingThingJidString, String readingThingPassword, IotScenario scenario) throws Exception { final EntityBareJid dataThingJid = JidCreate.entityBareFrom(dataThingJidString); final EntityBareJid readingThingJid = JidCreate.entityBareFrom(readingThingJidString); final XMPPTCPConnectionConfiguration dataThingConnectionConfiguration = XMPPTCPConnectionConfiguration.builder() .setUsernameAndPassword(dataThingJid.getLocalpart(), dataThingPassword) .setXmppDomain(dataThingJid.asDomainBareJid()).setSecurityMode(SecurityMode.disabled) .enableDefaultDebugger().build(); final XMPPTCPConnectionConfiguration readingThingConnectionConfiguration = XMPPTCPConnectionConfiguration .builder().setUsernameAndPassword(readingThingJid.getLocalpart(), readingThingPassword) .setXmppDomain(readingThingJid.asDomainBareJid()).setSecurityMode(SecurityMode.disabled) .enableDefaultDebugger().build(); final XMPPTCPConnection dataThingConnection = new XMPPTCPConnection(dataThingConnectionConfiguration); final XMPPTCPConnection readingThingConnection = new XMPPTCPConnection(readingThingConnectionConfiguration); dataThingConnection.setReplyTimeout(TIMEOUT); readingThingConnection.setReplyTimeout(TIMEOUT); dataThingConnection.setUseStreamManagement(false); readingThingConnection.setUseStreamManagement(false); try { dataThingConnection.connect().login(); readingThingConnection.connect().login(); scenario.iotScenario(dataThingConnection, readingThingConnection); } finally { dataThingConnection.disconnect(); readingThingConnection.disconnect(); } }
connection.disconnect();
@SmackIntegrationTest public void testMucBookmarksAutojoin(XMPPTCPConnection connection) throws InterruptedException, TestNotPossibleException, XMPPException, SmackException, IOException { final BookmarkManager bookmarkManager = BookmarkManager.getBookmarkManager(connection); if (!bookmarkManager.isSupported()) { throw new TestNotPossibleException("Private data storage not supported"); } final MultiUserChatManager multiUserChatManager = MultiUserChatManager.getInstanceFor(connection); final Resourcepart mucNickname = Resourcepart.from("Nick-" + StringUtils.randomString(6)); final String randomMucName = StringUtils.randomString(6); final DomainBareJid mucComponent = multiUserChatManager.getMucServiceDomains().get(0); final MultiUserChat muc = multiUserChatManager.getMultiUserChat(JidCreate.entityBareFrom( Localpart.from(randomMucName), mucComponent)); MucCreateConfigFormHandle handle = muc.createOrJoin(mucNickname); if (handle != null) { handle.makeInstant(); } muc.leave(); bookmarkManager.addBookmarkedConference("Smack Inttest: " + testRunId, muc.getRoom(), true, mucNickname, null); connection.disconnect(); connection.connect().login(); // MucBookmarkAutojoinManager is also able to do its task automatically // after every login, it's not deterministic when this will be finished. // So we trigger it manually here. MucBookmarkAutojoinManager.getInstanceFor(connection).autojoinBookmarkedConferences(); assertTrue(muc.isJoined()); // If the test went well, leave the MUC muc.leave(); }
@Override public void stop() { synchronized (this.lifecycleMonitor) { if (this.isRunning()) { getConnection().disconnect(); this.running = false; } } }
@Override public void reconnectionFailed(Exception e) { LOG.warn("XMPP reconnection failed", e); try { xmpp.disconnect(); } catch (NotConnectedException ex) { LOG.error("XMPP disconnect failed", ex); } instance = null; }
public void stop() { synchronized (this.lifecycleMonitor) { if (this.isRunning()) { this.connection.disconnect(); this.running = false; } } }
public void disconnectGracefully() { logger.info("Disconnecting ..."); if (xmppConn.isConnected()) { logger.info("Disconnecting the xmpp server from FCM"); xmppConn.disconnect(); // this method call the onClosed listener because it have not been detached } }
@Override protected void onShutdown() { if (logger.isInfoEnabled()) { logger.info("Shutting down XMPP receiver [" + connection.getUser() + "]"); } if (connection.isConnected()) { connection.disconnect(); } }
@Override protected void onShutdown() { if (logger.isInfoEnabled()) { logger.info("Shutting down XMPP receiver [" + connection.getUser() + "]"); } if (connection.isConnected()) { connection.disconnect(); } }
public void destroy(final @Observes ContainerSystemPreDestroy destroy) throws Exception { if (chatManager != null) { connection.disconnect(); chatManager = null; } SystemInstance.get().removeObserver(this); }