diff --git a/http/base/src/main/java/org/apache/felix/http/base/internal/registry/ErrorPageRegistry.java b/http/base/src/main/java/org/apache/felix/http/base/internal/registry/ErrorPageRegistry.java
index 90101e6..74253e9 100644
--- a/http/base/src/main/java/org/apache/felix/http/base/internal/registry/ErrorPageRegistry.java
+++ b/http/base/src/main/java/org/apache/felix/http/base/internal/registry/ErrorPageRegistry.java
@@ -17,7 +17,6 @@
 package org.apache.felix.http.base.internal.registry;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -29,7 +28,6 @@
 import java.util.regex.Pattern;
 
 import javax.annotation.Nonnull;
-import javax.servlet.Servlet;
 
 import org.apache.felix.http.base.internal.handler.ServletHandler;
 import org.apache.felix.http.base.internal.runtime.ServletInfo;
@@ -85,9 +83,9 @@
 
     private final Map<ServletInfo, ErrorRegistrationStatus> statusMapping = new ConcurrentHashMap<ServletInfo, ErrorRegistrationStatus>();
 
-    private static final class ErrorRegistration {
-        final Set<Long> errorCodes = new TreeSet<Long>();
-        final Set<String> exceptions = new TreeSet<String>();
+    public static final class ErrorRegistration {
+        public final Set<Long> errorCodes = new TreeSet<Long>();
+        public final Set<String> exceptions = new TreeSet<String>();
     }
 
     private static final class ErrorRegistrationStatus {
@@ -96,7 +94,7 @@
         final Map<String, Integer> exceptionMapping = new ConcurrentHashMap<String, Integer>();
     }
 
-    private ErrorRegistration getErrorRegistration(@Nonnull final ServletInfo info)
+    public static ErrorRegistration getErrorRegistration(@Nonnull final ServletInfo info)
     {
         if ( info.getErrorPage() != null )
         {
@@ -386,8 +384,8 @@
         return result == -1;
     }
 
-    public void getRuntimeInfo(final Collection<ServletState> servletStates,
-            final Collection<FailureServletState> failureServletStates)
+    public void getRuntimeInfo(final Map<Long, ServletState> servletStates,
+            final Map<Long, Map<Integer, FailureServletState>> failureServletStates)
     {
         for(final ErrorRegistrationStatus status : this.statusMapping.values())
         {
@@ -431,94 +429,56 @@
             }
             if ( !active.errorCodes.isEmpty() || !active.exceptions.isEmpty() )
             {
-                servletStates.add(new ServletState()
+                ServletState state = servletStates.get(status.handler.getServletInfo().getServiceId());
+                if ( state == null )
                 {
-
-                    @Override
-                    public Servlet getServlet()
+                    state = new ServletState(status.handler);
+                    servletStates.put(status.handler.getServletInfo().getServiceId(), state);
+                }
+                if ( !active.errorCodes.isEmpty() )
+                {
+                    final long[] codes = new long[active.errorCodes.size()];
+                    final Iterator<Long> iter = active.errorCodes.iterator();
+                    for(int i=0; i<codes.length; i++)
                     {
-                        return status.handler.getServlet();
+                        codes[i] = iter.next();
                     }
-
-                    @Override
-                    public ServletInfo getServletInfo()
-                    {
-                        return status.handler.getServletInfo();
-                    }
-
-                    @Override
-                    public String[] getPatterns()
-                    {
-                        return null;
-                    }
-
-                    @Override
-                    public long[] getErrorCodes()
-                    {
-                        final long[] codes = new long[active.errorCodes.size()];
-                        final Iterator<Long> iter = active.errorCodes.iterator();
-                        for(int i=0; i<codes.length; i++)
-                        {
-                            codes[i] = iter.next();
-                        }
-                        return codes;
-                    }
-
-                    @Override
-                    public String[] getErrorExceptions()
-                    {
-                        return active.exceptions.toArray(new String[active.exceptions.size()]);
-                    }
-                });
+                    state.setErrorCodes(codes);
+                }
+                if ( !active.exceptions.isEmpty() )
+                {
+                    state.setErrorExceptions(active.exceptions.toArray(new String[active.exceptions.size()]));
+                }
             }
             for(final Map.Entry<Integer, ErrorRegistration> entry : inactive.entrySet())
             {
-                failureServletStates.add(new FailureServletState()
+                Map<Integer, FailureServletState> failureStates = failureServletStates.get(status.handler.getServletInfo().getServiceId());
+                if ( failureStates == null )
                 {
+                    failureStates = new HashMap<Integer, FailureServletState>();
+                    failureServletStates.put(status.handler.getServletInfo().getServiceId(), failureStates);
+                }
 
-                    @Override
-                    public Servlet getServlet()
+                FailureServletState state = failureStates.get(entry.getKey());
+                if ( state == null )
+                {
+                    state = new FailureServletState(status.handler, entry.getKey());
+                    failureStates.put(entry.getKey(), state);
+                }
+                if ( !entry.getValue().errorCodes.isEmpty() )
+                {
+                    final long[] codes = new long[entry.getValue().errorCodes.size()];
+                    final Iterator<Long> iter = entry.getValue().errorCodes.iterator();
+                    for(int i=0; i<codes.length; i++)
                     {
-                        return status.handler.getServlet();
+                        codes[i] = iter.next();
                     }
-
-                    @Override
-                    public ServletInfo getServletInfo()
-                    {
-                        return status.handler.getServletInfo();
-                    }
-
-                    @Override
-                    public String[] getPatterns()
-                    {
-                        return null;
-                    }
-
-                    @Override
-                    public long[] getErrorCodes()
-                    {
-                        final long[] codes = new long[entry.getValue().errorCodes.size()];
-                        final Iterator<Long> iter = entry.getValue().errorCodes.iterator();
-                        for(int i=0; i<codes.length; i++)
-                        {
-                            codes[i] = iter.next();
-                        }
-                        return codes;
-                    }
-
-                    @Override
-                    public String[] getErrorExceptions()
-                    {
-                        return entry.getValue().exceptions.toArray(new String[entry.getValue().exceptions.size()]);
-                    }
-
-                    @Override
-                    public long getReason()
-                    {
-                        return entry.getKey();
-                    }
-
-                });
+                    state.setErrorCodes(codes);
+                }
+                if ( !entry.getValue().exceptions.isEmpty() )
+                {
+                    state.setErrorExceptions(entry.getValue().exceptions.toArray(new String[entry.getValue().exceptions.size()]));
+                }
             }
         }
     }
diff --git a/http/base/src/main/java/org/apache/felix/http/base/internal/registry/FilterRegistry.java b/http/base/src/main/java/org/apache/felix/http/base/internal/registry/FilterRegistry.java
index b69cac8..63c18c5 100644
--- a/http/base/src/main/java/org/apache/felix/http/base/internal/registry/FilterRegistry.java
+++ b/http/base/src/main/java/org/apache/felix/http/base/internal/registry/FilterRegistry.java
@@ -53,7 +53,7 @@
             return handler.getFilterInfo();
         }
         @Override
-        public long getReason() {
+        public int getReason() {
             return result;
         }
     }
diff --git a/http/base/src/main/java/org/apache/felix/http/base/internal/registry/PerContextHandlerRegistry.java b/http/base/src/main/java/org/apache/felix/http/base/internal/registry/PerContextHandlerRegistry.java
index 937a963..bf0d4f7 100644
--- a/http/base/src/main/java/org/apache/felix/http/base/internal/registry/PerContextHandlerRegistry.java
+++ b/http/base/src/main/java/org/apache/felix/http/base/internal/registry/PerContextHandlerRegistry.java
@@ -17,6 +17,8 @@
 package org.apache.felix.http.base.internal.registry;
 
 import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.TreeSet;
 
 import javax.annotation.Nonnull;
@@ -192,22 +194,30 @@
 
     public ContextRuntime getRuntime()
     {
+        // collect filters
         final Collection<FilterState> filterRuntimes = new TreeSet<FilterState>(FilterState.COMPARATOR);
         final Collection<FailureFilterState> failureFilterRuntimes = new TreeSet<FailureFilterState>(FailureFilterState.COMPARATOR);
         this.filterRegistry.getRuntimeInfo(filterRuntimes, failureFilterRuntimes);
 
-        final Collection<ServletState> errorPageRuntimes = new TreeSet<ServletState>(ServletState.COMPARATOR);
-        final Collection<FailureServletState> failureErrorPageRuntimes = new TreeSet<FailureServletState>(FailureServletState.COMPARATOR);
-        this.errorPageRegistry.getRuntimeInfo(errorPageRuntimes, failureErrorPageRuntimes);
-        // TODO - add servlets
-        // TODO - add failures from filters and error pages
+        // collect error pages
+        final Map<Long, ServletState> servletStates = new HashMap<Long, ServletState>();
+        final Map<Long, Map<Integer, FailureServletState>> failureServletStates = new HashMap<Long, Map<Integer,FailureServletState>>();
+        this.errorPageRegistry.getRuntimeInfo(servletStates, failureServletStates);
+
+        // collect servlets and resources
+        this.servletRegistry.getRuntimeInfo(servletStates, failureServletStates);
+
+        final Collection<ServletState> sortedServletStates = new TreeSet<ServletState>(ServletState.COMPARATOR);
+        sortedServletStates.addAll(servletStates.values());
+        final Collection<FailureServletState> sortedFailureServletStates = new TreeSet<FailureServletState>(ServletState.COMPARATOR);
+        for(final Map<Integer, FailureServletState> val : failureServletStates.values())
+        {
+            sortedFailureServletStates.addAll(val.values());
+        }
+
         return new ContextRuntime(filterRuntimes,
-                errorPageRuntimes,
-                null,
-                null,
+                sortedServletStates,
                 failureFilterRuntimes,
-                failureErrorPageRuntimes,
-                null,
-                null);
+                sortedFailureServletStates);
     }
 }
diff --git a/http/base/src/main/java/org/apache/felix/http/base/internal/registry/ServletRegistry.java b/http/base/src/main/java/org/apache/felix/http/base/internal/registry/ServletRegistry.java
index 745eae0..dbcf29d 100644
--- a/http/base/src/main/java/org/apache/felix/http/base/internal/registry/ServletRegistry.java
+++ b/http/base/src/main/java/org/apache/felix/http/base/internal/registry/ServletRegistry.java
@@ -29,6 +29,8 @@
 
 import org.apache.felix.http.base.internal.handler.ServletHandler;
 import org.apache.felix.http.base.internal.runtime.ServletInfo;
+import org.apache.felix.http.base.internal.runtime.dto.state.FailureServletState;
+import org.apache.felix.http.base.internal.runtime.dto.state.ServletState;
 import org.apache.felix.http.base.internal.util.PatternUtil;
 import org.osgi.service.http.runtime.dto.DTOConstants;
 
@@ -52,28 +54,12 @@
 
     private final Map<ServletInfo, ServletRegistrationStatus> statusMapping = new ConcurrentHashMap<ServletInfo, ServletRegistry.ServletRegistrationStatus>();
 
-    private final Map<String, List<ServletNameStatus>> servletsByName = new ConcurrentHashMap<String, List<ServletNameStatus>>();
-
-    private static final class ServletNameStatus implements Comparable<ServletNameStatus>
-    {
-        public volatile boolean isActive = false;
-        public final ServletHandler handler;
-
-        public ServletNameStatus(final ServletHandler h)
-        {
-            this.handler = h;
-        }
-
-        @Override
-        public int compareTo(final ServletNameStatus o)
-        {
-            return handler.compareTo(o.handler);
-        }
-    }
+    private final Map<String, List<ServletHandler>> servletsByName = new ConcurrentHashMap<String, List<ServletHandler>>();
 
     public static final class ServletRegistrationStatus
     {
         public final Map<String, Integer> pathToStatus = new ConcurrentHashMap<String, Integer>();
+        public ServletHandler handler;
     }
 
     public PathResolution resolve(final String relativeRequestURI)
@@ -104,7 +90,9 @@
         if ( handler.getServletInfo().getPatterns() != null )
         {
             final ServletRegistrationStatus status = new ServletRegistrationStatus();
+            status.handler = handler;
 
+            boolean isActive = false;
             for(final String pattern : handler.getServletInfo().getPatterns())
             {
                 final ServletRegistration regHandler = this.activeServletMappings.get(pattern);
@@ -115,10 +103,16 @@
                         // replace if no error with new servlet
                         if ( this.tryToActivate(pattern, handler, status) )
                         {
-//                            nameStatus.isActive = true;
+                            isActive = true;
+                            final String oldName = regHandler.getServletHandler().getName();
                             regHandler.getServletHandler().destroy();
 
                             this.addToInactiveList(pattern, regHandler.getServletHandler(), this.statusMapping.get(regHandler.getServletHandler().getServletInfo()));
+
+                            if ( regHandler.getServletHandler().getServlet() == null )
+                            {
+                                removeFromNameMapping(oldName, regHandler.getServletHandler());
+                            }
                         }
                     }
                     else
@@ -132,11 +126,60 @@
                     // add to active
                     if ( this.tryToActivate(pattern, handler, status) )
                     {
-//                        nameStatus.isActive = true;
+                        isActive = true;
                     }
                 }
             }
             this.statusMapping.put(handler.getServletInfo(), status);
+            if ( isActive )
+            {
+                addToNameMapping(handler);
+            }
+        }
+    }
+
+    private void addToNameMapping(final ServletHandler handler)
+    {
+        final String servletName = handler.getName();
+        List<ServletHandler> list = this.servletsByName.get(servletName);
+        if ( list == null )
+        {
+            list = new ArrayList<ServletHandler>();
+            list.add(handler);
+        }
+        else
+        {
+            list = new ArrayList<ServletHandler>(list);
+            list.add(handler);
+            Collections.sort(list);
+        }
+        this.servletsByName.put(servletName, list);
+    }
+
+    private void removeFromNameMapping(final String servletName, final ServletHandler handler)
+    {
+        List<ServletHandler> list = this.servletsByName.get(servletName);
+        if ( list != null )
+        {
+            final List<ServletHandler> newList = new ArrayList<ServletHandler>(list);
+            final Iterator<ServletHandler> i = newList.iterator();
+            while ( i.hasNext() )
+            {
+                final ServletHandler s = i.next();
+                if ( s == handler )
+                {
+                    i.remove();
+                    break;
+                }
+            }
+            if ( newList.isEmpty() )
+            {
+                this.servletsByName.remove(servletName);
+            }
+            else
+            {
+                this.servletsByName.put(servletName, newList);
+            }
         }
     }
 
@@ -149,15 +192,16 @@
         if ( info.getPatterns() != null )
         {
             this.statusMapping.remove(info);
-            ServletHandler cleanuphandler = null;
+            ServletHandler cleanupHandler = null;
 
             for(final String pattern : info.getPatterns())
             {
-
                 final ServletRegistration regHandler = this.activeServletMappings.get(pattern);
                 if ( regHandler != null && regHandler.getServletHandler().getServletInfo().equals(info) )
                 {
-                    cleanuphandler = regHandler.getServletHandler();
+                    cleanupHandler = regHandler.getServletHandler();
+                    removeFromNameMapping(cleanupHandler.getName(), cleanupHandler);
+
                     final List<ServletHandler> inactiveList = this.inactiveServletMappings.get(pattern);
                     if ( inactiveList == null )
                     {
@@ -169,11 +213,19 @@
                         while ( !done )
                         {
                             final ServletHandler h = inactiveList.remove(0);
+                            boolean activate = h.getServlet() == null;
                             done = this.tryToActivate(pattern, h, this.statusMapping.get(h.getServletInfo()));
                             if ( !done )
                             {
                                 done = inactiveList.isEmpty();
                             }
+                            else
+                            {
+                                if ( activate )
+                                {
+                                    this.addToNameMapping(h);
+                                }
+                            }
                         }
                         if ( inactiveList.isEmpty() )
                         {
@@ -193,7 +245,7 @@
                             if ( h.getServletInfo().equals(info) )
                             {
                                 i.remove();
-                                cleanuphandler = h;
+                                cleanupHandler = h;
                                 break;
                             }
                         }
@@ -205,9 +257,9 @@
                 }
             }
 
-            if ( cleanuphandler != null )
+            if ( cleanupHandler != null )
             {
-                cleanuphandler.dispose();
+                cleanupHandler.dispose();
             }
         }
     }
@@ -247,22 +299,78 @@
         }
     }
 
-    public Map<ServletInfo, ServletRegistrationStatus> getServletStatusMapping()
+    Map<ServletInfo, ServletRegistrationStatus> getServletStatusMapping()
     {
         return this.statusMapping;
     }
 
-    public ServletHandler resolveByName(@Nonnull String name)
+    public ServletHandler resolveByName(final @Nonnull String name)
     {
-        final List<ServletNameStatus> handlerList = this.servletsByName.get(name);
+        final List<ServletHandler> handlerList = this.servletsByName.get(name);
         if ( handlerList != null )
         {
-            final ServletNameStatus status = handlerList.get(0);
-            if ( status != null && status.isActive )
-            {
-                return status.handler;
-            }
+            return handlerList.get(0);
         }
         return null;
     }
+
+    public void getRuntimeInfo(final Map<Long, ServletState> servletStates,
+            final Map<Long, Map<Integer, FailureServletState>> failureServletStates)
+    {
+        // TODO we could already do some pre calculation in the ServletRegistrationStatus
+        for(final Map.Entry<ServletInfo, ServletRegistrationStatus> entry : statusMapping.entrySet())
+        {
+            final long serviceId = entry.getKey().getServiceId();
+            for(final Map.Entry<String, Integer> map : entry.getValue().pathToStatus.entrySet())
+            {
+                if ( map.getValue() == - 1)
+                {
+                    ServletState state = servletStates.get(serviceId);
+                    if ( state == null )
+                    {
+                        state = new ServletState(entry.getValue().handler);
+                        servletStates.put(serviceId, state);
+                    }
+                    String[] patterns = state.getPatterns();
+                    if ( patterns.length ==  0 )
+                    {
+                        state.setPatterns(new String[] {map.getKey()});
+                    }
+                    else
+                    {
+                        patterns = new String[patterns.length + 1];
+                        System.arraycopy(state.getPatterns(), 0, patterns, 0, patterns.length - 1);
+                        patterns[patterns.length - 1] = map.getKey();
+                    }
+                }
+                else
+                {
+                    Map<Integer, FailureServletState> fmap = failureServletStates.get(serviceId);
+                    if ( fmap == null )
+                    {
+                        fmap = new HashMap<Integer, FailureServletState>();
+                        failureServletStates.put(serviceId, fmap);
+                    }
+                    FailureServletState state = fmap.get(map.getValue());
+                    if ( state == null )
+                    {
+                        state = new FailureServletState(entry.getValue().handler, map.getValue());
+                        fmap.put(map.getValue(), state);
+                    }
+                    String[] patterns = state.getPatterns();
+                    if ( patterns.length ==  0 )
+                    {
+                        state.setPatterns(new String[] {map.getKey()});
+                    }
+                    else
+                    {
+                        patterns = new String[patterns.length + 1];
+                        System.arraycopy(state.getPatterns(), 0, patterns, 0, patterns.length - 1);
+                        patterns[patterns.length - 1] = map.getKey();
+                    }
+                }
+
+            }
+        }
+    }
 }
diff --git a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ContextRuntime.java b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ContextRuntime.java
index 08010c1..dfe2d29 100644
--- a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ContextRuntime.java
+++ b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ContextRuntime.java
@@ -31,32 +31,20 @@
 public final class ContextRuntime
 {
     private final Collection<FilterState> filterRuntimes;
-    private final Collection<ServletState> errorPageRuntimes;
     private final Collection<ServletState> servletRuntimes;
-    private final Collection<ServletState> resourceRuntimes;
 
     private final Collection<FailureFilterState> failureFilterRuntimes;
-    private final Collection<FailureServletState> failureErrorPageRuntimes;
     private final Collection<FailureServletState> failureServletRuntimes;
-    private final Collection<FailureServletState> failureResourceRuntimes;
 
     public ContextRuntime(final Collection<FilterState> filterRuntimes,
-            final Collection<ServletState> errorPageRuntimes,
             final Collection<ServletState> servletRuntimes,
-            final Collection<ServletState> resourceRuntimes,
             final Collection<FailureFilterState> failureFilterRuntimes,
-            final Collection<FailureServletState> failureErrorPageRuntimes,
-            final Collection<FailureServletState> failureServletRuntimes,
-            final Collection<FailureServletState> failureResourceRuntimes)
+            final Collection<FailureServletState> failureServletRuntimes)
     {
         this.filterRuntimes = filterRuntimes;
-        this.errorPageRuntimes = errorPageRuntimes;
         this.servletRuntimes = servletRuntimes;
-        this.resourceRuntimes = resourceRuntimes;
         this.failureFilterRuntimes = failureFilterRuntimes;
-        this.failureErrorPageRuntimes = failureErrorPageRuntimes;
         this.failureServletRuntimes = failureServletRuntimes;
-        this.failureResourceRuntimes = failureResourceRuntimes;
     }
 
     Collection<ServletState> getServletRuntimes()
@@ -64,38 +52,18 @@
         return servletRuntimes;
     }
 
-    Collection<ServletState> getResourceRuntimes()
-    {
-        return resourceRuntimes;
-    }
-
     Collection<FilterState> getFilterRuntimes()
     {
         return filterRuntimes;
     }
 
-    Collection<ServletState> getErrorPageRuntimes()
-    {
-        return errorPageRuntimes;
-    }
-
     Collection<FailureServletState> getFailureServletRuntimes()
     {
         return failureServletRuntimes;
     }
 
-    Collection<FailureServletState> getFailureResourceRuntimes()
-    {
-        return failureResourceRuntimes;
-    }
-
     Collection<FailureFilterState> getFailureFilterRuntimes()
     {
         return failureFilterRuntimes;
     }
-
-    Collection<FailureServletState> getFailureErrorPageRuntimes()
-    {
-        return failureErrorPageRuntimes;
-    }
 }
diff --git a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ErrorPageDTOBuilder.java b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ErrorPageDTOBuilder.java
index 8cd2c35..89ecac9 100644
--- a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ErrorPageDTOBuilder.java
+++ b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ErrorPageDTOBuilder.java
@@ -18,6 +18,10 @@
  */
 package org.apache.felix.http.base.internal.runtime.dto;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
 import org.apache.felix.http.base.internal.runtime.dto.state.ServletState;
 import org.osgi.service.http.runtime.dto.ErrorPageDTO;
 
@@ -34,6 +38,20 @@
     }
 
     @Override
+    Collection<T> build(Collection<? extends ServletState> whiteboardServices,
+            long servletContextId) {
+        List<T> dtoList = new ArrayList<T>();
+        for (ServletState whiteboardService : whiteboardServices)
+        {
+            if ( whiteboardService.getErrorCodes().length > 0 || whiteboardService.getErrorExceptions().length > 0 )
+            {
+                dtoList.add(buildDTO(whiteboardService, servletContextId));
+            }
+        }
+        return dtoList;
+    }
+
+    @Override
     T buildDTO(ServletState errorPage, long servletConextId)
     {
         T errorPageDTO = super.buildDTO(errorPage, servletConextId);
diff --git a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/FailureRuntime.java b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/FailureRuntime.java
index bf9fc35..5a61148 100644
--- a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/FailureRuntime.java
+++ b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/FailureRuntime.java
@@ -26,19 +26,24 @@
 import static org.apache.felix.http.base.internal.runtime.dto.BuilderConstants.SERVLET_FAILURE_DTO_ARRAY;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
+import javax.servlet.ServletContext;
+
+import org.apache.felix.http.base.internal.registry.ErrorPageRegistry;
 import org.apache.felix.http.base.internal.runtime.AbstractInfo;
 import org.apache.felix.http.base.internal.runtime.FilterInfo;
 import org.apache.felix.http.base.internal.runtime.ListenerInfo;
 import org.apache.felix.http.base.internal.runtime.ResourceInfo;
 import org.apache.felix.http.base.internal.runtime.ServletContextHelperInfo;
 import org.apache.felix.http.base.internal.runtime.ServletInfo;
-import org.apache.felix.http.base.internal.runtime.dto.state.FilterState;
-import org.apache.felix.http.base.internal.runtime.dto.state.ServletState;
+import org.apache.felix.http.base.internal.runtime.dto.state.FailureFilterState;
+import org.apache.felix.http.base.internal.runtime.dto.state.FailureServletState;
 import org.osgi.framework.ServiceReference;
 import org.osgi.service.http.runtime.dto.FailedErrorPageDTO;
 import org.osgi.service.http.runtime.dto.FailedFilterDTO;
@@ -49,10 +54,7 @@
 
 public final class FailureRuntime
 {
-    private static final FailureComparator<ServletState> ERROR_PAGE_COMPARATOR = FailureComparator.<ServletState>create(ServletState.COMPARATOR);
-    private static final FailureComparator<FilterState> FILTER_COMPARATOR = FailureComparator.create(FilterState.COMPARATOR);
     private static final FailureComparator<ServletContextHelperRuntime> CONTEXT_COMPARATOR = FailureComparator.create(ServletContextHelperRuntime.COMPARATOR);
-    private static final FailureComparator<ServletState> SERVLET_COMPARATOR = FailureComparator.create(ServletState.COMPARATOR);
     private static final Comparator<Failure<ServiceReference<?>>> REFERENCE_COMPARATOR = new Comparator<Failure<ServiceReference<?>>>()
     {
         @Override
@@ -63,18 +65,18 @@
     };
 
     private final List<Failure<ServletContextHelperRuntime>> contextRuntimes;
-    private final List<Failure<ServletState>> servletRuntimes;
-    private final List<Failure<FilterState>> filterRuntimes;
-    private final List<Failure<ServletState>> resourceRuntimes;
-    private final List<Failure<ServletState>> errorPageRuntimes;
+    private final List<FailureServletState> servletRuntimes;
+    private final List<FailureFilterState> filterRuntimes;
+    private final List<FailureServletState> resourceRuntimes;
+    private final List<FailureServletState> errorPageRuntimes;
     private final List<Failure<ServiceReference<?>>> listenerRuntimes;
 
     private FailureRuntime(List<Failure<ServletContextHelperRuntime>> contextRuntimes,
             List<Failure<ServiceReference<?>>> listenerRuntimes,
-            List<Failure<ServletState>> servletRuntimes,
-            List<Failure<FilterState>> filterRuntimes,
-            List<Failure<ServletState>> resourceRuntimes,
-            List<Failure<ServletState>> errorPageRuntimes)
+            List<FailureServletState> servletRuntimes,
+            List<FailureFilterState> filterRuntimes,
+            List<FailureServletState> resourceRuntimes,
+            List<FailureServletState> errorPageRuntimes)
     {
         this.contextRuntimes = contextRuntimes;
         this.servletRuntimes = servletRuntimes;
@@ -84,16 +86,6 @@
         this.errorPageRuntimes = errorPageRuntimes;
     }
 
-    public static FailureRuntime empty()
-    {
-        return new FailureRuntime(Collections.<Failure<ServletContextHelperRuntime>>emptyList(),
-                Collections.<Failure<ServiceReference<?>>>emptyList(),
-                Collections.<Failure<ServletState>>emptyList(),
-                Collections.<Failure<FilterState>>emptyList(),
-                Collections.<Failure<ServletState>>emptyList(),
-                Collections.<Failure<ServletState>>emptyList());
-    }
-
     public static FailureRuntime.Builder builder()
     {
         return new Builder();
@@ -101,73 +93,73 @@
 
     public FailedServletDTO[] getServletDTOs()
     {
-        List<FailedServletDTO> servletDTOs = new ArrayList<FailedServletDTO>();
-        for (Failure<ServletState> failure : servletRuntimes)
+        final List<FailedServletDTO> servletDTOs = new ArrayList<FailedServletDTO>();
+        for (final FailureServletState failure : servletRuntimes)
         {
-            servletDTOs.add(getServletDTO(failure.service, failure.failureCode));
+            servletDTOs.add(getServletDTO(failure));
         }
         return servletDTOs.toArray(SERVLET_FAILURE_DTO_ARRAY);
     }
 
-    private FailedServletDTO getServletDTO(ServletState failedServlet, int failureCode)
+    private FailedServletDTO getServletDTO(FailureServletState failedServlet)
     {
         ServletDTOBuilder<FailedServletDTO> dtoBuilder = new ServletDTOBuilder<FailedServletDTO>(DTOFactories.FAILED_SERVLET);
         FailedServletDTO servletDTO = dtoBuilder.buildDTO(failedServlet, 0);
-        servletDTO.failureReason = failureCode;
+        servletDTO.failureReason = failedServlet.getReason();
         return servletDTO;
     }
 
     public FailedFilterDTO[] getFilterDTOs()
     {
         List<FailedFilterDTO> filterDTOs = new ArrayList<FailedFilterDTO>();
-        for (Failure<FilterState> failure : filterRuntimes)
+        for (FailureFilterState failure : filterRuntimes)
         {
-            filterDTOs.add(getFilterDTO(failure.service, failure.failureCode));
+            filterDTOs.add(getFilterDTO(failure));
         }
         return filterDTOs.toArray(FILTER_FAILURE_DTO_ARRAY);
     }
 
-    private FailedFilterDTO getFilterDTO(FilterState failedFilter, int failureCode)
+    private FailedFilterDTO getFilterDTO(FailureFilterState failedFilter)
     {
         FilterDTOBuilder<FailedFilterDTO> dtoBuilder = new FilterDTOBuilder<FailedFilterDTO>(DTOFactories.FAILED_FILTER);
         FailedFilterDTO filterDTO = dtoBuilder.buildDTO(failedFilter, 0);
-        filterDTO.failureReason = failureCode;
+        filterDTO.failureReason = failedFilter.getReason();
         return filterDTO;
     }
 
     public FailedResourceDTO[] getResourceDTOs()
     {
         List<FailedResourceDTO> resourceDTOs = new ArrayList<FailedResourceDTO>();
-        for (Failure<ServletState> failure : resourceRuntimes)
+        for (FailureServletState failure : resourceRuntimes)
         {
-            resourceDTOs.add(getResourceDTO(failure.service, failure.failureCode));
+            resourceDTOs.add(getResourceDTO(failure));
         }
         return resourceDTOs.toArray(RESOURCE_FAILURE_DTO_ARRAY);
     }
 
-    private FailedResourceDTO getResourceDTO(ServletState failedResource, int failureCode)
+    private FailedResourceDTO getResourceDTO(FailureServletState failedResource)
     {
         ResourceDTOBuilder<FailedResourceDTO> dtoBuilder = new ResourceDTOBuilder<FailedResourceDTO>(DTOFactories.FAILED_RESOURCE);
         FailedResourceDTO resourceDTO = dtoBuilder.buildDTO(failedResource, 0);
-        resourceDTO.failureReason = failureCode;
+        resourceDTO.failureReason = failedResource.getReason();
         return resourceDTO;
     }
 
     public FailedErrorPageDTO[] getErrorPageDTOs()
     {
         List<FailedErrorPageDTO> errorPageDTOs = new ArrayList<FailedErrorPageDTO>();
-        for (Failure<ServletState> failure : errorPageRuntimes)
+        for (FailureServletState failure : errorPageRuntimes)
         {
-            errorPageDTOs.add(getErrorPageDTO(failure.service, failure.failureCode));
+            errorPageDTOs.add(getErrorPageDTO(failure));
         }
         return errorPageDTOs.toArray(ERROR_PAGE_FAILURE_DTO_ARRAY);
     }
 
-    private FailedErrorPageDTO getErrorPageDTO(ServletState failedErrorPage, int failureCode)
+    private FailedErrorPageDTO getErrorPageDTO(FailureServletState failedErrorPage)
     {
         ErrorPageDTOBuilder<FailedErrorPageDTO> dtoBuilder = new ErrorPageDTOBuilder<FailedErrorPageDTO>(DTOFactories.FAILED_ERROR_PAGE);
         FailedErrorPageDTO errorPageDTO = dtoBuilder.buildDTO(failedErrorPage, 0);
-        errorPageDTO.failureReason = failureCode;
+        errorPageDTO.failureReason = failedErrorPage.getReason();
         return errorPageDTO;
     }
 
@@ -210,10 +202,10 @@
     public static class Builder
     {
         private final List<Failure<ServletContextHelperRuntime>> contextRuntimes = new ArrayList<FailureRuntime.Failure<ServletContextHelperRuntime>>();
-        private final List<Failure<ServletState>> servletRuntimes = new ArrayList<Failure<ServletState>>();
-        private final List<Failure<FilterState>> filterRuntimes = new ArrayList<Failure<FilterState>>();
-        private final List<Failure<ServletState>> resourceRuntimes = new ArrayList<Failure<ServletState>>();
-        private final List<Failure<ServletState>> errorPageRuntimes = new ArrayList<Failure<ServletState>>();
+        private final List<FailureServletState> servletRuntimes = new ArrayList<FailureServletState>();
+        private final List<FailureFilterState> filterRuntimes = new ArrayList<FailureFilterState>();
+        private final List<FailureServletState> resourceRuntimes = new ArrayList<FailureServletState>();
+        private final List<FailureServletState> errorPageRuntimes = new ArrayList<FailureServletState>();
         private final List<Failure<ServiceReference<?>>> listenerRuntimes = new ArrayList<Failure<ServiceReference<?>>>();
 
         public FailureRuntime.Builder add(Map<AbstractInfo<?>, Integer> failureInfos)
@@ -225,37 +217,91 @@
             return this;
         }
 
-        public FailureRuntime.Builder add(AbstractInfo<?> info, int failureCode)
+        private FailureRuntime.Builder add(final AbstractInfo<?> info, final int failureCode)
         {
             if (info instanceof ServletContextHelperInfo)
             {
-                // TODO
-//                ServletContextHelperRuntime servletRuntime = new InfoServletContextHelperRuntime((ServletContextHelperInfo) info);
-//                contextRuntimes.add(new Failure<ServletContextHelperRuntime>(servletRuntime, failureCode));
+                ServletContextHelperRuntime servletRuntime = new ServletContextHelperRuntime()
+                {
+
+                    @Override
+                    public ServletContext getSharedContext() {
+                        return null;
+                    }
+
+                    @Override
+                    public ServletContextHelperInfo getContextInfo() {
+                        return (ServletContextHelperInfo) info;
+                    }
+
+                    @Override
+                    public ContextRuntime getContextRuntime() {
+                        return null;
+                    }
+
+                    @Override
+                    public Collection<ServiceReference<?>> getListeners() {
+                        return null;
+                    }
+                };
+                contextRuntimes.add(new Failure<ServletContextHelperRuntime>(servletRuntime, failureCode));
             }
-            else if (info instanceof ServletInfo && ((ServletInfo) info).getErrorPage() != null)
+            else if (info instanceof ServletInfo )
             {
-                // TODO
-//                FailureServletState servletRuntime = new FailureServletRuntime((ServletInfo) info);
-//                ErrorPageRuntime errorPageRuntime = ErrorPageRuntime.fromServletRuntime(servletRuntime);
-//                errorPageRuntimes.add(new Failure<ErrorPageRuntime>(errorPageRuntime, failureCode));
-            }
-            else if (info instanceof ServletInfo)
-            {
-                // TODO
-//                ServletState servletRuntime = new FailureServletState((ServletInfo) info);
-//                servletRuntimes.add(new Failure<ServletRuntime>(servletRuntime, failureCode));
+                boolean isError = false;
+                if ( ((ServletInfo) info).getErrorPage() != null)
+                {
+                    isError = true;
+                    final FailureServletState servletRuntime = new FailureServletState((ServletInfo) info, failureCode);
+                    ErrorPageRegistry.ErrorRegistration  reg = ErrorPageRegistry.getErrorRegistration((ServletInfo)info);
+                    if ( !reg.errorCodes.isEmpty() )
+                    {
+                        final long[] codes = new long[reg.errorCodes.size()];
+                        int index = 0;
+                        final Iterator<Long> i = reg.errorCodes.iterator();
+                        while ( i.hasNext() )
+                        {
+                            codes[index++] = i.next();
+                        }
+                        servletRuntime.setErrorCodes(codes);
+                    }
+                    if ( !reg.exceptions.isEmpty() )
+                    {
+                        servletRuntime.setErrorExceptions(reg.exceptions.toArray(new String[reg.exceptions.size()]));
+                    }
+                    errorPageRuntimes.add(servletRuntime);
+                }
+                if ( ((ServletInfo) info).getPatterns() != null || !isError )
+                {
+                    FailureServletState servletRuntime = new FailureServletState((ServletInfo) info, failureCode);
+                    if ( ((ServletInfo) info).getPatterns() != null )
+                    {
+                        servletRuntime.setPatterns(((ServletInfo) info).getPatterns());
+                    }
+                    servletRuntimes.add(servletRuntime);
+                }
             }
             else if (info instanceof FilterInfo)
             {
-                // TODO
-//                FilterState filterRuntime = new FailureFilterState((FilterInfo) info, failureCode);
-//                filterRuntimes.add(new Failure<FilterState>(filterRuntime, failureCode));
+                FailureFilterState filterRuntime = new FailureFilterState() {
+
+                    @Override
+                    public FilterInfo getFilterInfo() {
+                        return (FilterInfo)info;
+                    }
+
+                    @Override
+                    public int getReason() {
+                        return failureCode;
+                    }
+
+                };
+                filterRuntimes.add(filterRuntime);
             }
             else if (info instanceof ResourceInfo)
             {
-//                ServletState servletRuntime = new FailureServletRuntime(new ServletInfo((ResourceInfo) info));
-//                resourceRuntimes.add(new Failure<ServletRuntime>(servletRuntime, failureCode));
+                FailureServletState servletRuntime = new FailureServletState(new ServletInfo((ResourceInfo) info), failureCode);
+                resourceRuntimes.add(servletRuntime);
             }
             else if (info instanceof ListenerInfo)
             {
@@ -273,10 +319,10 @@
         {
             Collections.sort(contextRuntimes, CONTEXT_COMPARATOR);
             Collections.sort(listenerRuntimes, REFERENCE_COMPARATOR);
-            Collections.sort(servletRuntimes, SERVLET_COMPARATOR);
-            Collections.sort(filterRuntimes, FILTER_COMPARATOR);
-            Collections.sort(resourceRuntimes, SERVLET_COMPARATOR);
-            Collections.sort(errorPageRuntimes, ERROR_PAGE_COMPARATOR);
+            Collections.sort(servletRuntimes, FailureServletState.COMPARATOR);
+            Collections.sort(filterRuntimes, FailureFilterState.COMPARATOR);
+            Collections.sort(resourceRuntimes, FailureServletState.COMPARATOR);
+            Collections.sort(errorPageRuntimes, FailureServletState.COMPARATOR);
 
             return new FailureRuntime(contextRuntimes,
                     listenerRuntimes,
diff --git a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/RegistryRuntime.java b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/RegistryRuntime.java
index 08a1341..1c4e6c9 100644
--- a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/RegistryRuntime.java
+++ b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/RegistryRuntime.java
@@ -18,13 +18,7 @@
  */
 package org.apache.felix.http.base.internal.runtime.dto;
 
-import static org.osgi.service.http.whiteboard.HttpWhiteboardConstants.HTTP_WHITEBOARD_DEFAULT_CONTEXT_NAME;
-
 import java.util.Collection;
-import java.util.Collections;
-
-import org.apache.felix.http.base.internal.runtime.dto.state.ServletState;
-import org.osgi.framework.ServiceReference;
 
 public final class RegistryRuntime
 {
@@ -38,61 +32,6 @@
         this.failureRuntime = failureRuntime;
     }
 
-
-
-    public ContextRuntime getHandlerRuntime(ServletContextHelperRuntime contextRuntime)
-    {
-        long serviceId = contextRuntime.getContextInfo().getServiceId();
-/**
-        if (handlerRuntimes.containsKey(serviceId) && isDefaultContext(contextRuntime))
-        {
-            // TODO Merge with the default context of the HttpService ( handlerRuntimes.get(0) )
-            return handlerRuntimes.get(serviceId);
-        }
-        else if (handlerRuntimes.containsKey(serviceId))
-        {
-            return handlerRuntimes.get(serviceId);
-        }**/
-        return null; //ContextRuntime.empty(serviceId);
-    }
-
-    public Collection<ServletState> getServletRuntimes(ServletContextHelperRuntime contextRuntime)
-    {
-        /* TODO
-        if (servletRuntimes.containsKey(contextRuntime.getContextInfo().getServiceId()))
-        {
-            return servletRuntimes.get(contextRuntime.getContextInfo().getServiceId());
-        }
-        */
-        return Collections.emptyList();
-    }
-
-    public Collection<ServletState> getResourceRuntimes(ServletContextHelperRuntime contextRuntime)
-    {
-        /* TODO
-        if (resourceRuntimes.containsKey(contextRuntime.getContextInfo().getServiceId()))
-        {
-            return resourceRuntimes.get(contextRuntime.getContextInfo().getServiceId());
-        }
-        */
-        return Collections.emptyList();
-    }
-
-    private boolean isDefaultContext(ServletContextHelperRuntime contextRuntime)
-    {
-        return contextRuntime.getContextInfo().getName().equals(HTTP_WHITEBOARD_DEFAULT_CONTEXT_NAME);
-    }
-
-    public Collection<ServiceReference<?>> getListenerRuntimes(ServletContextHelperRuntime contextRuntime)
-    {
-        /**
-        if (listenerRuntimes.containsKey(contextRuntime.getContextInfo().getServiceId()))
-        {
-            return listenerRuntimes.get(contextRuntime.getContextInfo().getServiceId());
-        }*/
-        return Collections.emptyList();
-    }
-
     public Collection<ServletContextHelperRuntime> getContexts()
     {
         return contexts;
diff --git a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/RequestInfoDTOBuilder.java b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/RequestInfoDTOBuilder.java
index e27f2c9..7250bdf 100644
--- a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/RequestInfoDTOBuilder.java
+++ b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/RequestInfoDTOBuilder.java
@@ -18,12 +18,9 @@
 
 import static java.util.Arrays.asList;
 
-import javax.servlet.Servlet;
-
 import org.apache.felix.http.base.internal.handler.FilterHandler;
 import org.apache.felix.http.base.internal.registry.HandlerRegistry;
 import org.apache.felix.http.base.internal.registry.PathResolution;
-import org.apache.felix.http.base.internal.runtime.ServletInfo;
 import org.apache.felix.http.base.internal.runtime.dto.state.ServletState;
 import org.osgi.service.http.runtime.dto.FilterDTO;
 import org.osgi.service.http.runtime.dto.RequestInfoDTO;
@@ -56,81 +53,18 @@
         requestInfoDTO.servletContextId = pr.handler.getContextServiceId();
         if (pr.handler.getServletInfo().isResource())
         {
+            final ServletState state = new ServletState(pr.handler);
+            state.setPatterns(pr.handler.getServletInfo().getPatterns());
             requestInfoDTO.resourceDTO = ResourceDTOBuilder.create()
-                    .buildDTO(new ServletState()
-                    {
-
-                        @Override
-                        public ServletInfo getServletInfo()
-                        {
-                            // TODO Auto-generated method stub
-                            return pr.handler.getServletInfo();
-                        }
-
-                        @Override
-                        public Servlet getServlet()
-                        {
-                            // TODO Auto-generated method stub
-                            return pr.handler.getServlet();
-                        }
-
-                        @Override
-                        public String[] getPatterns()
-                        {
-                            return pr.handler.getServletInfo().getPatterns();
-                        }
-
-                        @Override
-                        public String[] getErrorExceptions()
-                        {
-                            return null;
-                        }
-
-                        @Override
-                        public long[] getErrorCodes()
-                        {
-                            return null;
-                        }
-                    },
-
+                    .buildDTO(state,
                             pr.handler.getContextServiceId());
         }
         else
         {
+            final ServletState state = new ServletState(pr.handler);
+            state.setPatterns(pr.handler.getServletInfo().getPatterns());
             requestInfoDTO.servletDTO = ServletDTOBuilder.create()
-                    .buildDTO(new ServletState()
-                    {
-
-                        @Override
-                        public ServletInfo getServletInfo()
-                        {
-                            return pr.handler.getServletInfo();
-                        }
-
-                        @Override
-                        public Servlet getServlet()
-                        {
-                            return pr.handler.getServlet();
-                        }
-
-                        @Override
-                        public String[] getPatterns()
-                        {
-                            return pr.handler.getServletInfo().getPatterns();
-                        }
-
-                        @Override
-                        public String[] getErrorExceptions()
-                        {
-                            return new String[0];
-                        }
-
-                        @Override
-                        public long[] getErrorCodes()
-                        {
-                            return new long[0];
-                        }
-                    }, pr.handler.getContextServiceId());
+                    .buildDTO(state, pr.handler.getContextServiceId());
         }
 
         final FilterHandler[] filterHandlers = registry.getFilters(pr, null, path);
diff --git a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ResourceDTOBuilder.java b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ResourceDTOBuilder.java
index 552e4ef..8aa815c 100644
--- a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ResourceDTOBuilder.java
+++ b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ResourceDTOBuilder.java
@@ -18,6 +18,10 @@
  */
 package org.apache.felix.http.base.internal.runtime.dto;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
 import org.apache.felix.http.base.internal.runtime.ServletInfo;
 import org.apache.felix.http.base.internal.runtime.dto.state.ServletState;
 import org.osgi.service.http.runtime.dto.ResourceDTO;
@@ -35,6 +39,20 @@
     }
 
     @Override
+    Collection<T> build(Collection<? extends ServletState> whiteboardServices,
+            long servletContextId) {
+        List<T> dtoList = new ArrayList<T>();
+        for (ServletState whiteboardService : whiteboardServices)
+        {
+            if ( whiteboardService.getPatterns().length > 0 && whiteboardService.getServletInfo().isResource() )
+            {
+                dtoList.add(buildDTO(whiteboardService, servletContextId));
+            }
+        }
+        return dtoList;
+    }
+
+    @Override
     T buildDTO(ServletState runtime, long servletContextId)
     {
         ServletInfo servletInfo = runtime.getServletInfo();
diff --git a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/RuntimeDTOBuilder.java b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/RuntimeDTOBuilder.java
index e4794b7..ea12e78 100644
--- a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/RuntimeDTOBuilder.java
+++ b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/RuntimeDTOBuilder.java
@@ -22,8 +22,6 @@
 import java.util.HashMap;
 import java.util.Map;
 
-import org.apache.felix.http.base.internal.runtime.dto.state.FilterState;
-import org.apache.felix.http.base.internal.runtime.dto.state.ServletState;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.Constants;
 import org.osgi.framework.ServiceReference;
@@ -102,28 +100,22 @@
         for (final ServletContextHelperRuntime context : contexts)
         {
             result[index++] = createContextDTO(context,
-                    registry.getHandlerRuntime(context),
-                    registry.getServletRuntimes(context),
-                    registry.getResourceRuntimes(context),
-                    registry.getListenerRuntimes(context));
+                    context.getContextRuntime(),
+                    context.getListeners());
         }
         return result;
     }
 
-    private ServletContextDTO createContextDTO(ServletContextHelperRuntime context,
-            ContextRuntime contextRuntime,
-            Collection<ServletState> servletRuntimes,
-            Collection<ServletState> resourceRuntimes,
-            Collection<ServiceReference<?>> listenerRuntimes)
+    private ServletContextDTO createContextDTO(final ServletContextHelperRuntime context,
+            final ContextRuntime contextRuntime,
+            final Collection<ServiceReference<?>> listenerRuntimes)
     {
-        Collection<FilterState> filterRuntimes = contextRuntime.getFilterRuntimes();
-        Collection<ServletState> errorPageRuntimes = contextRuntime.getErrorPageRuntimes();
-        long servletContextId = context.getContextInfo().getServiceId();
+        final long servletContextId = context.getContextInfo().getServiceId();
 
-        Collection<ServletDTO> servletDTOs = ServletDTOBuilder.create().build(servletRuntimes, servletContextId);
-        Collection<ResourceDTO> resourceDTOs = ResourceDTOBuilder.create().build(resourceRuntimes, servletContextId);
-        Collection<FilterDTO> filterDTOs = FilterDTOBuilder.create().build(filterRuntimes, servletContextId);
-        Collection<ErrorPageDTO> errorDTOs = ErrorPageDTOBuilder.create().build(errorPageRuntimes, servletContextId);
+        Collection<ServletDTO> servletDTOs = ServletDTOBuilder.create().build(contextRuntime.getServletRuntimes(), servletContextId);
+        Collection<ResourceDTO> resourceDTOs = ResourceDTOBuilder.create().build(contextRuntime.getServletRuntimes(), servletContextId);
+        Collection<FilterDTO> filterDTOs = FilterDTOBuilder.create().build(contextRuntime.getFilterRuntimes(), servletContextId);
+        Collection<ErrorPageDTO> errorDTOs = ErrorPageDTOBuilder.create().build(contextRuntime.getServletRuntimes(), servletContextId);
         Collection<ListenerDTO> listenerDTOs = ListenerDTOBuilder.create().build(listenerRuntimes, servletContextId);
 
         return new ServletContextDTOBuilder(context,
diff --git a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ServletDTOBuilder.java b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ServletDTOBuilder.java
index 94c8fa9..09dbab9 100644
--- a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ServletDTOBuilder.java
+++ b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/ServletDTOBuilder.java
@@ -18,6 +18,10 @@
  */
 package org.apache.felix.http.base.internal.runtime.dto;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
 import org.apache.felix.http.base.internal.runtime.ServletInfo;
 import org.apache.felix.http.base.internal.runtime.dto.state.ServletState;
 import org.osgi.service.http.runtime.dto.ServletDTO;
@@ -34,6 +38,21 @@
         super(dtoFactory);
     }
 
+
+    @Override
+    Collection<T> build(Collection<? extends ServletState> whiteboardServices,
+            long servletContextId) {
+        List<T> dtoList = new ArrayList<T>();
+        for (ServletState whiteboardService : whiteboardServices)
+        {
+            if ( whiteboardService.getPatterns().length > 0 && !whiteboardService.getServletInfo().isResource() )
+            {
+                dtoList.add(buildDTO(whiteboardService, servletContextId));
+            }
+        }
+        return dtoList;
+    }
+
     @Override
     T buildDTO(ServletState servletRuntime, long servletContextId)
     {
diff --git a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/state/FailureFilterState.java b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/state/FailureFilterState.java
index 7147f04..918a7dd 100644
--- a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/state/FailureFilterState.java
+++ b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/state/FailureFilterState.java
@@ -21,5 +21,5 @@
 
 public interface FailureFilterState extends FilterState {
 
-    long getReason();
+    int getReason();
 }
diff --git a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/state/FailureServletState.java b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/state/FailureServletState.java
index d2ce336..4d1d8f0 100644
--- a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/state/FailureServletState.java
+++ b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/state/FailureServletState.java
@@ -18,8 +18,27 @@
  */
 package org.apache.felix.http.base.internal.runtime.dto.state;
 
+import org.apache.felix.http.base.internal.handler.ServletHandler;
+import org.apache.felix.http.base.internal.runtime.ServletInfo;
 
-public interface FailureServletState extends ServletState
+
+public class FailureServletState extends ServletState
 {
-    long getReason();
+    private final int reason;
+
+    public FailureServletState(final ServletHandler handler, final int reason)
+    {
+        super(handler);
+        this.reason = reason;
+    }
+
+    public FailureServletState(final ServletInfo info, final int reason)
+    {
+        super(info);
+        this.reason = reason;
+    }
+
+    public int getReason() {
+        return reason;
+    }
 }
diff --git a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/state/ServletState.java b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/state/ServletState.java
index 517dd81..9a53d16 100644
--- a/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/state/ServletState.java
+++ b/http/base/src/main/java/org/apache/felix/http/base/internal/runtime/dto/state/ServletState.java
@@ -22,11 +22,15 @@
 
 import javax.servlet.Servlet;
 
+import org.apache.felix.http.base.internal.handler.ServletHandler;
 import org.apache.felix.http.base.internal.runtime.ServletInfo;
 
-public interface ServletState
+public class ServletState
 {
-    static final Comparator<ServletState> COMPARATOR = new Comparator<ServletState>()
+    private static final String[] EMPTY_STRING_ARRAY = new String[0];
+    private static final long[] EMPTY_LONG_ARRAY = new long[0];
+
+    public static final Comparator<ServletState> COMPARATOR = new Comparator<ServletState>()
     {
         @Override
         public int compare(ServletState o1, ServletState o2)
@@ -35,13 +39,65 @@
         }
     };
 
-    Servlet getServlet();
+    private final ServletHandler handler;
 
-    ServletInfo getServletInfo();
+    private final ServletInfo info;
 
-    String[] getPatterns();
+    private String[] patterns = EMPTY_STRING_ARRAY;
 
-    long[] getErrorCodes();
+    private String[] exceptions = EMPTY_STRING_ARRAY;
 
-    String[] getErrorExceptions();
+    private long[] errorCodes = EMPTY_LONG_ARRAY;
+
+    public ServletState(final ServletHandler handler)
+    {
+        this.handler = handler;
+        this.info = handler.getServletInfo();
+    }
+
+    public ServletState(final ServletInfo info)
+    {
+        this.handler = null;
+        this.info = info;
+    }
+
+    public Servlet getServlet()
+    {
+        return (handler != null ? this.handler.getServlet() : null);
+    }
+
+    public ServletInfo getServletInfo()
+    {
+        return this.info;
+    }
+
+    public String[] getPatterns()
+    {
+        return this.patterns;
+    }
+
+    public long[] getErrorCodes()
+    {
+        return this.errorCodes;
+    }
+
+    public String[] getErrorExceptions()
+    {
+        return this.exceptions;
+    }
+
+    public void setPatterns(final String[] value)
+    {
+        this.patterns = value;
+    }
+
+    public void setErrorCodes(final long[] value)
+    {
+        this.errorCodes = value;
+    }
+
+    public void setErrorExceptions(final String[] value)
+    {
+        this.exceptions = value;
+    }
 }
diff --git a/http/base/src/test/java/org/apache/felix/http/base/internal/runtime/WhiteboardServiceHelper.java b/http/base/src/test/java/org/apache/felix/http/base/internal/runtime/WhiteboardServiceHelper.java
index 48b8668..f2486f0 100644
--- a/http/base/src/test/java/org/apache/felix/http/base/internal/runtime/WhiteboardServiceHelper.java
+++ b/http/base/src/test/java/org/apache/felix/http/base/internal/runtime/WhiteboardServiceHelper.java
@@ -98,19 +98,19 @@
         return info;
     }
 
-    public static ServletState createTestServletWithServiceId(String identifier,
+    public static ServletHandler createTestServletWithServiceId(String identifier,
             ExtServletContext context,
             long contextServiceId)
     {
         return createTestServlet(identifier, context, ID_COUNTER.incrementAndGet(), contextServiceId);
     }
 
-    public static ServletState createTestServlet(String identifier, ExtServletContext context, long contextServiceId)
+    public static ServletHandler createTestServlet(String identifier, ExtServletContext context, long contextServiceId)
     {
         return createTestServlet(identifier, context, -ID_COUNTER.incrementAndGet(), contextServiceId);
     }
 
-    private static ServletState createTestServlet(String identifier,
+    private static ServletHandler createTestServlet(String identifier,
             ExtServletContext context,
             Long serviceId,
             Long contextServiceId)
@@ -120,33 +120,7 @@
         when(servlet.getServletInfo()).thenReturn("info_" + identifier);
         final ServletHandler h = new HttpServiceServletHandler(contextServiceId, context, servletInfo, servlet);
 
-        return new ServletState() {
-
-            @Override
-            public ServletInfo getServletInfo() {
-                return h.getServletInfo();
-            }
-
-            @Override
-            public Servlet getServlet() {
-                return h.getServlet();
-            }
-
-            @Override
-            public String[] getPatterns() {
-                return h.getServletInfo().getPatterns();
-            }
-
-            @Override
-            public String[] getErrorExceptions() {
-                return null;
-            }
-
-            @Override
-            public long[] getErrorCodes() {
-                return null;
-            }
-        };
+        return h;
     }
 
     private static ServletInfo createServletInfo(String identifier, Long serviceId)
@@ -202,49 +176,20 @@
             Long serviceId,
             long contextServiceId)
     {
-        final ServletState servletHandler = createTestServlet(identifier, context, serviceId, contextServiceId);
+        final ServletHandler servletHandler = createTestServlet(identifier, context, serviceId, contextServiceId);
         final Collection<Long> errorCodes = Arrays.asList(400L, 500L);
         final Collection<String> exceptions = Arrays.asList("Bad request", "Error");
 
-        return new ServletState()
+        final ServletState state = new ServletState(servletHandler);
+        final long[] codes = new long[errorCodes.size()];
+        final Iterator<Long> iter = errorCodes.iterator();
+        for(int i=0; i<codes.length; i++)
         {
-
-            @Override
-            public ServletInfo getServletInfo()
-            {
-                return servletHandler.getServletInfo();
-            }
-
-            @Override
-            public Servlet getServlet()
-            {
-                return servletHandler.getServlet();
-            }
-
-            @Override
-            public String[] getPatterns()
-            {
-                return servletHandler.getPatterns();
-            }
-
-            @Override
-            public String[] getErrorExceptions()
-            {
-                return exceptions.toArray(new String[1]);
-            }
-
-            @Override
-            public long[] getErrorCodes()
-            {
-                final long[] codes = new long[errorCodes.size()];
-                final Iterator<Long> iter = errorCodes.iterator();
-                for(int i=0; i<codes.length; i++)
-                {
-                    codes[i] = iter.next();
-                }
-                return codes;
-            }
-        };
+            codes[i] = iter.next();
+        }
+        state.setErrorCodes(codes);
+        state.setErrorExceptions(exceptions.toArray(new String[exceptions.size()]));
+        return state;
     }
 
     public static ServletContextHelperInfo createContextInfo(int serviceRanking,
diff --git a/http/base/src/test/java/org/apache/felix/http/base/internal/runtime/dto/RuntimeDTOBuilderTest.java b/http/base/src/test/java/org/apache/felix/http/base/internal/runtime/dto/RuntimeDTOBuilderTest.java
index 30320f6..9ec1314 100644
--- a/http/base/src/test/java/org/apache/felix/http/base/internal/runtime/dto/RuntimeDTOBuilderTest.java
+++ b/http/base/src/test/java/org/apache/felix/http/base/internal/runtime/dto/RuntimeDTOBuilderTest.java
@@ -243,20 +243,20 @@
         ServletContextHelperRuntime contextHelper_A = setupContext(context_A, "A", ID_A);
         ServletContextHelperRuntime contextHelper_B = setupContext(context_B, "B", ID_B);
 
-        List<ServletState> servlets = new ArrayList<ServletState>();
-        List<ServletState> resources = new ArrayList<ServletState>();
+        List<ServletHandler> servlets = new ArrayList<ServletHandler>();
+        List<ServletHandler> resources = new ArrayList<ServletHandler>();
 
         servlets.add(createTestServlet("1", context_0, ID_0));
         resources.add(createTestServlet("1", context_0, ID_0));
         List<FilterState> filters_0 = asList(createTestFilter("1", context_0));
         List<ServletState> errorPages_0 = asList(createErrorPage("E_1", context_0, ID_0));
-        ContextRuntime contextRuntime_0 = new ContextRuntime(filters_0, errorPages_0, null, null, null, null, null, null);
+        ContextRuntime contextRuntime_0 = new ContextRuntime(filters_0, errorPages_0, null, null);
 
         servlets.add(createTestServlet("A_1", context_A, ID_A));
         resources.add(createTestServlet("A_1", context_A, ID_A));
         List<FilterState> filters_A = asList(createTestFilter("A_1", context_A));
         List<ServletState> errorPages_A = asList(createErrorPage("E_A_1", context_A, ID_A));
-        ContextRuntime contextRuntime_A = new ContextRuntime(filters_A, errorPages_A, null, null, null, null, null, null);
+        ContextRuntime contextRuntime_A = new ContextRuntime(filters_A, errorPages_A, null, null);
 
         servlets.addAll(asList(createTestServletWithServiceId("B_1", context_B, ID_B),
                 createTestServletWithServiceId("B_2", context_B, ID_B)));
@@ -266,7 +266,7 @@
                 createTestFilterWithServiceId("B_2", context_B));
         List<ServletState> errorPages_B = asList(createErrorPageWithServiceId("E_B_1", context_B, ID_B),
                 createErrorPageWithServiceId("E_B_2", context_B, ID_B));
-        ContextRuntime contextRuntime_B = new ContextRuntime(filters_B, errorPages_B, null, null, null, null, null, null);
+        ContextRuntime contextRuntime_B = new ContextRuntime(filters_B, errorPages_B, null, null);
 
         Map<Long, Collection<ServiceReference<?>>> listenerRuntimes = setupListeners();
 
@@ -274,7 +274,7 @@
                 asList(contextRuntime_0, contextRuntime_A, contextRuntime_B),
 //                new ServletRegistryRuntime(servlets, resources),
                 listenerRuntimes,
-                FailureRuntime.empty());
+                null);
 
         RuntimeDTO runtimeDTO = new RuntimeDTOBuilder(registry, runtimeReference).build();
 
@@ -617,12 +617,11 @@
 
         ContextRuntime contextRuntime = new ContextRuntime(asList(filterHandler),
                 Collections.<ServletState>emptyList(),
-                null, null,
-                null, null, null, null);
+                null, null);
         setupRegistry(asList(contextHandler), asList(contextRuntime),
 //                new ServletRegistryRuntime(asList(resourceHandler), asList(servletHandler)),
                 Collections.<Long, Collection<ServiceReference<?>>>emptyMap(),
-                FailureRuntime.empty());
+                null);
 
         RuntimeDTO runtimeDTO = new RuntimeDTOBuilder(registry, runtimeReference).build();
 
@@ -646,7 +645,7 @@
         setupRegistry(asList(contextHandler_0, contextHandler_A),
 null, //                asList(ContextRuntime.empty(ID_0), ContextRuntime.empty(ID_A)),
                 Collections.<Long, Collection<ServiceReference<?>>>emptyMap(),
-                FailureRuntime.empty());
+                null);
 
         RuntimeDTO runtimeDTO = new RuntimeDTOBuilder(registry, runtimeReference).build();
 
@@ -678,12 +677,11 @@
 
         ContextRuntime contextRuntime = new ContextRuntime(Collections.<FilterState>emptyList(),
                 Collections.<ServletState>emptyList(),
-                null, null,
-                null, null, null, null);
+                null, null);
         setupRegistry(asList(contextHandler), asList(contextRuntime),
 //                new ServletRegistryRuntime(asList(servletHandler), Collections.<ServletRuntime>emptyList()),
                 Collections.<Long, Collection<ServiceReference<?>>>emptyMap(),
-                FailureRuntime.empty());
+                null);
 
         new RuntimeDTOBuilder(registry, runtimeReference).build();
     }