Execute this transaction.

@param scope The server scope.
@param req The request created for the exec command.
@param res The response created for the exec command.
10168
function exec(scope, req, res) {
  var replies = [], item;

  // NOTE: incrby invalid amount will trigger EXECABORT
  // NOTE: wrong number of args are returned to the client
  // NOTE: but other types of validation errors (argument type coercion)
  // NOTE: trigger EXECABORT

  if(this.error) return this.destroy(req, res, ExecAbort);
  if(this.conflict) return this.destroy(req, res, null, null);

  function onReply(err, reply) {
    replies.push(err || reply);
  }

  onReply = onReply.bind(this);

  // fifo queue, maintain order
  while((item = this.queue.shift()) !== undefined) {
    if(item.err) {
      replies.push(item.err);
    }else{
      item.res.cb = onReply;

      // execute via the server so that these command
      // executions are included in slowlog/monitor
      scope.execute(item.req.exec, item.req, item.res);
    }
  }

  // reply and destroy this transaction
  this.destroy(req, res, null, replies);
}
863752
@Override
  public final void handle(final Map<String, Object> pReqVars,
    final IRequestData pRequestData) throws Exception {
    String processorName = pRequestData.getParameter("nmPrc");
    if (processorName == null) {
      //WHandlerAndJsp requires handle NULL request:
      return;
    }
    try {
      this.srvDatabase.setIsAutocommit(false);
      this.srvDatabase.setTransactionIsolation(this.writeReTi);
      this.srvDatabase.beginTransaction();
      IProcessor proc = this.processorsFactory.lazyGet(pReqVars, processorName);
      proc.process(pReqVars, pRequestData);
      this.srvDatabase.commitTransaction();
    } catch (Exception ex) {
      if (!this.srvDatabase.getIsAutocommit()) {
        this.srvDatabase.rollBackTransaction();
      }
      throw ex;
    } finally {
      this.srvDatabase.releaseResources();
    }
  }
644197
private Response act(final Request req, final Identity identity)
        throws IOException {
        Request wrap = new RqWithoutHeader(req, this.header);
        if (!identity.equals(Identity.ANONYMOUS)) {
            wrap = new RqWithAuth(identity, this.header, wrap);
        }
        return this.pass.exit(this.origin.act(wrap), identity);
    }
802278
function execute(req, res) {
  Persistence.save(this.state.store, this.state.conf);
  res.send(null, Constants.OK);
}
961963
function execute(req, res) {
  if(req.args.length) return res.send(null, req.args[0]);
  res.send(null, Constants.PONG);
}
449705
public void doProcess(HttpServletRequest req, HttpServletResponse res) 
        throws ServletException, IOException
    {
        ServletTask servletTask = new ServletTask(this, BasicServlet.SERVLET_TYPE.HTML);
        try {
            this.addBrowserProperties(req, servletTask);
            servletTask.doProcess(this, req, res, null);
        } catch (ServletException e) {
            throw e;
        } catch (IOException e) {
            throw e;
        } finally {
            servletTask.free();
        }
    }
809691
protected <T, A> AsyncFuture<T> executeRequest(final ManagementRequest<T, A> request, final Channel channel, final ActiveOperation<T, A> support) {
        assert support != null;
        updateChannelRef(support, channel);
        final Integer requestId = this.requestID.incrementAndGet();
        final ActiveRequest<T, A> ar = new ActiveRequest<T, A>(support, request);
        requests.put(requestId, ar);
        final ManagementRequestHeader header = new ManagementRequestHeader(ManagementProtocol.VERSION, requestId, support.getOperationId(), request.getOperationType());
        final ActiveOperation.ResultHandler<T> resultHandler = support.getResultHandler();
        try {
            request.sendRequest(resultHandler, new ManagementRequestContextImpl<T, A>(support, channel, header, getExecutor()));
        } catch (Exception e) {
            resultHandler.failed(e);
            requests.remove(requestId);
        }
        return support.getResult();
    }
144948
private void executePutOperation(HttpServletRequest request, HttpServletResponse response)
        throws IOException, ClassNotFoundException {
        if (request.getContentLength() > 0) {
            ObjectInputStream input = new ObjectInputStream(new BufferedInputStream(request.getInputStream()));
            CommandPayload payload = (CommandPayload) input.readObject();
            Command operation = payload.getCommand();
            Manager manager = (Manager) request.getAttribute(ARQUILLIAN_MANAGER_ATTRIBUTE);
            // execute remote Event
            try {
                manager.fire(new ActivateManager(manager));
                manager.inject(operation);
                operation.perform();
                manager.fire(new PassivateManager(manager));
            } catch (Throwable e) {
                payload.setThrowable(e);
            }
            response.setStatus(HttpServletResponse.SC_OK);
            ObjectOutputStream output = new ObjectOutputStream(response.getOutputStream());
            output.writeObject(payload);
            output.flush();
            output.close();
        } else {
            response.setStatus(HttpServletResponse.SC_NO_CONTENT);
        }
    }
752779
private OperationResponse executeForResult(final OperationExecutionContext executionContext) throws IOException {
        try {
            return execute(executionContext).get();
        } catch(Exception e) {
            throw new IOException(e);
        }
    }
278390
@Override
    public T execute() throws Auth0Exception {
        okhttp3.Request request = createRequest();
        try (Response response = client.newCall(request).execute()) {
            return parseResponse(response);
        } catch (Auth0Exception e) {
            throw e;
        } catch (IOException e) {
            throw new Auth0Exception("Failed to execute request", e);
        }
    }
33651
def exec_after_request_actions(actions, response, **kwargs):
    
    current_context["response"] = response
    groups = ("after_" + flask.request.method.lower(), "after")
    try:
        rv = execute_actions(actions, limit_groups=groups, **kwargs)
    except ReturnValueException as e:
        rv = e.value
    if rv:
        return rv
    return response
307056
def execline(scope, data):
    
    conn = scope.get('__connection__')
    response = []
    for line in data:
        conn.execute(line)
        response += conn.response.split('\n')[1:]
    scope.define(__response__=response)
    return True
1101173
public final boolean handle(HttpServletRequest req, HttpServletResponse res, String target) {
		final String method = req.getMethod();
		if (HuluSetting.isDevMode) {
			log.debug("Client [{}] {} [{}]", HttpUtil.getClientIP(req), method, target);
		}

		final ActionMethod actionMethod = actionMapping.getActionMethod(target);
		if (actionMethod == null || actionMethod.isHttpMethodMatch(method) == false) {
			//无对应的Action或者Http方法不匹配，跳过执行后续过程
			return false;
		}
		
		//找到对应的ActionMethod后注入ServletRequst和ServletResponse
		//在此阶段注入的目的是提升性能，避免没有匹配的ActionMethod依旧注入的问题
		fillReqAndRes(req, res);

		//重置过滤器执行游标，从第一个过滤器开始执行
		actionMethod.resetInterceptorPosition();
		try {
			actionMethod.invoke();
		} catch (ActionException e) {
			Render.renderError500(e.getCause());
		}finally{
			clearReqAndRes();
		}

		return true;
	}
190012
public void sendData(Object req, Object res)
        throws Exception, IOException
    {
        this.sendData((HttpServletRequest)req, (HttpServletResponse)res);
    }
37468
@CommandHandler
    public void handle(RequestStopTransactionAcceptedCommand command) {
        apply(new RequestStopTransactionAcceptedEvent(command.getChargingStationId(), command.getTransactionId(), command.getIdentityContext()));
    }
348819
public void doProcess(HttpServletRequest req, HttpServletResponse res) 
        throws ServletException, IOException
    {
        try {
            res.setDateHeader("Expires", 0);        // Make sure the browser never caches these requests
            res.setHeader("Pragma", "No-cache");
            res.setHeader("Cache-Control", "no-cache");
            m_servletTask.doProcess(this, req, res, null);
        } catch (Throwable ex)  {
            ex.printStackTrace();
        }
    }
486805
public CompletableFuture<ExecuteResponse> execute(ExecuteRequest request) {
    logRequest(request);
    return CompletableFuture.completedFuture(logResponse(ExecuteResponse.error()));
  }