コード例 #1
0
 @Override
 public void configure(AtmosphereConfig config) {
   String s = config.getInitParameter(ApplicationConfig.MESSAGE_DELIMITER);
   if (s != null) {
     wsDelimiter = s;
   }
 }
コード例 #2
0
  @Override
  public void configure(AtmosphereConfig config) {
    try {

      String s = config.getInitParameter(ATMOSPHERE_SPRING_EXCLUDE_CLASSES);
      if (s != null) {
        String[] list = s.split(",");
        for (String clazz : list) {
          excludedFromInjection.add(IOUtils.loadClass(getClass(), clazz));
        }

        if (list.length > 0) {
          preventSpringInjection = true;
        }
      }

      context = new AnnotationConfigApplicationContext();
      context.setParent(
          WebApplicationContextUtils.getWebApplicationContext(
              config.framework().getServletContext()));

      context.refresh();

      // Hack to make it injectable
      context.register(AtmosphereConfig.class);
      ((AtmosphereConfig)
              context.getBean(AtmosphereConfig.class.getCanonicalName(), config.framework()))
          .populate(config);
    } catch (Exception ex) {
      logger.warn("Unable to configure injection", ex);
    }
  }
コード例 #3
0
  protected Broadcaster getBroadcaster(boolean autoCreate) {
    if (broadcaster == null) {
      throw new IllegalStateException("No Broadcaster associated with this AtmosphereResource.");
    }

    String s = config.getInitParameter(ApplicationConfig.RECOVER_DEAD_BROADCASTER);
    if (s != null) {
      autoCreate = Boolean.parseBoolean(s);
    }

    if (autoCreate && broadcaster.isDestroyed() && config.getBroadcasterFactory() != null) {
      logger.debug(
          "Broadcaster {} has been destroyed and cannot be re-used. Recreating a new one with the same name. You can turn off this"
              + " mechanism by adding, in web.xml, {} set to false",
          broadcaster.getID(),
          ApplicationConfig.RECOVER_DEAD_BROADCASTER);

      Broadcaster.SCOPE scope = broadcaster.getScope();
      synchronized (this) {
        String id =
            scope != Broadcaster.SCOPE.REQUEST
                ? broadcaster.getID()
                : broadcaster.getID() + ".recovered" + UUID.randomUUID();

        // Another Thread may have added the Broadcaster.
        broadcaster = config.getBroadcasterFactory().lookup(id, true);
        broadcaster.setScope(scope);
        broadcaster.addAtmosphereResource(this);
      }
    }
    return broadcaster;
  }
コード例 #4
0
 private static void keepAliveThreads(ThreadPoolExecutor e, AtmosphereConfig config) {
   int keepAlive = DEFAULT_KEEP_ALIVE;
   String s = config.getInitParameter(ApplicationConfig.EXECUTORFACTORY_KEEP_ALIVE);
   if (s != null) {
     keepAlive = Integer.parseInt(s);
   }
   e.setKeepAliveTime(keepAlive, TimeUnit.SECONDS);
 }
コード例 #5
0
 public JBossWebCometSupport(AtmosphereConfig config) {
   super(config);
   Object b = config.getInitParameter(ApplicationConfig.TOMCAT_CLOSE_STREAM);
   closeConnectionOnInputStream = b == null ? true : Boolean.parseBoolean(b.toString());
   try {
     Class.forName(HttpEvent.class.getName());
   } catch (Throwable e) {
     throw new IllegalStateException(unableToDetectComet());
   }
 }
コード例 #6
0
    /**
     * Checks in the {@link AtmosphereConfig} if the {@link #propertyName} is defined as an
     * init-param and instantiate the appropriate class.
     *
     * <p>If instantiation fails, the exception is logged and {@code null} is returned.
     *
     * @param desiredType the type to be returned
     * @param config the configuration that provides parameters
     * @param <T> the generic for modular call
     * @return the instance of the expected class, {@code null} if an error occurs
     */
    public <T> T retrieve(final Class<T> desiredType, final AtmosphereConfig config) {
      final String initParameter = config.getInitParameter(this.propertyName);
      final String className = (initParameter != null) ? initParameter : defaultClass;

      try {
        final AtmosphereFramework fwk = config.framework();
        final Object retval =
            fwk.newClassInstance(
                desiredType, desiredType.getClass().cast(Class.forName(className)));
        return desiredType.cast(retval);
      } catch (Exception e) {
        logger.error("Unable to initialize {}", getClass().getName(), e);
        return null;
      }
    }
コード例 #7
0
  @Override
  public void init(ServletConfig sc) throws ServletException {

    String maxInactive =
        sc.getInitParameter(MAX_INACTIVE) != null
            ? sc.getInitParameter(MAX_INACTIVE)
            : config.getInitParameter(MAX_INACTIVE);

    if (maxInactive != null) {
      trackActiveRequest = true;
      final long maxInactiveTime = Long.parseLong(maxInactive);
      if (maxInactiveTime <= 0) return;

      closedDetector.scheduleAtFixedRate(
          new Runnable() {
            public void run() {
              for (AtmosphereRequest req : aliveRequests.keySet()) {
                long l = (Long) req.getAttribute(MAX_INACTIVE);
                if (l > 0 && System.currentTimeMillis() - l > maxInactiveTime) {
                  try {
                    logger.debug(
                        "Close detector disconnecting {}. Current size {}",
                        req,
                        aliveRequests.size());
                    AtmosphereResourceImpl r = (AtmosphereResourceImpl) aliveRequests.remove(req);
                    cancelled(req, r.getResponse(false));
                  } catch (Throwable e) {
                    logger.warn("closedDetector", e);
                  } finally {
                    try {
                      req.setAttribute(MAX_INACTIVE, (long) -1);
                    } catch (Throwable t) {
                      logger.trace("closedDetector", t);
                    }
                  }
                }
              }
            }
          },
          0,
          1,
          TimeUnit.SECONDS);
    }
  }
コード例 #8
0
  public void configure(AtmosphereConfig config) {
    this.config = config;

    String maxInactive = config.getInitParameter(MAX_INACTIVE);
    if (maxInactive != null) {
      maxInactiveTime = Long.parseLong(maxInactive);
    }

    if (maxInactiveTime > 0) {
      ExecutorsFactory.getScheduler(config)
          .scheduleAtFixedRate(
              new Runnable() {
                public void run() {
                  idleResources();
                }
              },
              0,
              2,
              TimeUnit.SECONDS);
    }
  }
コード例 #9
0
 public Tomcat7CometSupport(AtmosphereConfig config) {
   super(config);
   Object b = config.getInitParameter(ApplicationConfig.TOMCAT_CLOSE_STREAM);
   closeConnectionOnInputStream = b == null ? true : Boolean.parseBoolean(b.toString());
 }
コード例 #10
0
  /**
   * Create an {@link ExecutorService} to be used for dispatching messages, not I/O events.
   *
   * @param config the {@link AtmosphereConfig}
   * @param name a name to use if shared is false.
   * @return {@link ExecutorService}
   */
  public static ExecutorService getMessageDispatcher(
      final AtmosphereConfig config, final String name) {
    final boolean shared = config.framework().isShareExecutorServices();

    boolean isExecutorShared = shared ? true : false;
    if (!shared || config.properties().get("executorService") == null) {
      int numberOfMessageProcessingThread = DEFAULT_MESSAGE_THREAD;
      String s =
          config.getInitParameter(
              ApplicationConfig.BROADCASTER_MESSAGE_PROCESSING_THREADPOOL_MAXSIZE);
      if (s != null) {
        numberOfMessageProcessingThread = Integer.parseInt(s);
      }

      if (isExecutorShared && numberOfMessageProcessingThread == 1) {
        logger.warn(
            "Not enough numberOfMessageProcessingThread for a shareable thread pool {}, "
                + "Setting it to a newCachedThreadPool",
            numberOfMessageProcessingThread);
        numberOfMessageProcessingThread = -1;
      }

      ThreadPoolExecutor messageService;
      if (numberOfMessageProcessingThread == -1) {
        messageService =
            (ThreadPoolExecutor)
                Executors.newCachedThreadPool(
                    new ThreadFactory() {

                      private final AtomicInteger count = new AtomicInteger();

                      @Override
                      public Thread newThread(final Runnable runnable) {
                        Thread t =
                            new Thread(
                                runnable,
                                (shared ? "Atmosphere-Shared" : name)
                                    + "-DispatchOp-"
                                    + count.getAndIncrement());
                        t.setDaemon(true);
                        return t;
                      }
                    });
      } else {
        messageService =
            (ThreadPoolExecutor)
                Executors.newFixedThreadPool(
                    numberOfMessageProcessingThread,
                    new ThreadFactory() {

                      private final AtomicInteger count = new AtomicInteger();

                      @Override
                      public Thread newThread(final Runnable runnable) {
                        Thread t =
                            new Thread(
                                runnable,
                                (shared ? "Atmosphere-Shared" : name)
                                    + "-DispatchOp-"
                                    + count.getAndIncrement());
                        t.setDaemon(true);
                        return t;
                      }
                    });
      }

      keepAliveThreads(messageService, config);

      if (shared) {
        config.properties().put("executorService", messageService);
      }
      return messageService;
    } else {
      return (ExecutorService) config.properties().get("executorService");
    }
  }