import org.glassfish.jersey.internal.PropertiesDelegate; //导入依赖的package包/类
/**
 * Demonstrates that when the {@link FedoraBaseResource#JMS_BASEURL_PROP fcrepo.jms.baseUrl} system property is not
 * set, the url used for JMS messages is the same as the base url found in the {@code UriInfo}.
 * <p>
 * Implementation note: this test requires a concrete instance of {@link UriInfo}, because it is the interaction of
 * {@code javax.ws.rs.core.UriBuilder} and {@code FedoraBaseResource} that is being tested.
 * </p>
 */
@Test
public void testJmsBaseUrlDefault() {
    // Obtain a concrete instance of UriInfo
    final URI baseUri = create("http://localhost/fcrepo");
    final URI requestUri = create("http://localhost/fcrepo/foo");
    final ContainerRequest req = new ContainerRequest(baseUri, requestUri, "GET", mock(SecurityContext.class),
            mock(PropertiesDelegate.class));
    final UriInfo info = spy(req.getUriInfo());

    final String expectedBaseUrl = baseUri.toString();

    testObj.setUpJMSInfo(info, mockHeaders);

    verify(mockFedoraSession).addSessionData(BASE_URL, expectedBaseUrl);
    verify(info, times(0)).getBaseUriBuilder();
    verify(info).getBaseUri();
}
 

import org.glassfish.jersey.internal.PropertiesDelegate; //导入依赖的package包/类
/**
 * Demonstrates that the host supplied by the {@link FedoraBaseResource#JMS_BASEURL_PROP fcrepo.jms.baseUrl} system
 * property is used as the as the base url for JMS messages, and not the base url found in {@code UriInfo}.
 * <p>
 * Note: the path from the request is preserved, the host from the fcrepo.jms.baseUrl is used
 * </p>
 * <p>
 * Implementation note: this test requires a concrete instance of {@link UriInfo}, because it is the interaction of
 * {@code javax.ws.rs.core.UriBuilder} and {@code FedoraBaseResource} that is being tested.
 * </p>
 */
@Test
public void testJmsBaseUrlOverrideHost() {
    // Obtain a concrete implementation of UriInfo
    final URI baseUri = create("http://localhost/fcrepo");
    final URI requestUri = create("http://localhost/fcrepo/foo");
    final ContainerRequest req = new ContainerRequest(baseUri, requestUri, "GET", mock(SecurityContext.class),
            mock(PropertiesDelegate.class));
    final UriInfo info = spy(req.getUriInfo());

    final String baseUrl = "http://example.org";
    final String expectedBaseUrl = baseUrl + baseUri.getPath();
    System.setProperty(JMS_BASEURL_PROP, baseUrl);

    testObj.setUpJMSInfo(info, mockHeaders);

    verify(mockFedoraSession).addSessionData(BASE_URL, expectedBaseUrl);
    verify(info).getBaseUriBuilder();
    System.clearProperty(JMS_BASEURL_PROP);
}
 

import org.glassfish.jersey.internal.PropertiesDelegate; //导入依赖的package包/类
/**
 * Demonstrates that the host and port supplied by the {@link FedoraBaseResource#JMS_BASEURL_PROP
 * fcrepo.jms.baseUrl} system property is used as the as the base url for JMS messages, and not the base url found
 * in {@code UriInfo}.
 * <p>
 * Note: the path from the request is preserved, but the host and port from the request is overridden by the values
 * from fcrepo.jms.baseUrl
 * </p>
 * <p>
 * Implementation note: this test requires a concrete instance of {@link UriInfo}, because it is the interaction of
 * {@code javax.ws.rs.core.UriBuilder} and {@code FedoraBaseResource} that is being tested.
 * </p>
 */
@Test
public void testJmsBaseUrlOverrideHostAndPort() {
    // Obtain a concrete implementation of UriInfo
    final URI baseUri = create("http://localhost/fcrepo");
    final URI requestUri = create("http://localhost/fcrepo/foo");
    final ContainerRequest req = new ContainerRequest(baseUri, requestUri, "GET", mock(SecurityContext.class),
            mock(PropertiesDelegate.class));
    final UriInfo info = spy(req.getUriInfo());

    final String baseUrl = "http://example.org:9090";
    final String expectedBaseUrl = baseUrl + baseUri.getPath();
    System.setProperty(JMS_BASEURL_PROP, baseUrl);

    testObj.setUpJMSInfo(info, mockHeaders);

    verify(mockFedoraSession).addSessionData(BASE_URL, expectedBaseUrl);
    verify(info).getBaseUriBuilder();
    System.clearProperty(JMS_BASEURL_PROP);
}
 

import org.glassfish.jersey.internal.PropertiesDelegate; //导入依赖的package包/类
/**
 * Demonstrates that the url supplied by the {@link FedoraBaseResource#JMS_BASEURL_PROP fcrepo.jms.baseUrl} system
 * property is used as the as the base url for JMS messages, and not the base url found in {@code UriInfo}.
 * <p>
 * Note: the host and path from the request is overridden by the values from fcrepo.jms.baseUrl
 * </p>
 * <p>
 * Implementation note: this test requires a concrete instance of {@link UriInfo}, because it is the interaction of
 * {@code javax.ws.rs.core.UriBuilder} and {@code FedoraBaseResource} that is being tested.
 * </p>
 */
@Test
public void testJmsBaseUrlOverrideUrl() {
    // Obtain a concrete implementation of UriInfo
    final URI baseUri = create("http://localhost/fcrepo");
    final URI requestUri = create("http://localhost/fcrepo/foo");
    final ContainerRequest req = new ContainerRequest(baseUri, requestUri, "GET", mock(SecurityContext.class),
            mock(PropertiesDelegate.class));
    final UriInfo info = spy(req.getUriInfo());

    final String expectedBaseUrl = "http://example.org/fcrepo/rest";
    System.setProperty(JMS_BASEURL_PROP, expectedBaseUrl);

    testObj.setUpJMSInfo(info, mockHeaders);

    verify(mockFedoraSession).addSessionData(BASE_URL, expectedBaseUrl);
    verify(info).getBaseUriBuilder();
    System.clearProperty(JMS_BASEURL_PROP);
}
 

import org.glassfish.jersey.internal.PropertiesDelegate; //导入依赖的package包/类
/**
 * Demonstrates that when the the base url in {@code UriInfo} contains a port number, and the base url defined by
 * {@link FedoraBaseResource#JMS_BASEURL_PROP fcrepo.jms.baseUrl} does <em>not</em> contain a port number, that the
 * base url for JMS messages does not contain a port number.
 * <p>
 * Note: the host, port, and path from the request is overridden by values from fcrepo.jms.baseUrl
 * </p>
 * <p>
 * Implementation note: this test requires a concrete instance of {@link UriInfo}, because it is the interaction of
 * {@code javax.ws.rs.core.UriBuilder} and {@code FedoraBaseResource} that is being tested.
 * </p>
 */
@Test
public void testJmsBaseUrlOverrideRequestUrlWithPort8080() {
    // Obtain a concrete implementation of UriInfo
    final URI baseUri = create("http://localhost:8080/fcrepo/rest");
    final URI reqUri = create("http://localhost:8080/fcrepo/rest/foo");
    final ContainerRequest req = new ContainerRequest(baseUri, reqUri, "GET", mock(SecurityContext.class),
            mock(PropertiesDelegate.class));
    final UriInfo info = spy(req.getUriInfo());

    final String expectedBaseUrl = "http://example.org/fcrepo/rest/";
    System.setProperty(JMS_BASEURL_PROP, expectedBaseUrl);

    testObj.setUpJMSInfo(info, mockHeaders);

    verify(mockFedoraSession).addSessionData(BASE_URL, expectedBaseUrl);
    verify(info).getBaseUriBuilder();
    System.clearProperty(JMS_BASEURL_PROP);
}
 

import org.glassfish.jersey.internal.PropertiesDelegate; //导入依赖的package包/类
@Override
protected void channelRead0(ChannelHandlerContext ctx, HttpMessage msg) throws Exception {
    Writer w = new Writer(ctx);

    PropertiesDelegate properties = new MapPropertiesDelegate();
    SecurityContext securityContext = new SecurityContext() {
        @Override
        public Principal getUserPrincipal() {
            return null;
        }

        @Override
        public boolean isUserInRole(String s) {
            return false;
        }

        @Override
        public boolean isSecure() {
            return false;
        }

        @Override
        public String getAuthenticationScheme() {
            return null;
        }
    };
}
 

import org.glassfish.jersey.internal.PropertiesDelegate; //导入依赖的package包/类
private ContainerRequest createContainerRequest(URI baseUri, URI requestUri, String method, String content, Map<String, String> headers,
                                                SecurityContext securityContext, PropertiesDelegate propertiesDelegate) {
    URI uri = URI.create(baseUri.getPath() + "/");
    ContainerRequest containerRequest = new ContainerRequest(uri, requestUri, method, securityContext, propertiesDelegate);
    containerRequest.setEntityStream(new ByteArrayInputStream(content.getBytes()));
    for (Map.Entry<String, String> headerEntry : headers.entrySet()) {
        containerRequest.getHeaders().add(headerEntry.getKey(), headerEntry.getValue());
    }
    return containerRequest;
}
 

import org.glassfish.jersey.internal.PropertiesDelegate; //导入依赖的package包/类
/**
 * Reads an request object generated by an AWS_PROXY integration in API Gateway and transforms it into a Jersey
 * <code>ContainerRequest</code> object.
 *
 * @param request The incoming request object
 * @param securityContext A jax-rs SecurityContext object (@see com.amazonaws.serverless.proxy.SecurityContextWriter)
 * @param lambdaContext The AWS Lambda context for the request
 * @param config The container config object, this is passed in by the LambdaContainerHandler
 * @return A populated ContainerRequest object
 * @throws InvalidRequestEventException When the method fails to parse the incoming request
 */
@Override
public ContainerRequest readRequest(AwsProxyRequest request, SecurityContext securityContext, Context lambdaContext, ContainerConfig config)
        throws InvalidRequestEventException {
    currentRequest = request;
    currentLambdaContext = lambdaContext;

    request.setPath(stripBasePath(request.getPath(), config));

    URI basePathUri;
    URI requestPathUri;
    String basePath = "/";

    try {
        basePathUri = new URI(basePath);
    } catch (URISyntaxException e) {
        log.error("Could not read base path URI", e);
        throw new InvalidRequestEventException("Error while generating base path URI: " + basePath, e);
    }


    UriBuilder uriBuilder = UriBuilder.fromPath(request.getPath());

    if (request.getQueryStringParameters() != null) {
        for (String paramKey : request.getQueryStringParameters().keySet()) {
            uriBuilder = uriBuilder.queryParam(paramKey, request.getQueryStringParameters().get(paramKey));
        }
    }

    requestPathUri = uriBuilder.build();

    PropertiesDelegate apiGatewayProperties = new MapPropertiesDelegate();
    apiGatewayProperties.setProperty(API_GATEWAY_CONTEXT_PROPERTY, request.getRequestContext());
    apiGatewayProperties.setProperty(API_GATEWAY_STAGE_VARS_PROPERTY, request.getStageVariables());
    apiGatewayProperties.setProperty(LAMBDA_CONTEXT_PROPERTY, lambdaContext);

    ContainerRequest requestContext = new ContainerRequest(basePathUri, requestPathUri, request.getHttpMethod(), securityContext, apiGatewayProperties);

    if (request.getBody() != null) {
        if (request.isBase64Encoded()) {
            requestContext.setEntityStream(new ByteArrayInputStream(Base64.getDecoder().decode(request.getBody())));
        } else {
            requestContext.setEntityStream(new ByteArrayInputStream(request.getBody().getBytes()));
        }
    }

    if (request.getHeaders() != null) {
        for (final String headerName : request.getHeaders().keySet()) {
            requestContext.headers(headerName, request.getHeaders().get(headerName));
        }
    }

    return requestContext;
}
 

import org.glassfish.jersey.internal.PropertiesDelegate; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * <p/>
 * Transforms client-side request to server-side and invokes it on provided
 * application ({@link ApplicationHandler} instance).
 *
 * @param clientRequest
 *            client side request to be invoked.
 */
@Override
public ClientResponse apply(final ClientRequest clientRequest) {
	final PropertiesDelegate propertiesDelegate = new MapPropertiesDelegate();

	final ContainerRequest containerRequest = new ContainerRequest(this.baseUri, clientRequest.getUri(),
			clientRequest.getMethod(), null, propertiesDelegate);

	containerRequest.getHeaders().putAll(clientRequest.getStringHeaders());

	final ByteArrayOutputStream clientOutput = new ByteArrayOutputStream();
	if (clientRequest.getEntity() != null) {
		clientRequest.setStreamProvider(new OutboundMessageContext.StreamProvider() {
			@Override
			public OutputStream getOutputStream(final int contentLength) throws IOException {
				final MultivaluedMap<String, Object> clientHeaders = clientRequest.getHeaders();
				if (contentLength != -1 && !clientHeaders.containsKey(HttpHeaders.CONTENT_LENGTH)) {
					containerRequest.getHeaders().putSingle(HttpHeaders.CONTENT_LENGTH,
							String.valueOf(contentLength));
				}
				return clientOutput;
			}
		});
		clientRequest.enableBuffering();

		try {
			clientRequest.writeEntity();
		} catch (final IOException e) {
			final String msg = "Error while writing entity to the output stream.";
			CdiAwareInMemoryConnector.LOGGER.log(Level.SEVERE, msg, e);
			throw new ProcessingException(msg, e);
		}
	}

	containerRequest.setEntityStream(new ByteArrayInputStream(clientOutput.toByteArray()));

	final boolean followRedirects = ClientProperties.getValue(clientRequest.getConfiguration().getProperties(),
			ClientProperties.FOLLOW_REDIRECTS, true);

	final InMemoryResponseWriter inMemoryResponseWriter = new InMemoryResponseWriter();
	containerRequest.setWriter(inMemoryResponseWriter);
	containerRequest.setSecurityContext(new SecurityContext() {

		@Override
		public String getAuthenticationScheme() {
			return null;
		}

		@Override
		public Principal getUserPrincipal() {
			return null;
		}

		@Override
		public boolean isSecure() {
			return false;
		}

		@Override
		public boolean isUserInRole(final String role) {
			return false;
		}

	});
	this.appHandler.handle(containerRequest);

	return tryFollowRedirects(followRedirects,
			CdiAwareInMemoryConnector.createClientResponse(clientRequest, inMemoryResponseWriter),
			new ClientRequest(clientRequest));

}
 

import org.glassfish.jersey.internal.PropertiesDelegate; //导入依赖的package包/类
@Test
public void testFilter() throws Exception {
    DatabaseProvider.openConnection();

    String username = "testuser";

    User user = new User();
    user.setName(username);
    user.setLogin("testUserLogin");
    user.setPassHash("testUserPassHash");
    user.saveIt();


    HttpSession session = Mockito.mock(HttpSession.class);
    HttpServletRequest request = Mockito.mock(HttpServletRequest.class);

    Mockito.stub(request.getSession(true)).toReturn(session);
    Mockito.stub(session.getAttribute("userId")).toReturn(user.getId());

    AuthUserProvider provider = new AuthUserProvider();


    ContainerRequestContext containerRequest =
            new ContainerRequest(null, null, null, null, Mockito.mock(PropertiesDelegate.class));

    provider.setRequest(request);
    provider.filter(containerRequest);

    assertEquals(username, containerRequest.getSecurityContext().getUserPrincipal().getName());
}
 

import org.glassfish.jersey.internal.PropertiesDelegate; //导入依赖的package包/类
/**
 * Create new Jersey container request context.
 *
 * @param baseUri            base application URI.
 * @param requestUri         request URI.
 * @param httpMethod         request HTTP method name.
 * @param securityContext    security context of the current request. Must not be {@code null}.
 *                           The {@link javax.ws.rs.core.SecurityContext#getUserPrincipal()} must return
 *                           {@code null} if the current request has not been authenticated
 *                           by the container.
 * @param propertiesDelegate custom {@link org.glassfish.jersey.internal.PropertiesDelegate properties delegate}
 */
public Request(URI baseUri, URI requestUri, String httpMethod, SecurityContext securityContext, PropertiesDelegate propertiesDelegate) {
    super(baseUri, requestUri, httpMethod, securityContext, propertiesDelegate);
}
 

import org.glassfish.jersey.internal.PropertiesDelegate; //导入依赖的package包/类
/**
 * <p>readEntity.</p>
 *
 * @param rawType            a {@link java.lang.Class} object.
 * @param type               a {@link java.lang.reflect.Type} object.
 * @param annotations        an array of {@link java.lang.annotation.Annotation} objects.
 * @param propertiesDelegate a {@link org.glassfish.jersey.internal.PropertiesDelegate} object.
 * @param <T>                a T object.
 * @return a T object.
 */
public static <T> T readEntity(Class<T> rawType, Type type, Annotation[] annotations, PropertiesDelegate propertiesDelegate) {
    return getRequest().readEntity(rawType, type, annotations, propertiesDelegate);
}
 

import org.glassfish.jersey.internal.PropertiesDelegate; //导入依赖的package包/类
/**
 * <p>getPropertiesDelegate.</p>
 *
 * @return a {@link org.glassfish.jersey.internal.PropertiesDelegate} object.
 */
public static PropertiesDelegate getPropertiesDelegate() {
    return getRequest().getPropertiesDelegate();
}