org.osgi.service.http.HttpContext Java Examples

@Test
public void testStart_dmFound() throws Exception {

	// Mock
	Bundle b = Mockito.mock( Bundle.class );
	Mockito.when( b.getSymbolicName()).thenReturn( "net.roboconf.dm" );

	this.factory.httpService = Mockito.mock( HttpService.class );
	this.factory.bundleContext = Mockito.mock( BundleContext.class );
	Mockito.when( this.factory.bundleContext.getBundles()).thenReturn( new Bundle[] { b });

	// Start
	this.factory.start();

	// Check
	Mockito.verify( this.factory.httpService, Mockito.times( 1 )).registerServlet(
			Mockito.eq( HttpConstants.DM_SOCKET_PATH ),
			Mockito.any( Servlet.class ),
			Mockito.any( Dictionary.class ),
			Mockito.isNull( HttpContext.class ));
}
 

public void registerServlet(String context, Servlet servlet, Dictionary dictionary, HttpContext httpContext) throws ServletException, NamespaceException {

        ContextHandlerCollection contexts = new ContextHandlerCollection();
        server.setHandler(contexts);
        ServletContextHandler root = new ServletContextHandler(contexts, "/",
                ServletContextHandler.SESSIONS);
        ServletHolder servletHolder = new ServletHolder(servlet);
        root.addServlet(servletHolder, context);

        if (!server.getServer().getState().equals(server.STARTED)) {
            try {
                server.start();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }
 

public synchronized ServletContext getServletContext(final HttpContext httpContext,
                                                     String realPath)
{

  if (realPath == null) {
    realPath = "";
  }

  final ContextKey key = new ContextKey(httpContext, realPath);
  ServletContextImpl context = contextMap.get(key);
  if (context == null) {
    context =
      new ServletContextImpl(httpContext, realPath, httpConfig, log,
                             registrations);
    keyMap.put(context, key);
    contextMap.put(key, context);
  } else {
    keyMap.get(context).referenceCount++;
  }

  return context;
}
 

public boolean addConstraintMapping(HttpContext httpContext, WebContainer service, Object cm) {
    if (cm instanceof ConstraintMapping) {
        ConstraintMapping constraintMapping = (ConstraintMapping) cm;
        Constraint constraint = constraintMapping.getConstraint();
        String[] roles = constraint.getRoles();
        // name property is unavailable on constraint object :/

        String name = "Constraint-" + new SecureRandom().nextInt(Integer.MAX_VALUE);

        int dataConstraint = constraint.getDataConstraint();
        String dataConstraintStr;
        switch (dataConstraint) {
            case Constraint.DC_UNSET:
                dataConstraintStr = null;
                break;
            case Constraint.DC_NONE:
                dataConstraintStr = "NONE";
                break;
            case Constraint.DC_CONFIDENTIAL:
                dataConstraintStr = "CONFIDENTIAL";
                break;
            case Constraint.DC_INTEGRAL:
                dataConstraintStr = "INTEGRAL";
                break;
            default:
                log.warnv("Unknown data constraint: " + dataConstraint);
                dataConstraintStr = "CONFIDENTIAL";
        }
        List<String> rolesList = Arrays.asList(roles);

        log.debug("Adding security constraint name=" + name + ", url=" + constraintMapping.getPathSpec() + ", dataConstraint=" + dataConstraintStr + ", canAuthenticate="
                + constraint.getAuthenticate() + ", roles=" + rolesList);
        service.registerConstraintMapping(name, constraintMapping.getPathSpec(), null, dataConstraintStr, constraint.getAuthenticate(), rolesList, httpContext);
        return true;
    }
    return false;
}
 

@Test
public void httpContextShouldCallgetResourceOnBundle() {
    HttpContext context = httpContextFactoryService.createDefaultHttpContext(bundle);
    context.getResource(RESOURCE);

    verify(httpContext).wrap(bundle);
    verify(bundle).getResource(RESOURCE);
}
 

@Test
public void shouldCreateHttpContext() {
    HttpContext context = httpContextFactoryService.createDefaultHttpContext(bundle);
    assertThat(context, is(notNullValue()));

    verify(httpContext).wrap(bundle);
}
 

@Test
public void httpContextShouldCallgetResourceOnBundleWithoutLeadingSlash() {
    HttpContext context = httpContextFactoryService.createDefaultHttpContext(bundle);
    context.getResource("/" + RESOURCE);

    verify(httpContext).wrap(bundle);
    verify(bundle).getResource(RESOURCE);
}
 

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
	HttpServletRequest httpRequest = (HttpServletRequest) request;
	HttpServletResponse httpResponse = (HttpServletResponse) response;

	if (httpRequest.getRemoteUser() != null) {
		chain.doFilter(request, response);
		return;
	}

	String login;
	if (redirect) {
		login = authenticationService.authenticateUser(httpRequest, httpResponse);
		if (login == null) {
			return;
		}
	} else {
		login = authenticationService.getAuthenticatedUser(httpRequest, httpResponse);
		if (login == null) {
			chain.doFilter(request, response);
			return;
		}
	}

	request.setAttribute(HttpContext.REMOTE_USER, login);
	request.setAttribute(HttpContext.AUTHENTICATION_TYPE, authenticationService.getAuthType());
	chain.doFilter(request, response);
}
 

@Override
public String getAuthType()
{
  final Object o = getAttribute(HttpContext.AUTHENTICATION_TYPE);
  if (o instanceof String) {
    return (String) o;
  }
  return null;
}
 

ServletContextImpl(final HttpContext httpContext, final String realPath,
                   final HttpConfig httpConfig, final LogRef log,
                   final Registrations registrations)
{

  this.httpContext = httpContext;
  this.realPath = realPath;
  this.httpConfig = httpConfig;
  this.log = log;
  this.registrations = registrations;
}
 

@Override
public String getRemoteUser()
{
  final Object o = getAttribute(HttpContext.REMOTE_USER);
  if (o instanceof String) {
    return (String) o;
  }
  return null;
}
 

public ResourceRegistration(final String alias, final String realPath,
                            final HttpContext httpContext,
                            final ServletContextManager contextManager,
                            long newDate)
{
  this.alias = alias;
  this.httpContext = httpContext;
  this.contextManager = contextManager;
  // HACK CSM
  lastModificationDate = newDate;

  context = contextManager.getServletContext(httpContext, realPath);
  config = new ServletConfigImpl(new Hashtable<String, String>(), context);
}
 

/**
 * HACK CSM
 */
RequestDispatcherImpl(final String servletPath, final Servlet servlet,
                      final HttpContext httpContext,
                      final ServletConfig config, long newDate, URL resourceURL)
{
  this.servletPath = servletPath;
  this.servlet = servlet;
  this.httpContext = httpContext;
  this.config = config;
  lastModificationDate = newDate;
  this.resourceURL = resourceURL;
}
 

public void registerResources(String alias,
                              String realPath,
                              HttpContext httpContext)
    throws NamespaceException
{
  if (closed) {
    throw new IllegalStateException("Service has been unget");
  }

  if (realPath.length() > 0 && realPath.charAt(realPath.length() - 1) == '/') {
    throw new IllegalArgumentException(
                                       "The name parameter must not end with slash: "
                                           + realPath);
  }

  if (httpContext == null) {
    if (defaultBundleContext == null) {
      defaultBundleContext = createDefaultHttpContext();
    }
    httpContext = defaultBundleContext;
  }

  // HACK CSM now caching "last updated" time
  register(alias,
           new ResourceRegistration(alias, realPath, httpContext,
                                    contextManager, System
                                        .currentTimeMillis()));
}
 

public ServletRegistration(final String alias, final Servlet servlet,
                           Dictionary<String, String> parameters,
                           final HttpContext httpContext,
                           final ServletContextManager contextManager,
                           final Registrations registrations)
  throws ServletException
{
  if (parameters == null) {
    parameters = new Hashtable<String, String>();
  }

  if (parameters.get(HttpUtil.SERVLET_NAME_KEY) == null) {
    parameters.put(HttpUtil.SERVLET_NAME_KEY, servlet.getClass().getName());
  }

  this.contextManager = contextManager;
  this.registrations = registrations;

  // Fail fast if servlet already registered!
  registrations.addServlet(servlet);

  final ServletContext context =
    contextManager.getServletContext(httpContext, null);
  final ServletConfig config = new ServletConfigImpl(parameters, context);
  servlet.init(config);

  dispatcher =
    new RequestDispatcherImpl(alias, servlet, httpContext,
                              lastModificationDate);
}
 

public JspBundle ( final Bundle bundle, final HttpService service, final HttpContext context ) throws ServletException, NamespaceException
{
    this.service = service;

    this.alias = String.format ( "/bundle/%s/WEB-INF", bundle.getBundleId () );
    this.servlet = new JspServlet ( bundle, "/WEB-INF", this.alias );

    logger.info ( "Registering JSP servlet - resources: /WEB-INF, alias: {}, bundle: {}", this.alias, bundle.getSymbolicName () );

    final Dictionary<String, String> initparams = new Hashtable<> ( 2 );
    initparams.put ( "compilerSourceVM", "1.8" );
    initparams.put ( "compilerTargetVM", "1.8" );

    this.service.registerServlet ( this.alias, this.servlet, initparams, context );
}
 

@Override
protected Map<String, Object> exportRemoteService(RSARemoteServiceRegistration reg) {
	// Create Servlet
	Servlet servlet = createServlet(reg);
	if (servlet == null)
		throw new NullPointerException(
				"Servlet is null.  It cannot be null to export Jax RS servlet.   See subclass implementation of JaxRSServerContainer.createServlet()");
	// Create servletProps
	@SuppressWarnings("rawtypes")
	Dictionary servletProperties = createServletProperties(reg);
	// Create HttpContext
	HttpContext servletContext = createServletContext(reg);
	// Get servlet alias
	String servletAlias = getServletAlias(reg);
	// Get HttpService instance
	HttpService httpService = getHttpService();
	if (httpService == null)
		throw new NullPointerException("HttpService cannot cannot be null");
	synchronized (this.registrations) {
		try {
			httpService.registerServlet(servletAlias, servlet, servletProperties, servletContext);
		} catch (ServletException | NamespaceException e) {
			throw new RuntimeException("Cannot register servlet with alias=" + servletAlias, e);
		}
		this.registrations.put(servletAlias, reg);
	}
	return createExtraExportProperties(servletAlias, reg);
}
 

@Test
public void shouldCreateHttpContext() {
    HttpContext context = httpContextFactoryService.createDefaultHttpContext(bundle);
    assertThat(context, is(notNullValue()));

    verify(httpContext).wrap(bundle);
}
 

@Test
public void httpContextShouldCallgetResourceOnBundle() {
    HttpContext context = httpContextFactoryService.createDefaultHttpContext(bundle);
    context.getResource(RESOURCE);

    verify(httpContext).wrap(bundle);
    verify(bundle).getResource(RESOURCE);
}
 

@Test
public void httpContextShouldCallgetResourceOnBundleWithoutLeadingSlash() {
    HttpContext context = httpContextFactoryService.createDefaultHttpContext(bundle);
    context.getResource("/" + RESOURCE);

    verify(httpContext).wrap(bundle);
    verify(bundle).getResource(RESOURCE);
}
 

@Activate
protected void activate(Map<String, Object> configProps, BundleContext bundleContext) {
    config.applyConfig(configProps);
    HttpContext httpContext = createHttpContext(bundleContext.getBundle());

    super.activate(WEBAPP_ALIAS + "/" + SERVLET_NAME, httpContext);
    try {
        httpService.registerResources(WEBAPP_ALIAS, "web", httpContext);
    } catch (NamespaceException e) {
        logger.error("Could not register static resources under {}", WEBAPP_ALIAS, e);
    }
}
 

@Activate
protected void activate(Map<String, Object> configProps, BundleContext bundleContext) {
    HttpContext httpContext = createHttpContext(bundleContext.getBundle());
    super.activate(WEBAPP_ALIAS + "/" + SERVLET_NAME, httpContext);

    try {
        httpService.registerResources(WEBAPP_ALIAS, "web", httpContext);
    } catch (NamespaceException e) {
        logger.error("Could not register static resources under {}", WEBAPP_ALIAS, e);
    }

    config.applyConfig(configProps);
}
 

/**
 * Creates a {@link SecureHttpContext} which handles the security for this
 * servlet
 * 
 * @return a {@link SecureHttpContext}
 */
protected HttpContext createHttpContext() {
    if (httpService == null) {
        logger.warn("Cannot create HttpContext because the httpService is null");
        return null;
    } else {
        HttpContext defaultHttpContext = httpService.createDefaultHttpContext();
        return new SecureHttpContext(defaultHttpContext, "openHAB.org");
    }
}
 

@Override
public boolean addConstraintMapping(HttpContext httpContext, WebContainer service, Object cm) {
    if (cm instanceof PaxWebSecurityConstraintMapping) {
        PaxWebSecurityConstraintMapping constraintMapping = (PaxWebSecurityConstraintMapping) cm;
        String name = constraintMapping.getConstraintName();
        if (name == null) {
            name = "Constraint-" + new SecureRandom().nextInt(Integer.MAX_VALUE);
        }
        log.debug("Adding security constraint name=" + name + ", url=" + constraintMapping.getUrl() + ", dataConstraint=" + constraintMapping.getDataConstraint() + ", canAuthenticate="
                + constraintMapping.isAuthentication() + ", roles=" + constraintMapping.getRoles());
        service.registerConstraintMapping(name, constraintMapping.getUrl(), constraintMapping.getMapping(), constraintMapping.getDataConstraint(), constraintMapping.isAuthentication(), constraintMapping.getRoles(), httpContext);
        return true;
    }
    return false;
}
 

@Override
public boolean addConstraintMapping(HttpContext httpContext, WebContainer service, Object cm) {
    if (cm instanceof ConstraintMapping) {
        ConstraintMapping constraintMapping = (ConstraintMapping) cm;
        Constraint constraint = constraintMapping.getConstraint();
        String[] roles = constraint.getRoles();
        // name property is unavailable on constraint object :/

        String name = "Constraint-" + new SecureRandom().nextInt(Integer.MAX_VALUE);

        int dataConstraint = constraint.getDataConstraint();
        String dataConstraintStr;
        switch (dataConstraint) {
            case Constraint.DC_UNSET:
                dataConstraintStr = null;
                break;
            case Constraint.DC_NONE:
                dataConstraintStr = "NONE";
                break;
            case Constraint.DC_CONFIDENTIAL:
                dataConstraintStr = "CONFIDENTIAL";
                break;
            case Constraint.DC_INTEGRAL:
                dataConstraintStr = "INTEGRAL";
                break;
            default:
                log.warnv("Unknown data constraint: " + dataConstraint);
                dataConstraintStr = "CONFIDENTIAL";
        }
        List<String> rolesList = Arrays.asList(roles);

        log.debug("Adding security constraint name=" + name + ", url=" + constraintMapping.getPathSpec() + ", dataConstraint=" + dataConstraintStr + ", canAuthenticate="
                + constraint.getAuthenticate() + ", roles=" + rolesList);
        service.registerConstraintMapping(name, constraintMapping.getPathSpec(), null, dataConstraintStr, constraint.getAuthenticate(), rolesList, httpContext);
        return true;
    }
    return false;
}
 

public boolean addConstraintMapping(HttpContext httpContext, WebContainer service, Object cm) {
    if (cm instanceof SecurityConstraintMappingModel) {
        SecurityConstraintMappingModel constraintMapping = (SecurityConstraintMappingModel) cm;
        String name = constraintMapping.getConstraintName();
        if (name == null) {
            name = "Constraint-" + new SecureRandom().nextInt(Integer.MAX_VALUE);
        }
        log.debug("Adding security constraint name=" + name + ", url=" + constraintMapping.getUrl() + ", dataConstraint=" + constraintMapping.getDataConstraint() + ", canAuthenticate="
                + constraintMapping.isAuthentication() + ", roles=" + constraintMapping.getRoles());
        service.registerConstraintMapping(name, constraintMapping.getUrl(), constraintMapping.getMapping(), constraintMapping.getDataConstraint(), constraintMapping.isAuthentication(), constraintMapping.getRoles(), httpContext);
        return true;
    }
    return false;
}
 

@Activate
protected void activate(Map<String, Object> configProps, BundleContext context) {
    try {
        Object useGzipCompression = configProps.get("useGzipCompression");
        HttpContext httpContext = new HABotHttpContext(httpService.createDefaultHttpContext(), RESOURCES_BASE,
                (useGzipCompression != null && Boolean.parseBoolean(useGzipCompression.toString())));

        httpService.registerResources(HABOT_ALIAS, RESOURCES_BASE, httpContext);
        logger.info("Started HABot at " + HABOT_ALIAS);
    } catch (NamespaceException e) {
        logger.error("Error during HABot startup: {}", e.getMessage());
    }
}
 

@Override
public void registerResources( String alias, String name, HttpContext context ) throws NamespaceException {
	// nothing
}
 

@Override
@SuppressWarnings( "rawtypes" )
public void registerServlet( String alias, Servlet servlet, Dictionary initparams, HttpContext context )
throws ServletException, NamespaceException {
	this.pathToServlet.put( alias, servlet );
}
 

@Override
public HttpContext createDefaultHttpContext() {
	return null;
}