/** * @todo Implement testGet(). */ public function testGet() { $response = $this->presta->uri('http://example.com')->get(); $entity_body = $response->entity_body; $this->assertTrue(!empty($entity_body), "No Entity Body returned"); $this->assertTrue($response->status_code == '200', "Response code expected 200, found [" . $response->header('status_code') . "]"); }
/** * Sends the HTTP message [Request] to a remote server and processes * the response. * * @param Request $request request to send * @param Response $request response to send * @return Response */ public function _send_message(Request $request, Response $response) { $http_method_mapping = array(HTTP_Request::GET => HTTPRequest::METH_GET, HTTP_Request::HEAD => HTTPRequest::METH_HEAD, HTTP_Request::POST => HTTPRequest::METH_POST, HTTP_Request::PUT => HTTPRequest::METH_PUT, HTTP_Request::DELETE => HTTPRequest::METH_DELETE, HTTP_Request::OPTIONS => HTTPRequest::METH_OPTIONS, HTTP_Request::TRACE => HTTPRequest::METH_TRACE, HTTP_Request::CONNECT => HTTPRequest::METH_CONNECT); // Create an http request object $http_request = new HTTPRequest($request->uri(), $http_method_mapping[$request->method()]); if ($this->_options) { // Set custom options $http_request->setOptions($this->_options); } // Set headers $http_request->setHeaders($request->headers()->getArrayCopy()); // Set cookies $http_request->setCookies($request->cookie()); // Set query data (?foo=bar&bar=foo) $http_request->setQueryData($request->query()); // Set the body if ($request->method() == HTTP_Request::PUT) { $http_request->addPutData($request->body()); } else { $http_request->setBody($request->body()); } try { $http_request->send(); } catch (HTTPRequestException $e) { throw new Request_Exception($e->getMessage()); } catch (HTTPMalformedHeaderException $e) { throw new Request_Exception($e->getMessage()); } catch (HTTPEncodingException $e) { throw new Request_Exception($e->getMessage()); } // Build the response $response->status($http_request->getResponseCode())->headers($http_request->getResponseHeader())->cookie($http_request->getResponseCookies())->body($http_request->getResponseBody()); return $response; }
public function __construct() { parent::__construct(); if (Request::uri() !== 'ajax/project/issue_upload_attachment') { $this->filter('before', 'auth'); } }
public static function render($template, $data = array()) { // get default theme $theme = Config::get('metadata.theme'); // load global theming functions but not for the admin template if (strpos(static::$path, 'system/admin/theme') === false) { $includes = array('articles', 'comments', 'config', 'helpers', 'menus', 'metadata', 'pages', 'posts', 'search', 'users'); foreach ($includes as $file) { require PATH . 'system/functions/' . $file . '.php'; } } // load theme functions if (file_exists(static::$path . 'functions.php')) { require static::$path . 'functions.php'; } // render files foreach (array('includes/header', $template, 'includes/footer') as $file) { $filepath = static::$path . $file . '.php'; // Nasty hack, but hey, we've got custom pages now. if ($file === 'page' and file_exists(static::$path . Request::uri() . '.php') !== false) { $filepath = static::$path . Request::uri() . '.php'; } if (file_exists($filepath) === false) { throw new ErrorException('Theme file <strong>themes/' . $theme . '/' . $file . '.php</strong> not found.'); } static::parse($filepath, $data); } }
public function execute(Request $request) { if ($this->callback_depth() > $this->max_callback_depth()) { throw new Request_Client_Recursion_Exception("Could not execute request to :uri - too many recursions after :depth requests", array(":uri" => $request->uri(), ":depth" => $this->callback_depth() - 1)); } $orig_response = $response = Response::factory(array("_protocol" => $request->protocol())); if (($cache = $this->cache()) instanceof HTTP_Cache) { return $cache->execute($this, $request, $response); } $response = $this->execute_request($request, $response); foreach ($this->header_callbacks() as $header => $callback) { if ($response->headers($header)) { $cb_result = call_user_func($callback, $request, $response, $this); if ($cb_result instanceof Request) { $this->assign_client_properties($cb_result->client()); $cb_result->client()->callback_depth($this->callback_depth() + 1); $response = $cb_result->execute(); } elseif ($cb_result instanceof Response) { $response = $cb_result; } if ($response !== $orig_response) { break; } } } return $response; }
private static function parse() { // get uri $uri = Request::uri(); // lets log our initial uri Log::info('Requested URI: ' . $uri); // route definitions $routes = array(); // posts host page if ($page = IoC::resolve('posts_page')) { $routes[$page->slug . '/(:any)'] = 'article/$1'; } // fallback to 'admin' $admin_folder = Config::get('application.admin_folder', 'admin'); // static routes $routes = array_merge($routes, array($admin_folder . '/(:any)/(:any)/(:any)' => 'admin/$1/$2/$3', $admin_folder . '/(:any)/(:any)' => 'admin/$1/$2', $admin_folder . '/(:any)' => 'admin/$1', $admin_folder => 'admin', 'search/(:any)' => 'search/$1', 'search' => 'search', 'rss' => 'rss', '(:any)' => 'page/$1')); // define wild-cards $search = array(':any', ':num'); $replace = array('[0-9a-zA-Z~%\\.:_\\-]+', '[0-9]+'); // parse routes foreach ($routes as $route => $translated) { // replace wildcards $route = str_replace($search, $replace, $route); // look for matches if (preg_match('#^' . $route . '#', $uri, $matches)) { // replace matched values foreach ($matches as $k => $match) { $translated = str_replace('$' . $k, $match, $translated); } // return on first match return $translated; } } return $uri; }
/** * Basic cache key generator that hashes the entire request and returns * it. This is fine for static content, or dynamic content where user * specific information is encoded into the request. * * // Generate cache key * $cache_key = HTTP_Cache::basic_cache_key_generator($request); * * @param Request $request * @return string */ public static function basic_cache_key_generator(Request $request) { $uri = $request->uri(); $query = $request->query(); $headers = $request->headers()->getArrayCopy(); $body = $request->body(); return sha1($uri . '?' . http_build_query($query, NULL, '&') . '~' . implode('~', $headers) . '~' . $body); }
function __construct() { echo 'Install::App started!<br>'; echo Request::uri(); echo '?page=', Request::get('page', 1, false); $layout = Responce::layout('start'); $layout->title('Test page!'); }
public function __construct(Request $request) { // Delete the authorization cookie::delete('authorized'); // Redirect to the login page $request->redirect(url::site($request->uri(array('controller' => NULL)))); // Do not call anything here, redirect has already halted execution. }
/** * Sends the HTTP message [Request] to a remote server and processes * the response. * * @param Request request to send * @return Response */ public function _send_message(Request $request) { // Response headers $response_headers = array(); // Set the request method $options[CURLOPT_CUSTOMREQUEST] = $request->method(); // Set the request body. This is perfectly legal in CURL even // if using a request other than POST. PUT does support this method // and DOES NOT require writing data to disk before putting it, if // reading the PHP docs you may have got that impression. SdF $options[CURLOPT_POSTFIELDS] = $request->body(); // Process headers if ($headers = $request->headers()) { $http_headers = array(); foreach ($headers as $key => $value) { $http_headers[] = $key . ': ' . $value; } $options[CURLOPT_HTTPHEADER] = $http_headers; } // Process cookies if ($cookies = $request->cookie()) { $options[CURLOPT_COOKIE] = http_build_query($cookies, NULL, '; '); } // Create response $response = $request->create_response(); $response_header = $response->headers(); // Implement the standard parsing parameters $options[CURLOPT_HEADERFUNCTION] = array($response_header, 'parse_header_string'); $this->_options[CURLOPT_RETURNTRANSFER] = TRUE; $this->_options[CURLOPT_HEADER] = FALSE; // Apply any additional options set to $options += $this->_options; $uri = $request->uri(); if ($query = $request->query()) { $uri .= '?' . http_build_query($query, NULL, '&'); } // Open a new remote connection $curl = curl_init($uri); // Set connection options if (!curl_setopt_array($curl, $options)) { throw new Request_Exception('Failed to set CURL options, check CURL documentation: :url', array(':url' => 'http://php.net/curl_setopt_array')); } // Get the response body $body = curl_exec($curl); // Get the response information $code = curl_getinfo($curl, CURLINFO_HTTP_CODE); if ($body === FALSE) { $error = curl_error($curl); } // Close the connection curl_close($curl); if (isset($error)) { throw new Request_Exception('Error fetching remote :url [ status :code ] :error', array(':url' => $request->url(), ':code' => $code, ':error' => $error)); } $response->status($code)->body($body); return $response; }
public static function call($name = '') { $page = basename(Request::uri()); if (empty($name)) { $name = 'main'; } if ($func = isset(static::$stack[$page][$name]) ? static::$stack[$page][$name] : false) { return is_callable($func) ? $func() : ''; } return ''; }
/** * Calculate the signature of a request. * Should be called just before the request is sent. * * @param Request $request * @param $private_key * @return string Calculated HMAC */ public static function calculate_hmac(Request $request, $private_key) { // Consolidate data that's not in the main route (params) $query = array_change_key_case($request->query()); $post = array_change_key_case($request->post()); // Sort alphabetically ksort($query); ksort($post); $data_to_sign = ['method' => $request->method(), 'uri' => $request->uri(), 'post' => $post, 'query' => $query]; // Calculate the signature return hash_hmac('sha256', json_encode($data_to_sign), $private_key); }
/** * Tests if the route matches a given URI. A successful match will return * all of the routed parameters as an array. A failed match will return * boolean FALSE. * * // Params: controller = users, action = edit, id = 10 * $params = $route->matches('users/edit/10'); * * This method should almost always be used within an if/else block: * * if ($params = $route->matches($uri)) * { * // Parse the parameters * } * * @param string $uri URI to match * @return array on success * @return FALSE on failure */ public function matches(Request $request) { // Get the URI from the Request $uri = trim($request->uri(), '/'); if (!preg_match($this->_route_regex, $uri, $matches)) { return FALSE; } $params = array(); foreach ($matches as $key => $value) { if (is_int($key)) { // Skip all unnamed keys continue; } // Set the value for all matched keys $params[$key] = $value; //<--- // added by Yuna if (is_array($this->_retain) and in_array($key, $this->_retain) && $value != '') { // Value should be retained; add it to the _uri_defaults $this->_uri_defaults[$key] = $value; } //--> } foreach ($this->_defaults as $key => $value) { if (!isset($params[$key]) or $params[$key] === '') { // Set default values for any key that was not matched $params[$key] = $value; } } if (!empty($params['controller'])) { // PSR-0: Replace underscores with spaces, run ucwords, then replace underscore $params['controller'] = str_replace(' ', '_', ucwords(str_replace('_', ' ', $params['controller']))); } if (!empty($params['directory'])) { // PSR-0: Replace underscores with spaces, run ucwords, then replace underscore $params['directory'] = str_replace(' ', '_', ucwords(str_replace('_', ' ', $params['directory']))); } if ($this->_filters) { foreach ($this->_filters as $callback) { // Execute the filter giving it the route, params, and request $return = call_user_func($callback, $this, $params, $request); if ($return === FALSE) { // Filter has aborted the match return FALSE; } elseif (is_array($return)) { // Filter has modified the parameters $params = $return; } } } return $params; }
/** * Open a HTML form. * * @param string $action * @param string $method * @param array $attributes * @param bool $https * @return string */ public static function open($action = null, $method = 'POST', $attributes = array(), $https = false) { $attributes['action'] = HTML::entities(URL::to(is_null($action) ? Request::uri() : $action, $https)); // PUT and DELETE methods are spoofed using a hidden field containing the request method. // Since, HTML does not support PUT and DELETE on forms, we will use POST. $attributes['method'] = ($method == 'PUT' or $method == 'DELETE') ? 'POST' : $method; if (!array_key_exists('accept-charset', $attributes)) { $attributes['accept-charset'] = Config::get('application.encoding'); } $html = '<form' . HTML::attributes($attributes) . '>'; if ($method == 'PUT' or $method == 'DELETE') { $html .= PHP_EOL . static::input('hidden', 'REQUEST_METHOD', $method); } return $html . PHP_EOL; }
public static function extend($page) { if (is_array($page)) { $pages = array(); foreach ($page as $itm) { $pages[] = static::extend($itm); } return $pages; } if (is_object($page)) { $uri = Request::uri(); $page->url = Url::make($page->slug); $page->active = strlen($uri) ? strpos($uri, $page->slug) !== false : $page->slug === 'posts'; return $page; } return false; }
/** * Sends the HTTP message [Request] to a remote server and processes * the response. * * @param Request request to send * @return Response * @uses [PHP cURL](http://php.net/manual/en/book.curl.php) */ public function _send_message(Request $request) { // Calculate stream mode $mode = $request->method() === HTTP_Request::GET ? 'r' : 'r+'; // Process cookies if ($cookies = $request->cookie()) { $request->headers('cookie', http_build_query($cookies, NULL, '; ')); } // Get the message body $body = $request->body(); if (is_resource($body)) { $body = stream_get_contents($body); } // Set the content length $request->headers('content-length', (string) strlen($body)); list($protocol) = explode('/', $request->protocol()); // Create the context $options = array(strtolower($protocol) => array('method' => $request->method(), 'header' => (string) $request->headers(), 'content' => $body)); // Create the context stream $context = stream_context_create($options); stream_context_set_option($context, $this->_options); $uri = $request->uri(); if ($query = $request->query()) { $uri .= '?' . http_build_query($query, NULL, '&'); } $stream = fopen($uri, $mode, FALSE, $context); $meta_data = stream_get_meta_data($stream); // Get the HTTP response code $http_response = array_shift($meta_data['wrapper_data']); if (preg_match_all('/(\\w+\\/\\d\\.\\d) (\\d{3})/', $http_response, $matches) !== FALSE) { $protocol = $matches[1][0]; $status = (int) $matches[2][0]; } else { $protocol = NULL; $status = NULL; } // Create a response $response = $request->create_response(); $response_header = $response->headers(); // Process headers array_map(array($response_header, 'parse_header_string'), array(), $meta_data['wrapper_data']); $response->status($status)->protocol($protocol)->body(stream_get_contents($stream)); // Close the stream after use fclose($stream); return $response; }
public function execute_request(Request $request, Response $response) { $prefix = "Controller_"; $directory = $request->directory(); $controller = $request->controller(); if ($directory) { $prefix .= str_replace(array("\\", "/"), "_", trim($directory, "/")) . "_"; } if (JsonApiApplication::$profiling) { $benchmark = "'" . $request->uri() . "'"; if ($request !== Request::$initial and Request::$current) { $benchmark .= " « '" . Request::$current->uri() . "'"; } $benchmark = Profiler::start("Requests", $benchmark); } $previous = Request::$current; Request::$current = $request; $initial_request = $request === Request::$initial; try { if (!class_exists($prefix . $controller)) { throw HTTP_Exception::factory(404, "The requested URL :uri was not found on this server.", array(":uri" => $request->uri()))->request($request); } $class = new ReflectionClass($prefix . $controller); if ($class->isAbstract()) { throw new JsonApiApplication_Exception("Cannot create instances of abstract :controller", array(":controller" => $prefix . $controller)); } $controller = $class->newInstance($request, $response); $response = $class->getMethod("execute")->invoke($controller); if (!$response instanceof Response) { throw new JsonApiApplication_Exception("Controller failed to return a Response"); } } catch (HTTP_Exception $e) { if ($e->request() === NULL) { $e->request($request); } $response = $e->get_response(); } catch (Exception $e) { $response = JsonApiApplication_Exception::_handler($e); } Request::$current = $previous; if (isset($benchmark)) { Profiler::stop($benchmark); } return $response; }
public static function extend($page) { if (is_array($page)) { $pages = array(); foreach ($page as $itm) { $pages[] = static::extend($itm); } return $pages; } if (is_object($page)) { $uri = Request::uri(); $page->url = Url::make($page->slug); $page->active = false; if ($current = IoC::resolve('page')) { if ($current->id == $page->id) { $page->active = true; } } return $page; } return false; }
/** * Processes the request, executing the controller action that handles this * request, determined by the [Route]. * * 1. Before the controller action is called, the [Controller::before] method * will be called. * 2. Next the controller action will be called. * 3. After the controller action is called, the [Controller::after] method * will be called. * * By default, the output from the controller is captured and returned, and * no headers are sent. * * $request->execute(); * * @param Request $request * @return Response * @throws Kohana_Exception * @uses [Kohana::$profiling] * @uses [Profiler] * @deprecated passing $params to controller methods deprecated since version 3.1 * will be removed in 3.2 */ public function execute_request(Request $request) { // Create the class prefix $prefix = 'controller_'; // Directory $directory = $request->directory(); // Controller $controller = $request->controller(); if ($directory) { // Add the directory name to the class prefix $prefix .= str_replace(array('\\', '/'), '_', trim($directory, '/')) . '_'; } if (Kohana::$profiling) { // Set the benchmark name $benchmark = '"' . $request->uri() . '"'; if ($request !== Request::$initial and Request::$current) { // Add the parent request uri $benchmark .= ' « "' . Request::$current->uri() . '"'; } // Start benchmarking $benchmark = Profiler::start('Requests', $benchmark); } // Store the currently active request $previous = Request::$current; // Change the current request to this request Request::$current = $request; // Is this the initial request $initial_request = $request === Request::$initial; try { if (!class_exists($prefix . $controller)) { throw new HTTP_Exception_404('The requested URL :uri was not found on this server.', array(':uri' => $request->uri())); } // Load the controller using reflection $class = new ReflectionClass($prefix . $controller); if ($class->isAbstract()) { throw new Kohana_Exception('Cannot create instances of abstract :controller', array(':controller' => $prefix . $controller)); } // Create a new instance of the controller $controller = $class->newInstance($request, $request->response() ? $request->response() : $request->create_response()); $class->getMethod('before')->invoke($controller); // Determine the action to use $action = $request->action(); $params = $request->param(); // If the action doesn't exist, it's a 404 if (!$class->hasMethod('action_' . $action)) { throw new HTTP_Exception_404('The requested URL :uri was not found on this server.', array(':uri' => $request->uri())); } $method = $class->getMethod('action_' . $action); $method->invoke($controller); // Execute the "after action" method $class->getMethod('after')->invoke($controller); } catch (Exception $e) { // Restore the previous request if ($previous instanceof Request) { Request::$current = $previous; } if (isset($benchmark)) { // Delete the benchmark, it is invalid Profiler::delete($benchmark); } // Re-throw the exception throw $e; } // Restore the previous request Request::$current = $previous; if (isset($benchmark)) { // Stop the benchmark Profiler::stop($benchmark); } // Return the response return $request->response(); }
public static function current() { return Request::uri(); }
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"> <title>Tiny Issue</title> <script> var siteurl = '<?php echo URL::to(); ?> '; var current_url = '/<?php echo Request::uri(); ?> '; var baseurl = '<?php echo URL::base(); ?> '; </script> <meta name="viewport" content="width=device-width,initial-scale=1"> <?php echo Asset::styles(); ?> <?php echo Asset::scripts(); ?> </head> <body>
/** * Execute the request using PHP stream. (not recommended) * * @param Request $request Request to execute * @return Response */ protected function _native_execute(Request $request) { // Reset the headers Request_Client_External::$_processed_headers = array(); // Calculate stream mode $mode = $request->method() === HTTP_Request::GET ? 'r' : 'r+'; // Process cookies if ($cookies = $request->cookie()) { $request->headers('cookie', http_build_query($cookies, NULL, '; ')); } // Create the context $options = array($request->protocol() => array('method' => $request->method(), 'header' => (string) $request->headers(), 'content' => $request->body(), 'user-agent' => 'Kohana Framework ' . Kohana::VERSION . ' (' . Kohana::CODENAME . ')')); // Create the context stream $context = stream_context_create($options); stream_context_set_option($context, $this->_options); $stream = fopen($request->uri(), $mode, FALSE, $context); $meta_data = stream_get_meta_data($stream); // Get the HTTP response code $http_response = array_shift($meta_data['wrapper_data']); if (preg_match_all('/(\\w+\\/\\d\\.\\d) (\\d{3})/', $http_response, $matches) !== FALSE) { $protocol = $matches[1][0]; $status = (int) $matches[2][0]; } else { $protocol = NULL; $status = NULL; } // Process headers array_map(array('Request_Client_External', '_parse_headers'), array(), $meta_data['wrapper_data']); // Create a response $response = $request->create_response(); $response->status($status)->protocol($protocol)->headers(Request_Client_External::$_processed_headers)->body(stream_get_contents($stream)); // Close the stream after use fclose($stream); return $response; }
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"> <title>Tiny Issue</title> <script> var siteurl = '<?php echo URL::to(); ?> '; var current_url = '<?php echo URL::to(Request::uri()); ?> '; var baseurl = '<?php echo URL::base(); ?> '; </script> <meta name="viewport" content="width=device-width,initial-scale=1"> <?php echo Asset::styles(); ?> <?php echo Asset::scripts(); ?> </head> <body>
break; } } // -------------------------------------------------------------- // Route the request and get the response from the route. // -------------------------------------------------------------- if (is_null($response)) { $route = Routing\Router::make(Request::method(), Request::uri(), new Routing\Loader(ACTIVE_MODULE_PATH))->route(); $response = is_null($route) ? Response::error('404') : $route->call(); } $response = Response::prepare($response); // -------------------------------------------------------------- // Call the "after" filter for the application and module. // -------------------------------------------------------------- foreach (array(ACTIVE_MODULE . '::after', 'after') as $filter) { Routing\Filter::call($filter, array($response, Request::method(), Request::uri())); } // -------------------------------------------------------------- // Stringify the response. // -------------------------------------------------------------- $response->content = (string) $response->content; // -------------------------------------------------------------- // Close the session. // -------------------------------------------------------------- if (Config::get('session.driver') != '') { Session::close(); } // -------------------------------------------------------------- // Send the response to the browser. // -------------------------------------------------------------- $response->send();
static function page_by($root) { $page = trim(Request::uri(), '/'); if (isset($root)) { foreach ((array) $root as $url) { $url = trim($url, '/'); @(list($prefix, $tail) = explode("/{$url}/", "/{$page}/", 2)); if ($prefix === '' and isset($tail)) { return trim($tail, '/'); } } } else { return $page; } }
public function execute_request(Request $request, Response $response) { // Create the class prefix $prefix = 'Controller_'; // Directory $directory = $request->directory(); // Controller $controller = $request->controller(); if ($directory) { // Add the directory name to the class prefix $prefix .= str_replace(array('\\', '/'), '_', trim($directory, '/')) . '_'; } if (Kohana::$profiling) { // Set the benchmark name $benchmark = '"' . $request->uri() . '"'; if ($request !== Request::$initial and Request::$current) { // Add the parent request uri $benchmark .= ' « "' . Request::$current->uri() . '"'; } // Start benchmarking $benchmark = Profiler::start('Requests', $benchmark); } // Store the currently active request $previous = Request::$current; // Change the current request to this request Request::$current = $request; // Is this the initial request $initial_request = $request === Request::$initial; try { if (!class_exists($prefix . $controller)) { $prefix = str_replace('_', '\\', $prefix); $controller = str_replace('_', '\\', $controller); if (!class_exists($prefix . $controller)) { $z = new HTTP_Exception_404('The requested URL :uri was not found on this server.at :prefix :controller', array(':uri' => $request->uri(), ':prefix' => $prefix, ':controller' => $controller)); $z->request($request); throw $z; } } // Load the controller using reflection $class = new ReflectionClass($prefix . $controller); if ($class->isAbstract()) { throw new Kohana_Exception('Cannot create instances of abstract :controller', array(':controller' => $prefix . $controller)); } // Create a new instance of the controller $controller = $class->newInstance($request, $response); // Run the controller's execute() method $response = $class->getMethod('execute')->invoke($controller); if (!$response instanceof Response) { // Controller failed to return a Response. throw new Kohana_Exception('Controller failed to return a Response'); } } catch (HTTP_Exception $e) { // Store the request context in the Exception if ($e->request() === NULL) { $e->request($request); } // Get the response via the Exception $response = $e->get_response(); } catch (Exception $e) { // Generate an appropriate Response object $response = Kohana_Exception::_handler($e); } // Restore the previous request Request::$current = $previous; if (isset($benchmark)) { // Stop the benchmark Profiler::stop($benchmark); } // Return the response return $response; }
/** * Tests that the uri supplied to Request is only trimed * for internal requests. * * @dataProvider provider_uri_only_trimed_on_internal * * @return void */ public function test_uri_only_trimed_on_internal(Request $request, $expected) { $this->assertSame($request->uri(), $expected); }
/** * Processes the request, executing the controller action that handles this * request, determined by the [Route]. * * 1. Before the controller action is called, the [Controller::before] method * will be called. * 2. Next the controller action will be called. * 3. After the controller action is called, the [Controller::after] method * will be called. * * By default, the output from the controller is captured and returned, and * no headers are sent. * * $request->execute(); * * @param Request $request A request object * @param Response $response A response object * @return Response * @throws Kohana_Exception * @uses [Kohana::$profiling] * @uses [Profiler] */ public function execute_request(Request $request, Response $response) { if (Kohana::$profiling) { // Set the benchmark name $benchmark = '"' . $request->uri() . '"'; if ($request !== Request::$initial and Request::$current) { // Add the parent request uri $benchmark .= ' « "' . Request::$current->uri() . '"'; } // Start benchmarking $benchmark = Profiler::start('Requests', $benchmark); } // Store the current active request and replace current with new request $previous = Request::$current; Request::$current = $request; // Resolve the POST fields if ($post = $request->post()) { $request->body(http_build_query($post, NULL, '&'))->headers('content-type', 'application/x-www-form-urlencoded; charset=' . Kohana::$charset); } $request->headers('content-length', (string) $request->content_length()); // If Kohana expose, set the user-agent if (Kohana::$expose) { $request->headers('user-agent', Kohana::version()); } try { $response = $this->_send_message($request, $response); } catch (Exception $e) { // Restore the previous request Request::$current = $previous; if (isset($benchmark)) { // Delete the benchmark, it is invalid Profiler::delete($benchmark); } // Re-throw the exception throw $e; } // Restore the previous request Request::$current = $previous; if (isset($benchmark)) { // Stop the benchmark Profiler::stop($benchmark); } // Return the response return $response; }
/** * Processes the request, executing the controller action that handles this * request, determined by the [Route]. * * 1. Before the controller action is called, the [Controller::before] method * will be called. * 2. Next the controller action will be called. * 3. After the controller action is called, the [Controller::after] method * will be called. * * By default, the output from the controller is captured and returned, and * no headers are sent. * * $request->execute(); * * @param Request $request * @param Response $response * @return Response * @throws Kohana_Exception * @uses [Kohana::$profiling] * @uses [Profiler] */ public function execute(Request $request) { // Prevent too much recursion of header callback requests if ($this->callback_depth() > $this->max_callback_depth()) { throw new Request_Client_Recursion_Exception("Could not execute request to :uri - too many recursions after :depth requests", array(':uri' => $request->uri(), ':depth' => $this->callback_depth() - 1)); } // Execute the request and pass the currently used protocol $orig_response = $response = Response::factory(array('_protocol' => $request->protocol())); if (($cache = $this->cache()) instanceof HTTP_Cache) { return $cache->execute($this, $request, $response); } $response = $this->execute_request($request, $response); // Execute response callbacks foreach ($this->header_callbacks() as $header => $callback) { if ($response->headers($header)) { $cb_result = call_user_func($callback, $request, $response, $this); if ($cb_result instanceof Request) { // If the callback returns a request, automatically assign client params $this->assign_client_properties($cb_result->client()); $cb_result->client()->callback_depth($this->callback_depth() + 1); // Execute the request $response = $cb_result->execute(); } elseif ($cb_result instanceof Response) { // Assign the returned response $response = $cb_result; } // If the callback has created a new response, do not process any further if ($response !== $orig_response) { break; } } } return $response; }
/** * Set the active link based on the current request * * @since 3.0 * @param Request $request * @return bool|\Menu_Item */ public function guess_active_item(Request $request) { return $this->set_current($request->uri()); }