2Paths Team Blog

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.ServletException;

import org.acegisecurity.Authentication;
import org.acegisecurity.context.SecurityContextHolder;
import org.acegisecurity.ui.webapp.AuthenticationProcessingFilter;
import org.springframework.mock.web.MockFilterChain;
import org.springframework.mock.web.MockFilterConfig;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.mock.web.MockServletContext;
import
  org.springframework.test.AbstractTransactionalDataSourceSpringContextTests;
import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.ContextLoaderListener;

public class AcegiSecurityTest
  extends AbstractTransactionalDataSourceSpringContextTests {

  private static final String SECURITY_CONTEXT_CLASSPATH =
    "classpath:/com/twopaths/test/core/security-context.xml";

  private static final String TEST_USERNAME = "test";
  private static final String TEST_PASSWORD = "test";

  private MockServletContext servletContext;
  private MockFilterConfig mockConfig;
  private FilterChain mockFilterChain;
  private Filter authenticationFilter;

  @Override
  protected String[] getConfigLocations() {
    return new String[] {SECURITY_CONTEXT_CLASSPATH};
  }

  @Override
  protected void onSetUpInTransaction() throws Exception {
    // Insert user dummy data
    jdbcTemplate.execute("insert into end_user values(1, 'ROLE_USR', '" +
      TEST_USERNAME + "', '" +
      TEST_PASSWORD + "', 'true')");
  }

  @Override
  protected void onSetUpBeforeTransaction() throws Exception {
    // Init servlet context mock
    servletContext = new MockServletContext("");
    servletContext.addInitParameter(
      ContextLoader.CONFIG_LOCATION_PARAM,
      SECURITY_CONTEXT_CLASSPATH);

    // Init servlet context listener
    ServletContextListener contextListener = new ContextLoaderListener();
    ServletContextEvent event = new ServletContextEvent(servletContext);
    contextListener.contextInitialized(event);

    // Init filter config and filter chain mocks
    mockConfig = new MockFilterConfig(servletContext);
    mockFilterChain = new MockFilterChain();

    // Init authentication filter
    authenticationFilter = (Filter)
      this.getApplicationContext().getBean("authenticationProcessingFilter");
    authenticationFilter.init(mockConfig);
  }

  public void testThatTestUserLogsInOk() throws Exception {
    // Build mock request
    MockHttpServletRequest request =
      new MockHttpServletRequest("POST", "/j_acegi_security_check");
    request.setParameter(
      AuthenticationProcessingFilter.ACEGI_SECURITY_FORM_USERNAME_KEY,
      TEST_USERNAME);
    request.setParameter(
      AuthenticationProcessingFilter.ACEGI_SECURITY_FORM_PASSWORD_KEY,
      TEST_PASSWORD);

    // Build mock response
    MockHttpServletResponse response = new MockHttpServletResponse();

    // Run authentication filter
    authenticationFilter.doFilter(request, response, mockFilterChain);

    // Get authentication instance
    Authentication authentication =
      SecurityContextHolder.getContext().getAuthentication();

    // Verify authentication instance
    assertNotNull(authentication);
    assertEquals(TEST_USERNAME, authentication.getName());

    // Verify response redirected URL
    assertEquals("/home", response.getRedirectedUrl());
  }

import static java.util.concurrent.TimeUnit.*;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class AsynchronousProcessor<T>
    implements Runnable, ApplicationContextAware {

  protected final Log logger = LogFactory.getLog(this.getClass());

  protected static boolean started = false;

  private ScheduledFuture handle;

  // Specifies which bean in spring to instantiate as a new job
  // Default is job
  private String jobBean = "job";

  // Specified initial delay before kicking off the first job
  // Default is 1 second
  private int initialDelay = 1;

  // Specifies the delay between finishing and starting a new job
  // Default is 10 seconds
  private int delay = 10;

  // Specifies how long to wait for a job to complete before timing out
  // Default is 60 seconds
  private int timeout = 60;

  // Specifies how long job will keep running
  // Default is 1 hour. Set to zero to run forever.
  private int duration = 60 * 60;

  protected final ScheduledExecutorService scheduler =
      Executors.newScheduledThreadPool(1);
  protected final ExecutorService THREADPOOL =
      Executors.newCachedThreadPool();

  private ApplicationContext applicationContext;

  public void setApplicationContext(ApplicationContext applicationContext)
      throws BeansException {
    this.applicationContext = applicationContext;
  }

  public AsynchronousProcessor() {
    this.start();
  }

  protected synchronized void start() {
    if (!this.started) { // Ensures that it only starts up once
      this.started = true;
      final ScheduledFuture handle =
        scheduler.scheduleWithFixedDelay(this, this.getInitialDelay(),
        this.getDelay(), SECONDS);
      if (this.getDuration() > 0) {
        scheduler.schedule(new Runnable() {
          public void run() {handle.cancel(true);}
        }, this.getDuration(), SECONDS);
      }
      this.setHandle(handle);
    }
  }

  public void run() {
    try {
      Callable<T> job =
        (Callable<T>) applicationContext.getBean(this.getJobBean());
      T result = this.call(job, this.getTimeout());
      this.logger.info(result);
    } catch (Exception e) {
      this.logger.error("Exception occured when running job", e);
    }
  }

  protected <T> T call(Callable<T> c, long timeout)
      throws InterruptedException, ExecutionException, TimeoutException {
    FutureTask<T> t = new FutureTask<T>(c);
    THREADPOOL.execute(t);
    T result = t.get(timeout, SECONDS);
    return result;
  }

  public void destroy() {
    if ((this.getHandle() != null) && (!this.getHandle().isCancelled())) {
      this.getHandle().cancel(true);
    }
  }

  public String getJobBean() {
    return jobBean;
  }
  public void setJobBean(String jobBean) {
    this.jobBean = jobBean;
  }

  public ScheduledFuture getHandle() {
    return handle;
  }
  protected void setHandle(ScheduledFuture handle) {
    this.handle = handle;
  }

  public int getDelay() {
    return delay;
  }
  public void setDelay(int delay) {
    this.delay = delay;
  }

  public int getInitialDelay() {
    return initialDelay;
  }
  public void setInitialDelay(int initialDelay) {
    this.initialDelay = initialDelay;
  }

  public int getTimeout() {
    return timeout;
  }
  public void setTimeout(int timeout) {
    this.timeout = timeout;
  }

  public int getDuration() {
    return duration;
  }
  public void setDuration(int duration) {
    this.duration = duration;
  }

import java.util.concurrent.Callable;

public class HelloWorldJob<T> implements Callable<T> {

  private String message = "Hello World"; // default

  public String getMessage() {
    return message;
  }
  public void setMessage(String message) {
    this.message = message;
  }

  public T call() {
    return (T) message;
  }

@Id
@GeneratedValue
private Long id;
private Publisher publisher;

public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}