Java ClientSession.close方法代码示例

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Path("/{queue-name}")
public synchronized QueueResource findQueue(@PathParam("queue-name") String name) throws Exception {
   QueueResource queue = queues.get(name);
   if (queue == null) {
      String queueName = name;
      ClientSession session = manager.getSessionFactory().createSession(false, false, false);
      try {
         ClientSession.QueueQuery query = session.queueQuery(new SimpleString(queueName));
         if (!query.isExists()) {
            throw new WebApplicationException(Response.status(404).type("text/plain").entity("Queue '" + name + "' does not exist").build());
         }
         DestinationSettings queueSettings = manager.getDefaultSettings();
         boolean defaultDurable = queueSettings.isDurableSend() || query.isDurable();

         queue = createQueueResource(queueName, defaultDurable, queueSettings.getConsumerSessionTimeoutSeconds(), queueSettings.isDuplicatesAllowed());
      } finally {
         try {
            session.close();
         } catch (ActiveMQException e) {
         }
      }
   }
   return queue;
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testProducerWithSmallWindowSizeAndLargeMessage() throws Exception {
   final CountDownLatch latch = new CountDownLatch(1);
   server.getRemotingService().addIncomingInterceptor(new Interceptor() {
      @Override
      public boolean intercept(final Packet packet, final RemotingConnection connection) throws ActiveMQException {
         if (packet.getType() == PacketImpl.SESS_SEND) {
            latch.countDown();
         }
         return true;
      }
   });
   ServerLocator locator = createInVMNonHALocator().setConfirmationWindowSize(100);
   ClientSessionFactory cf = locator.createSessionFactory();
   ClientSession session = cf.createSession(false, true, true);
   ClientProducer producer = session.createProducer(QUEUE);
   ClientMessage message = session.createMessage(true);
   byte[] body = new byte[1000];
   message.getBodyBuffer().writeBytes(body);
   producer.send(message);
   Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
   session.close();
   locator.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testRollbackWithSend() throws Exception {
   cf = createSessionFactory(locator);
   ClientSession clientSession = cf.createSession(false, false, true);
   clientSession.createQueue(queueName, queueName, false);
   ClientProducer cp = clientSession.createProducer(queueName);
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   Queue q = (Queue) server.getPostOffice().getBinding(new SimpleString(queueName)).getBindable();
   Assert.assertEquals(0, getMessageCount(q));
   clientSession.rollback();
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   clientSession.commit();
   Assert.assertEquals(2, getMessageCount(q));
   clientSession.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testAsyncConsumerAck() throws Exception {
   ActiveMQServer server = createServer(false);
   server.start();
   ServerLocator locator = createInVMNonHALocator().setBlockOnAcknowledge(true).setAckBatchSize(0);
   ClientSessionFactory cf = createSessionFactory(locator);
   ClientSession sendSession = cf.createSession(false, true, true);
   final ClientSession session = cf.createSession(false, true, true);
   sendSession.createQueue(addressA, queueA, false);
   ClientProducer cp = sendSession.createProducer(addressA);
   ClientConsumer cc = session.createConsumer(queueA);
   int numMessages = 100;
   for (int i = 0; i < numMessages; i++) {
      cp.send(sendSession.createMessage(false));
   }
   final CountDownLatch latch = new CountDownLatch(numMessages);
   session.start();
   cc.setMessageHandler(new MessageHandler() {
      @Override
      public void onMessage(final ClientMessage message) {
         try {
            message.acknowledge();
         } catch (ActiveMQException e) {
            try {
               session.close();
            } catch (ActiveMQException e1) {
               e1.printStackTrace();
            }
         }
         latch.countDown();
      }
   });
   Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
   Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
   Assert.assertEquals(0, q.getDeliveringCount());
   sendSession.close();
   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testRequest() throws Exception {
   final SimpleString key = RandomUtil.randomSimpleString();
   long value = RandomUtil.randomLong();
   SimpleString requestAddress = new SimpleString("AdTest");
   SimpleString requestQueue = RandomUtil.randomSimpleString();

   final ClientSession session = sf.createSession(false, true, true);

   session.start();

   session.createTemporaryQueue(requestAddress, requestQueue);

   ClientConsumer requestConsumer = session.createConsumer(requestQueue);
   requestConsumer.setMessageHandler(new SimpleMessageHandler(key, session));

   ClientRequestor requestor = new ClientRequestor(session, requestAddress);
   ClientMessage request = session.createMessage(false);
   request.putLongProperty(key, value);

   ClientMessage reply = requestor.request(request, 500);
   Assert.assertNotNull("reply was not received", reply);
   Assert.assertEquals(value, reply.getObjectProperty(key));

   Thread.sleep(5000);
   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testAsyncConsumerRollback() throws Exception {
   ActiveMQServer server = createServer(false);
   server.start();
   ServerLocator locator = createInVMNonHALocator().setBlockOnAcknowledge(true).setAckBatchSize(0);
   ClientSessionFactory cf = createSessionFactory(locator);
   ClientSession sendSession = cf.createSession(false, true, true);
   final ClientSession session = cf.createSession(false, true, false);
   sendSession.createQueue(addressA, queueA, false);
   ClientProducer cp = sendSession.createProducer(addressA);
   ClientConsumer cc = session.createConsumer(queueA);
   int numMessages = 100;
   for (int i = 0; i < numMessages; i++) {
      cp.send(sendSession.createMessage(false));
   }
   CountDownLatch latch = new CountDownLatch(numMessages);
   session.start();
   cc.setMessageHandler(new ackHandler(session, latch));
   Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
   Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
   Assert.assertEquals(numMessages, q.getDeliveringCount());
   Assert.assertEquals(numMessages, getMessageCount(q));
   session.stop();
   session.rollback();
   Assert.assertEquals(0, q.getDeliveringCount());
   Assert.assertEquals(numMessages, getMessageCount(q));
   latch = new CountDownLatch(numMessages);
   cc.setMessageHandler(new ackHandler(session, latch));
   session.start();
   Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
   sendSession.close();
   session.close();
   cf.close();

}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
public static void main(final String[] args) throws Exception {
   if (args.length != 2) {
      throw new Exception("require 2 arguments: queue name + message text");
   }
   String queueName = args[0];
   String messageText = args[1];

   try {
      ServerLocator locator = ActiveMQClient.createServerLocatorWithoutHA(new TransportConfiguration(NettyConnectorFactory.class.getName()));
      ClientSessionFactory sf = locator.createSessionFactory();
      ClientSession session = sf.createSession(false, true, true);
      ClientProducer producer = session.createProducer(queueName);
      ClientConsumer consumer = session.createConsumer(queueName);

      ClientMessage message = session.createMessage(ActiveMQTextMessage.TYPE, false, 0, System.currentTimeMillis(), (byte) 1);
      message.getBodyBuffer().writeString(messageText);
      producer.send(message);

      session.start();

      // block in receiving for 5 secs, we won't receive anything
      consumer.receive(5000);

      // this should silence any non-daemon thread and allow for graceful exit
      session.close();
      System.exit(0);
   } catch (Throwable t) {
      GracefulClient.log.error(t.getMessage(), t);
      System.exit(1);
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testMessageAttributes() throws Exception {

   ClientSession session = basicSetUp();

   session.createQueue(QUEUE_NAME, RoutingType.MULTICAST, QUEUE_NAME, true);

   ClientProducer producer = session.createProducer(QUEUE_NAME);

   ClientMessage msg = session.createMessage(Message.BYTES_TYPE, true);
   msg.setExpiration(Long.MAX_VALUE);
   msg.setPriority((byte) 0);
   msg.setTimestamp(Long.MAX_VALUE - 1);
   msg.setUserID(UUIDGenerator.getInstance().generateUUID());
   producer.send(msg);

   session.close();
   locator.close();
   server.stop();

   ByteArrayOutputStream xmlOutputStream = new ByteArrayOutputStream();
   XmlDataExporter xmlDataExporter = new XmlDataExporter();
   xmlDataExporter.process(xmlOutputStream, server.getConfiguration().getBindingsDirectory(), server.getConfiguration().getJournalDirectory(), server.getConfiguration().getPagingDirectory(), server.getConfiguration().getLargeMessagesDirectory());
   System.out.print(new String(xmlOutputStream.toByteArray()));

   clearDataRecreateServerDirs();
   server.start();
   checkForLongs();
   locator = createInVMNonHALocator();
   factory = createSessionFactory(locator);
   session = factory.createSession(false, true, true);

   ByteArrayInputStream xmlInputStream = new ByteArrayInputStream(xmlOutputStream.toByteArray());
   XmlDataImporter xmlDataImporter = new XmlDataImporter();
   xmlDataImporter.validate(xmlInputStream);
   xmlInputStream.reset();
   xmlDataImporter.process(xmlInputStream, session);
   ClientConsumer consumer = session.createConsumer(QUEUE_NAME);
   session.start();

   msg = consumer.receive(CONSUMER_TIMEOUT);
   assertEquals(Long.MAX_VALUE, msg.getExpiration());
   assertEquals((byte) 0, msg.getPriority());
   assertEquals(Long.MAX_VALUE - 1, msg.getTimestamp());
   assertNotNull(msg.getUserID());
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testLargeJmsTextMessage() throws Exception {
   basicSetUp();
   ConnectionFactory cf = ActiveMQJMSClient.createConnectionFactory("vm://0", "test");
   Connection c = cf.createConnection();
   Session s = c.createSession(false, Session.AUTO_ACKNOWLEDGE);
   server.createQueue(SimpleString.toSimpleString("A"), RoutingType.ANYCAST, SimpleString.toSimpleString("A"), null, true, false);
   MessageProducer p = s.createProducer(ActiveMQJMSClient.createQueue("A"));
   p.setDeliveryMode(DeliveryMode.PERSISTENT);
   StringBuilder stringBuilder = new StringBuilder();
   for (int i = 0; i < 1024 * 200; i++) {
      stringBuilder.append(RandomUtil.randomChar());
   }
   TextMessage textMessage = s.createTextMessage(stringBuilder.toString());
   textMessage.setStringProperty("_AMQ_DUPL_ID", String.valueOf(UUID.randomUUID()));
   p.send(textMessage);
   c.close();

   locator.close();
   server.stop();

   ByteArrayOutputStream xmlOutputStream = new ByteArrayOutputStream();
   XmlDataExporter xmlDataExporter = new XmlDataExporter();
   xmlDataExporter.process(xmlOutputStream, server.getConfiguration().getBindingsDirectory(), server.getConfiguration().getJournalDirectory(), server.getConfiguration().getPagingDirectory(), server.getConfiguration().getLargeMessagesDirectory());
   System.out.print(new String(xmlOutputStream.toByteArray()));

   clearDataRecreateServerDirs();
   server.start();
   checkForLongs();
   locator = createInVMNonHALocator();
   factory = createSessionFactory(locator);
   ClientSession session = factory.createSession(false, true, true);

   ByteArrayInputStream xmlInputStream = new ByteArrayInputStream(xmlOutputStream.toByteArray());
   XmlDataImporter xmlDataImporter = new XmlDataImporter();
   xmlDataImporter.validate(xmlInputStream);
   xmlInputStream.reset();
   xmlDataImporter.process(xmlInputStream, session);
   session.close();

   c = cf.createConnection();
   s = c.createSession();
   MessageConsumer mc = s.createConsumer(ActiveMQJMSClient.createQueue("A"));
   c.start();
   javax.jms.Message msg = mc.receive(CONSUMER_TIMEOUT);

   assertNotNull(msg);

   c.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Override
@Before
public void setUp() throws Exception {
   super.setUp();

   Configuration config = createDefaultConfig(isNetty()).setJournalFileSize(10 * 1024 * 1024);

   server = createServer(IS_JOURNAL, config, -1, -1, new HashMap<String, AddressSettings>());

   server.start();

   ServerLocator locator = createFactory(isNetty());

   ClientSessionFactory sf = createSessionFactory(locator);

   ClientSession session = sf.createSession();

   session.createQueue(ClientNonDivertedSoakTest.ADDRESS, ClientNonDivertedSoakTest.ADDRESS, true);

   session.close();

   sf.close();

   locator.close();

}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void test3LevelHierarchyWithDLA() throws Exception {
   ActiveMQServer server = createServer(false);

   server.start();
   AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(dlaA).setMaxDeliveryAttempts(1);
   AddressSettings addressSettings2 = new AddressSettings().setDeadLetterAddress(dlaB).setMaxDeliveryAttempts(1);
   AddressSettings addressSettings3 = new AddressSettings().setDeadLetterAddress(dlaC).setMaxDeliveryAttempts(1);
   HierarchicalRepository<AddressSettings> repos = server.getAddressSettingsRepository();
   repos.addMatch(addressA2.toString(), addressSettings);
   repos.addMatch("add.*", addressSettings2);
   repos.addMatch("#", addressSettings3);
   ServerLocator locator = createInVMNonHALocator();
   ClientSessionFactory sf = createSessionFactory(locator);
   ClientSession session = sf.createSession(false, true, false);
   session.createQueue(addressA2, queueA, false);
   session.createQueue(addressB2, queueB, false);
   session.createQueue(addressC, queueC, false);
   session.createQueue(dlaA, dlqA, false);
   session.createQueue(dlaB, dlqB, false);
   session.createQueue(dlaC, dlqC, false);
   ClientSession sendSession = sf.createSession(false, true, true);
   ClientMessage cm = sendSession.createMessage(true);
   cm.getBodyBuffer().writeString("A");
   ClientMessage cm2 = sendSession.createMessage(true);
   cm2.getBodyBuffer().writeString("B");
   ClientMessage cm3 = sendSession.createMessage(true);
   cm3.getBodyBuffer().writeString("C");
   ClientProducer cp1 = sendSession.createProducer(addressA2);
   ClientProducer cp2 = sendSession.createProducer(addressB2);
   ClientProducer cp3 = sendSession.createProducer(addressC);
   cp1.send(cm);
   cp2.send(cm2);
   cp3.send(cm3);

   ClientConsumer dlqARec = session.createConsumer(dlqA);
   ClientConsumer dlqBrec = session.createConsumer(dlqB);
   ClientConsumer dlqCrec = session.createConsumer(dlqC);
   ClientConsumer cc1 = session.createConsumer(queueA);
   ClientConsumer cc2 = session.createConsumer(queueB);
   ClientConsumer cc3 = session.createConsumer(queueC);
   session.start();
   ClientMessage message = cc1.receive(5000);
   Assert.assertNotNull(message);
   message.acknowledge();
   message = cc2.receive(5000);
   Assert.assertNotNull(message);
   message.acknowledge();
   message = cc3.receive(5000);
   Assert.assertNotNull(message);
   message.acknowledge();
   session.rollback();
   cc1.close();
   cc2.close();
   cc3.close();
   message = dlqARec.receive(5000);
   Assert.assertNotNull(message);
   Assert.assertEquals("A", message.getBodyBuffer().readString());
   message = dlqBrec.receive(5000);
   Assert.assertNotNull(message);
   Assert.assertEquals("B", message.getBodyBuffer().readString());
   message = dlqCrec.receive(5000);
   Assert.assertNotNull(message);
   Assert.assertEquals("C", message.getBodyBuffer().readString());
   sendSession.close();
   session.close();

}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
public void testScheduledMessagesDeliveredCorrectly(final boolean recover) throws Exception {

      ClientSessionFactory sessionFactory = createSessionFactory(locator);
      ClientSession session = sessionFactory.createSession(false, true, false);
      session.createQueue(atestq, atestq, null, true);
      ClientProducer producer = session.createProducer(atestq);
      ClientMessage m1 = createDurableMessage(session, "m1");
      ClientMessage m2 = createDurableMessage(session, "m2");
      ClientMessage m3 = createDurableMessage(session, "m3");
      ClientMessage m4 = createDurableMessage(session, "m4");
      ClientMessage m5 = createDurableMessage(session, "m5");
      long time = System.currentTimeMillis();
      time += 10000;
      m1.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, time);
      producer.send(m1);
      time += 1000;
      m2.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, time);
      producer.send(m2);
      time += 1000;
      m3.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, time);
      producer.send(m3);
      time += 1000;
      m4.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, time);
      producer.send(m4);
      time += 1000;
      m5.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, time);
      producer.send(m5);
      time -= 4000;
      if (recover) {
         producer.close();
         session.close();
         server.stop();
         server = null;
         server = createServer(true, configuration);
         server.start();

         sessionFactory = createSessionFactory(locator);

         session = sessionFactory.createSession(false, true, true);
      }

      ClientConsumer consumer = session.createConsumer(atestq);

      session.start();

      ClientMessage message = consumer.receive(11000);
      Assert.assertTrue(System.currentTimeMillis() >= time);
      Assert.assertEquals("m1", message.getBodyBuffer().readString());
      message.acknowledge();
      time += 1000;
      message = consumer.receive(1250);
      Assert.assertTrue(System.currentTimeMillis() >= time);
      Assert.assertEquals("m2", message.getBodyBuffer().readString());
      message.acknowledge();
      time += 1000;
      message = consumer.receive(1250);
      Assert.assertTrue(System.currentTimeMillis() >= time);
      Assert.assertEquals("m3", message.getBodyBuffer().readString());
      message.acknowledge();
      time += 1000;
      message = consumer.receive(1250);
      Assert.assertTrue(System.currentTimeMillis() >= time);
      Assert.assertEquals("m4", message.getBodyBuffer().readString());
      message.acknowledge();
      time += 1000;
      message = consumer.receive(1250);
      Assert.assertTrue(System.currentTimeMillis() >= time);
      Assert.assertEquals("m5", message.getBodyBuffer().readString());
      message.acknowledge();

      // Make sure no more messages
      consumer.close();
      consumer = session.createConsumer(atestq);
      Assert.assertNull(consumer.receiveImmediate());

      session.close();
   }
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testProduceAndConsume() throws Throwable {
   int numberOfConsumers = 5;
   // this test assumes numberOfConsumers == numberOfProducers
   int numberOfProducers = numberOfConsumers;
   int produceMessage = 10000;
   int commitIntervalProduce = 100;
   int consumeMessage = (int) (produceMessage * 0.9);
   int commitIntervalConsume = 100;

   ClientSession session = sf.createSession(false, false);
   session.createQueue("compact", "compact-queue", true);

   ClientProducer producer = session.createProducer("compact");

   for (int i = 0; i < 100; i++) {
      producer.send(session.createMessage(true));
   }

   session.commit();

   // Number of messages expected to be received after restart
   int numberOfMessagesExpected = (produceMessage - consumeMessage) * numberOfConsumers;

   CountDownLatch latchReady = new CountDownLatch(numberOfConsumers + numberOfProducers);

   CountDownLatch latchStart = new CountDownLatch(1);

   ArrayList<BaseThread> threads = new ArrayList<>();

   ProducerThread[] prod = new ProducerThread[numberOfProducers];
   for (int i = 0; i < numberOfProducers; i++) {
      prod[i] = new ProducerThread(i, latchReady, latchStart, produceMessage, commitIntervalProduce);
      prod[i].start();
      threads.add(prod[i]);
   }

   ConsumerThread[] cons = new ConsumerThread[numberOfConsumers];

   for (int i = 0; i < numberOfConsumers; i++) {
      cons[i] = new ConsumerThread(i, latchReady, latchStart, consumeMessage, commitIntervalConsume);
      cons[i].start();
      threads.add(cons[i]);
   }

   ActiveMQTestBase.waitForLatch(latchReady);
   latchStart.countDown();

   for (BaseThread t : threads) {
      t.join();
      if (t.e != null) {
         throw t.e;
      }
   }

   server.stop();

   setupServer(JournalType.NIO);

   ClientSession sess = sf.createSession(true, true);

   ClientConsumer consumer = sess.createConsumer(QUEUE);

   sess.start();

   for (int i = 0; i < numberOfMessagesExpected; i++) {
      ClientMessage msg = consumer.receive(5000);
      Assert.assertNotNull(msg);

      if (i % 1000 == 0) {
         System.out.println("Received #" + i + "  on thread before end");
      }
      msg.acknowledge();
   }

   Assert.assertNull(consumer.receiveImmediate());

   sess.close();

}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
private void testConsumerBrowserMessagesArentAcked(final boolean preACK) throws Exception {
   ClientSessionFactory sf = createSessionFactory(locator);

   ClientSession session = sf.createSession(null, null, false, true, true, preACK, 0);

   session.createQueue(QUEUE, QUEUE, null, false);

   ClientProducer producer = session.createProducer(QUEUE);

   final int numMessages = 100;

   for (int i = 0; i < numMessages; i++) {
      ClientMessage message = createTextMessage(session, "m" + i);
      producer.send(message);
   }

   ClientConsumer consumer = session.createConsumer(QUEUE, null, true);

   for (int i = 0; i < numMessages; i++) {
      ClientMessage message2 = consumer.receive(1000);

      Assert.assertEquals("m" + i, message2.getBodyBuffer().readString());
   }
   // assert that all the messages are there and none have been acked
   Assert.assertEquals(0, ((Queue) server.getPostOffice().getBinding(QUEUE).getBindable()).getDeliveringCount());
   Assert.assertEquals(100, getMessageCount(((Queue) server.getPostOffice().getBinding(QUEUE).getBindable())));

   session.close();

}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void scaleDownDelay() throws Exception {
   createSessionFactory();

   ClientSession session = createSession(sf, true, true);

   session.createQueue(ADDRESS, ADDRESS, null, true);

   ClientProducer producer = session.createProducer(ADDRESS);

   //send enough messages to ensure that when the client fails over scaledown hasn't complete
   sendMessages(session, producer, 1000);

   crash(session);

   ClientConsumer consumer = session.createConsumer(ADDRESS);

   session.start();

   receiveDurableMessages(consumer);

   session.close();

   sf.close();

   Assert.assertEquals(0, sf.numSessions());

   Assert.assertEquals(0, sf.numConnections());
}