Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source.
   * Copyright 2012 Red Hat, Inc., and individual contributors
   * as indicated by the @author tags.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package io.undertow.servlet.spec;
 
 
 import java.io.File;
 import java.net.URL;
 import java.util.Map;
 import java.util.Set;
 
 import static io.undertow.servlet.core.ApplicationListeners.ListenerState.NO_LISTENER;
 import static io.undertow.servlet.core.ApplicationListeners.ListenerState.PROGRAMATIC_LISTENER;

Author(s):
Stuart Douglas
 
 public class ServletContextImpl implements ServletContext {
 
     private final ServletContainer servletContainer;
     private final Deployment deployment;
    private final ConcurrentMap<StringObjectattributes;
    private final AttachmentKey<HttpSessionImplsessionAttachmentKey = AttachmentKey.create(HttpSessionImpl.class);
    private volatile SessionConfig sessionConfig;
    private volatile boolean initialized = false;
    public ServletContextImpl(final ServletContainer servletContainerfinal Deployment deployment) {
        this. = servletContainer;
        this. = deployment;
        this. = deployment.getDeploymentInfo();
         = new SessionCookieConfigImpl(this);
        if (.getServletContextAttributeBackingMap() == null) {
            this. = new ConcurrentHashMap<StringObject>();
        } else {
        }
    }
    public void initDone() {
         = true;
        Set<SessionTrackingModetrackingMethods = ;
        SessionConfig sessionConfig = ;
        if (trackingMethods != null && !trackingMethods.isEmpty()) {
            if (.contains(.)) {
                sessionConfig = new SslSessionConfig(.getSessionManager());
            } else {
                } else if (.contains(.)) {
                    sessionConfig = new PathParameterSessionConfig(.getName().toLowerCase(.));
                }
            }
        }
        if (wrapper != null) {
            sessionConfig = wrapper.wrap(sessionConfig);
        }
        this. = sessionConfig;
    }
    @Override
    public String getContextPath() {
        return .getContextPath();
    }
    @Override
    public ServletContext getContext(final String uripath) {
        DeploymentManager deploymentByPath = .getDeploymentByPath(uripath);
        if (deploymentByPath == null) {
            return null;
        }
        return deploymentByPath.getDeployment().getServletContext();
    }
    @Override
    public int getMajorVersion() {
        return 3;
    }
    @Override
    public int getMinorVersion() {
        return 1;
    }
    @Override
    public int getEffectiveMajorVersion() {
        return .getMajorVersion();
    }
    @Override
    public int getEffectiveMinorVersion() {
        return .getMinorVersion();
    }
    @Override
    public String getMimeType(final String file) {
        int pos = file.lastIndexOf('.');
        if (pos == -1) {
            return .getMimeExtensionMappings().get(file);
        }
        return .getMimeExtensionMappings().get(file.substring(pos + 1));
    }
    @Override
    public Set<StringgetResourcePaths(final String path) {
        final Resource resource;
        try {
            resource = .getResourceManager().getResource(path);
        } catch (IOException e) {
            return null;
        }
        if (resource == null || !resource.isDirectory()) {
            return null;
        }
        final Set<Stringresources = new HashSet<String>();
        for (Resource res : resource.list()) {
            File file = res.getFile();
            if (file != null) {
                File base = res.getResourceManagerRoot();
                if (base == null) {
                    resources.add(file.getPath()); //not much else we can do here
                } else {
                    String filePath = file.getAbsolutePath().substring(base.getAbsolutePath().length());
                    filePath = filePath.replace('\\''/'); //for windows systems
                    if (file.isDirectory()) {
                        filePath = filePath + "/";
                    }
                    resources.add(filePath);
                }
            }
        }
        return resources;
    }
    @Override
    public URL getResource(final String paththrows MalformedURLException {
        if (!path.startsWith("/")) {
            throw ..pathMustStartWithSlash(path);
        }
        Resource resource = null;
        try {
            resource = .getResourceManager().getResource(path);
        } catch (IOException e) {
            return null;
        }
        if (resource == null) {
            return null;
        }
        return resource.getUrl();
    }
    @Override
    public InputStream getResourceAsStream(final String path) {
        Resource resource = null;
        try {
            resource = .getResourceManager().getResource(path);
        } catch (IOException e) {
            return null;
        }
        if (resource == null) {
            return null;
        }
        try {
            if (resource.getFile() != null) {
                return new BufferedInputStream(new FileInputStream(resource.getFile()));
            } else {
                return new BufferedInputStream(resource.getUrl().openStream());
            }
        } catch (FileNotFoundException e) {
            //should never happen, as the resource loader should return null in this case
            return null;
        } catch (IOException e) {
            return null;
        }
    }
    @Override
    public RequestDispatcher getRequestDispatcher(final String path) {
        return new RequestDispatcherImpl(paththis);
    }
    @Override
    public RequestDispatcher getNamedDispatcher(final String name) {
        if (chain != null) {
            return new RequestDispatcherImpl(chainthis);
        } else {
            return null;
        }
    }
    @Override
    public Servlet getServlet(final String namethrows ServletException {
    }
    @Override
    public Enumeration<ServletgetServlets() {
        return EmptyEnumeration.instance();
    }
    @Override
    public Enumeration<StringgetServletNames() {
        return EmptyEnumeration.instance();
    }
    @Override
    public void log(final String msg) {
    }
    @Override
    public void log(final Exception exceptionfinal String msg) {
        ..error(msgexception);
    }
    @Override
    public void log(final String messagefinal Throwable throwable) {
        ..error(messagethrowable);
    }
    @Override
    public String getRealPath(final String path) {
        if (path == null) {
            return null;
        }
        Resource resource = null;
        try {
            resource = .getResourceManager().getResource(path);
        } catch (IOException e) {
            return null;
        }
        if (resource == null) {
            return null;
        }
        File file = resource.getFile();
        if (file == null) {
            return null;
        }
        return file.getAbsolutePath();
    }
    @Override
    public String getServerInfo() {
        return .getServerName() + " - " + Version.getVersionString();
    }
    @Override
    public String getInitParameter(final String name) {
        if (name == null) {
            throw ..nullName();
        }
        return .getInitParameters().get(name);
    }
    @Override
    }
    @Override
    public boolean setInitParameter(final String namefinal String value) {
        if (.getInitParameters().containsKey(name)) {
            return false;
        }
        .addInitParameter(namevalue);
        return true;
    }
    @Override
    public Object getAttribute(final String name) {
        return .get(name);
    }
    @Override
    public Enumeration<StringgetAttributeNames() {
        return new IteratorEnumeration<String>(.keySet().iterator());
    }
    @Override
    public void setAttribute(final String namefinal Object object) {
        if (object == null) {
            Object existing = .remove(name);
            if (.getApplicationListeners() != null) {
                if (existing != null) {
                    .getApplicationListeners().servletContextAttributeRemoved(nameexisting);
                }
            }
        } else {
            Object existing = .put(nameobject);
            if (.getApplicationListeners() != null) {
                if (existing != null) {
                    .getApplicationListeners().servletContextAttributeReplaced(nameexisting);
                } else {
                    .getApplicationListeners().servletContextAttributeAdded(nameobject);
                }
            }
        }
    }
    @Override
    public void removeAttribute(final String name) {
        Object exiting = .remove(name);
    }
    @Override
    public String getServletContextName() {
        return .getDisplayName();
    }
    @Override
    public ServletRegistration.Dynamic addServlet(final String servletNamefinal String className) {
        ensureNotInitialized();
        try {
            if (.getServlets().containsKey(servletName)) {
                return null;
            }
            ServletInfo servlet = new ServletInfo(servletName, (Class<? extends Servlet>) .getClassLoader().loadClass(className));
            readServletAnnotations(servlet);
            .addServlet(servlet);
            .getServlets().addServlet(servlet);
            return new ServletRegistrationImpl(servlet);
        } catch (ClassNotFoundException e) {
            throw ..cannotLoadClass(classNamee);
        }
    }
    @Override
    public ServletRegistration.Dynamic addServlet(final String servletNamefinal Servlet servlet) {
        ensureNotInitialized();
        if (.getServlets().containsKey(servletName)) {
            return null;
        }
        ServletInfo s = new ServletInfo(servletNameservlet.getClass(), new ImmediateInstanceFactory<Servlet>(servlet));
        readServletAnnotations(s);
        .addServlet(s);
        .getServlets().addServlet(s);
        return new ServletRegistrationImpl(s);
    }
    @Override
    public ServletRegistration.Dynamic addServlet(final String servletNamefinal Class<? extends ServletservletClass) {
        ensureNotInitialized();
        if (.getServlets().containsKey(servletName)) {
            return null;
        }
        ServletInfo servlet = new ServletInfo(servletNameservletClass);
        readServletAnnotations(servlet);
        .addServlet(servlet);
        .getServlets().addServlet(servlet);
        return new ServletRegistrationImpl(servlet);
    }
    @Override
    public <T extends Servlet> T createServlet(final Class<T> clazzthrows ServletException {
        try {
        } catch (Exception e) {
            throw ..couldNotInstantiateComponent(clazz.getName(), e);
        }
    }
    @Override
    public ServletRegistration getServletRegistration(final String servletName) {
        final ServletInfo servlet = .getServlets().get(servletName);
        if (servlet == null) {
            return null;
        }
        return new ServletRegistrationImpl(servlet);
    }
    @Override
    public Map<String, ? extends ServletRegistrationgetServletRegistrations() {
        final Map<StringServletRegistrationret = new HashMap<StringServletRegistration>();
        for (Map.Entry<StringServletInfoentry : .getServlets().entrySet()) {
            ret.put(entry.getKey(), new ServletRegistrationImpl(entry.getValue(), ));
        }
        return ret;
    }
    @Override
    public FilterRegistration.Dynamic addFilter(final String filterNamefinal String className) {
        ensureNotInitialized();
        if (.getFilters().containsKey(filterName)) {
            return null;
        }
        try {
            FilterInfo filter = new FilterInfo(filterName, (Class<? extends Filter>) .getClassLoader().loadClass(className));
            .addFilter(filter);
            .getFilters().addFilter(filter);
            return new FilterRegistrationImpl(filter);
        } catch (ClassNotFoundException e) {
            throw ..cannotLoadClass(classNamee);
        }
    }
    @Override
    public FilterRegistration.Dynamic addFilter(final String filterNamefinal Filter filter) {
        ensureNotInitialized();
        if (.getFilters().containsKey(filterName)) {
            return null;
        }
        FilterInfo f = new FilterInfo(filterNamefilter.getClass(), new ImmediateInstanceFactory<Filter>(filter));
        .addFilter(f);
        .getFilters().addFilter(f);
        return new FilterRegistrationImpl(f);
    }
    @Override
    public FilterRegistration.Dynamic addFilter(final String filterNamefinal Class<? extends FilterfilterClass) {
        ensureNotInitialized();
        if (.getFilters().containsKey(filterName)) {
            return null;
        }
        FilterInfo filter = new FilterInfo(filterNamefilterClass);
        .addFilter(filter);
        .getFilters().addFilter(filter);
        return new FilterRegistrationImpl(filter);
    }
    @Override
    public <T extends Filter> T createFilter(final Class<T> clazzthrows ServletException {
        try {
        } catch (Exception e) {
            throw ..couldNotInstantiateComponent(clazz.getName(), e);
        }
    }
    @Override
    public FilterRegistration getFilterRegistration(final String filterName) {
        final FilterInfo filterInfo = .getFilters().get(filterName);
        if (filterInfo == null) {
            return null;
        }
        return new FilterRegistrationImpl(filterInfo);
    }
    @Override
    public Map<String, ? extends FilterRegistrationgetFilterRegistrations() {
        final Map<StringFilterRegistrationret = new HashMap<StringFilterRegistration>();
        for (Map.Entry<StringFilterInfoentry : .getFilters().entrySet()) {
            ret.put(entry.getKey(), new FilterRegistrationImpl(entry.getValue(), ));
        }
        return ret;
    }
    @Override
        return ;
    }
    @Override
    public void setSessionTrackingModes(final Set<SessionTrackingModesessionTrackingModes) {
        ensureNotInitialized();
        if (sessionTrackingModes.size() > 1 && sessionTrackingModes.contains(.)) {
        }
        this. = new HashSet<SessionTrackingMode>(sessionTrackingModes);
        //TODO: actually make this work
    }
    @Override
        return ;
    }
    @Override
        return Collections.unmodifiableSet();
    }
    @Override
    public void addListener(final String className) {
        try {
            Class<? extends EventListenerclazz = (Class<? extends EventListener>) .getClassLoader().loadClass(className);
            addListener(clazz);
        } catch (ClassNotFoundException e) {
            throw new IllegalArgumentException(e);
        }
    }
    @Override
    public <T extends EventListenervoid addListener(final T t) {
        ensureNotInitialized();
        if (ApplicationListeners.listenerState() !=  &&
                ServletContextListener.class.isAssignableFrom(t.getClass())) {
        }
        ListenerInfo listener = new ListenerInfo(t.getClass(), new ImmediateInstanceFactory<EventListener>(t));
        .addListener(listener);
        .getApplicationListeners().addListener(new ManagedListener(listenertrue));
    }
    @Override
    public void addListener(final Class<? extends EventListenerlistenerClass) {
        ensureNotInitialized();
        if (ApplicationListeners.listenerState() !=  &&
                ServletContextListener.class.isAssignableFrom(listenerClass)) {
        }
        InstanceFactory<? extends EventListenerfactory = null;
        try {
            factory = .getClassIntrospecter().createInstanceFactory(listenerClass);
        } catch (Exception e) {
            throw new IllegalArgumentException(e);
        }
        final ListenerInfo listener = new ListenerInfo(listenerClassfactory);
        .addListener(listener);
        .getApplicationListeners().addListener(new ManagedListener(listenertrue));
    }
    @Override
    public <T extends EventListener> T createListener(final Class<T> clazzthrows ServletException {
        if (!ApplicationListeners.isListenerClass(clazz)) {
        }
        try {
        } catch (Exception e) {
            throw ..couldNotInstantiateComponent(clazz.getName(), e);
        }
    }
    @Override
        return .getJspConfigDescriptor();
    }
    @Override
    public ClassLoader getClassLoader() {
        return .getClassLoader();
    }
    @Override
    public void declareRoles(final String... roleNames) {
    }
    @Override
    public String getVirtualServerName() {
        return .getDeploymentInfo().getHostName();
    }

    
Gets the session with the specified ID if it exists

Parameters:
sessionId The session ID
Returns:
The session
    public HttpSessionImpl getSession(final String sessionId) {
        final SessionManager sessionManager = .getSessionManager();
        Session session = sessionManager.getSession(sessionId);
        if (session != null) {
            return SecurityActions.forSession(sessionthisfalse);
        }
        return null;
    }
    public HttpSessionImpl getSession(final ServletContextImpl originalServletContextfinal HttpServerExchange exchangeboolean create) {
        SessionConfig c = originalServletContext.getSessionConfig();
        HttpSessionImpl httpSession = exchange.getAttachment();
        if (httpSession != null && httpSession.isInvalid()) {
            exchange.removeAttachment();
            httpSession = null;
        }
        if (httpSession == null) {
            final SessionManager sessionManager = .getSessionManager();
            Session session = sessionManager.getSession(exchangec);
            if (session != null) {
                httpSession = SecurityActions.forSession(sessionthisfalse);
                exchange.putAttachment(httpSession);
            } else if (create) {
                String existing = c.findSessionId(exchange);
                if (originalServletContext != this) {
                    //this is a cross context request
                    //we need to make sure there is a top level session
                    originalServletContext.getSession(originalServletContextexchangetrue);
                } else if (existing != null) {
                    c.clearSession(exchangeexisting);
                }
                final Session newSession = sessionManager.createSession(exchangec);
                httpSession = SecurityActions.forSession(newSessionthistrue);
                exchange.putAttachment(httpSession);
            }
        }
        return httpSession;
    }

    
Gets the session

Parameters:
create
Returns:
    public HttpSessionImpl getSession(final HttpServerExchange exchangeboolean create) {
        return getSession(thisexchangecreate);
    }
    public void updateSessionAccessTime(final HttpServerExchange exchange) {
        HttpSessionImpl httpSession = getSession(exchangefalse);
        if (httpSession != null) {
            Session underlyingSession;
            if (System.getSecurityManager() == null) {
                underlyingSession = httpSession.getSession();
            } else {
                underlyingSession = AccessController.doPrivileged(new HttpSessionImpl.UnwrapSessionAction(httpSession));
            }
            underlyingSession.requestDone(exchange);
        }
    }
    public Deployment getDeployment() {
        return ;
    }
    private void ensureNotInitialized() {
        if () {
        }
    }
    private void ensureNotProgramaticListener() {
        if (ApplicationListeners.listenerState() == ) {
        }
    }
    boolean isInitialized() {
        return ;
    }
    public SessionConfig getSessionConfig() {
        return ;
    }
    public void destroy() {
        .clear();
         = null;
    }
    private void readServletAnnotations(ServletInfo servlet) {
        if (System.getSecurityManager() == null) {
            new ReadServletAnnotationsTask(servlet).run();
        } else {
            AccessController.doPrivileged(new ReadServletAnnotationsTask(servlet));
        }
    }
    public void setDefaultSessionTrackingModes(HashSet<SessionTrackingModesessionTrackingModes) {
        this. = sessionTrackingModes;
        this. = sessionTrackingModes;
    }
    private static final class ReadServletAnnotationsTask implements PrivilegedAction<Void> {
        private final ServletInfo servletInfo;
        private final DeploymentInfo deploymentInfo;
        private ReadServletAnnotationsTask(ServletInfo servletInfoDeploymentInfo deploymentInfo) {
            this. = servletInfo;
            this. = deploymentInfo;
        }
        @Override
        public Void run() {
            final ServletSecurity security = .getServletClass().getAnnotation(ServletSecurity.class);
            if (security != null) {
                ServletSecurityInfo servletSecurityInfo = new ServletSecurityInfo()
                        .addRolesAllowed(security.value().rolesAllowed());
                for (HttpMethodConstraint constraint : security.httpMethodConstraints()) {
                    servletSecurityInfo.addHttpMethodSecurityInfo(new HttpMethodSecurityInfo()
                            .setMethod(constraint.value()))
                            .addRolesAllowed(constraint.rolesAllowed());
                }
                .setServletSecurityInfo(servletSecurityInfo);
            }
            final MultipartConfig multipartConfig = .getServletClass().getAnnotation(MultipartConfig.class);
            if (multipartConfig != null) {
                .setMultipartConfig(new MultipartConfigElement(multipartConfig.location(), multipartConfig.maxFileSize(), multipartConfig.maxRequestSize(), multipartConfig.fileSizeThreshold()));
            }
            final RunAs runAs = .getServletClass().getAnnotation(RunAs.class);
            if (runAs != null) {
                .setRunAs(runAs.value());
            }
            final DeclareRoles declareRoles = .getServletClass().getAnnotation(DeclareRoles.class);
            if (declareRoles != null) {
                .addSecurityRoles(declareRoles.value());
            }
            return null;
        }
    }
New to GrepCode? Check out our FAQ X