docs: @Override
      protected void service( HttpServletRequest req,
                              HttpServletResponse resp ) throws ServletException, IOException {
  
          String methodName = req.getMethod();
          ITransaction transaction = null;
          boolean needRollback = false;
  
          if (LOG.isTraceEnabled()) {
              debugRequest(methodName, req);
          }
  
          try {
              Principal userPrincipal = req.getUserPrincipal();
              transaction = store.begin(userPrincipal);
              needRollback = true;
              store.checkAuthentication(transaction);
              resp.setStatus(WebdavStatus.SC_OK);
  
              try {
                  IMethodExecutor methodExecutor = methodMap.get(methodName);
                  if (methodExecutor == null) {
                      methodExecutor = methodMap.get("*NO*IMPL*");
                  }
  
                  methodExecutor.execute(transaction, req, resp);
  
                  store.commit(transaction);
                  /**
                   * Clear not consumed data Clear input stream if available otherwise later access include current input. These
                   * cases occure if the client sends a request with body to an not existing resource.
                   */
                  if (RequestUtil.streamNotConsumed(req)) {
                      if (LOG.isTraceEnabled()) {
                          LOG.trace("Clear not consumed data!");
                      }
                      try {
                          while (req.getInputStream().available() > 0) {
                              req.getInputStream().read();
                          }
                      } catch (IOException e) {
                          //ignore
                      }
                  }
                  needRollback = false;
              } catch (IOException e) {
                  LOG.error(e, new TextI18n("IOException"));
                  resp.sendError(WebdavStatus.SC_INTERNAL_SERVER_ERROR);
                  store.rollback(transaction);
                  throw new ServletException(e);
              }
  
          } catch (UnauthenticatedException e) {
              resp.sendError(WebdavStatus.SC_FORBIDDEN);
          } catch (AccessDeniedException e) {
              resp.sendError(WebdavStatus.SC_FORBIDDEN);
          } catch (LockFailedException e) {
              resp.sendError(WebdavStatus.SC_INTERNAL_SERVER_ERROR);
          } catch (ObjectAlreadyExistsException e) {
              resp.sendError(WebdavStatus.SC_PRECONDITION_FAILED);
          } catch (ObjectNotFoundException e) {
              resp.sendError(WebdavStatus.SC_NOT_FOUND);
          } catch (WebdavException e) {
              throw new ServletException(e);
          } catch (Throwable t) {
              t = translate(t);
              if (t instanceof UnauthenticatedException) {
                  resp.sendError(WebdavStatus.SC_FORBIDDEN);
              } else if (t instanceof AccessDeniedException) {
                  resp.sendError(WebdavStatus.SC_FORBIDDEN);
              } else if (t instanceof LockFailedException) {
                  resp.sendError(WebdavStatus.SC_INTERNAL_SERVER_ERROR);
              } else if (t instanceof ObjectAlreadyExistsException) {
                  resp.sendError(WebdavStatus.SC_PRECONDITION_FAILED);
              } else if (t instanceof ObjectNotFoundException) {
                  resp.sendError(WebdavStatus.SC_NOT_FOUND);
              } else if (t instanceof WebdavException) {
                  throw new ServletException(t);
              } else {
                  throw new ServletException(t);
              }
          } finally {
              if (needRollback) {
                  store.rollback(transaction);
              }
          }
      }