php - update - Actualización de Laravel 5.5 a 5.6 error

update 5.5 to 5.6 laravel

Question

Estoy tratando de actualizar mi Laravel 5.5 a 5.6. He seguido las instrucciones del laravel web de laravel , pero recibí este error:

Your requirements could not be resolved to an installable set of packages.
Problem 1
- The requested package laravel/framework 5.6.* is satisfiable by laravel/framework[5.6.x-dev] but these conflict with your requirements or minimum-stability.

Entonces, cambié mi archivo composer.json y agregué 2 líneas: **"minimum-stability": "dev", "prefer-stable": true,** basado en la primera respuesta en this discusión laracast.

Todo parecía funcionar bien hasta que tuve otro error:

Loading composer repositories with package information
Updating dependencies (including require-dev)
Package operations: 0 installs, 6 updates, 0 removals
- Updating sebastian/diff (2.0.1 => 3.0.0): Downloading (100%)
- Updating phpunit/phpunit-mock-objects (5.0.6 => 6.0.0): Downloading (100%) - Updating phpunit/php-timer (1.0.9 => 2.0.0): Downloading (100%)
- Updating phpunit/php-token-stream (2.0.2 => 3.0.0): Downloading (100%) - Updating phpunit/php-code-coverage (5.3.0 => 6.0.1): Downloading (100%) - Updating phpunit/phpunit (6.5.6 => 7.0.0): Downloading (100%)
Writing lock file
Generating optimized autoload files
> Illuminate/Foundation/ComposerScripts::postAutoloadDump
> @php artisan package:discover
In trustedproxy.php line 66:
Undefined class constant ''HEADER_CLIENT_IP''
Script @php artisan package:discover handling the post-autoload-dump event returned with error code 1

El problema en la línea 66 es Illuminate / Http / Request :: HEADER_CLIENT_IP => ''X_FORWARDED_FOR'',. He buscado otras publicaciones en stackoverflow pero todavía no he tenido suerte. Lo último que intenté fue la actualización automática del compositor y la actualización global del compositor que se mencionó en el comando post compositor dump-autoload no reconocido

Además, no puedo eliminar "estabilidad mínima": "dev", "prefer-stable": verdadero porque si lo hago, obtendré el siguiente error:

 - Installation request for laravel/framework 5.6.* -> satisfiable by laravel/framework[5.6.x-dev].
- Removal request for laravel/framework == 5.6.9999999.9999999-dev

He adjuntado mi archivo composer.json y trustedproxy.php respectivamente. Cualquier ayuda será muy apreciada.

{
"name": "laravel/laravel",
"description": "The Laravel Framework.",
"minimum-stability": "dev",
"prefer-stable": true,
"keywords": ["framework", "laravel"],
"license": "MIT",
"type": "project",
"require": {
"php": ">=7.1.3",
"fideloper/proxy": "~3.3",
"laravel/framework": "5.6.*",
"laravel/tinker": "~1.0"
},
"require-dev": {
"filp/whoops": "~2.0",
"fzaninotto/faker": "~1.4",
"mockery/mockery": "~1.0",
"phpunit/phpunit": "~7.0",
"symfony/thanks": "^1.0"
},
"autoload": {
"classmap": [
"database/seeds",
"database/factories"
],
"psr-4": {
"App//": "app/"
}
},
"autoload-dev": {
"psr-4": {
"Tests//": "tests/"
}
},
"extra": {
"laravel": {
"dont-discover": [
]
}
},
"scripts": {
"post-root-package-install": [
"@php -r /"file_exists(''.env'') || copy(''.env.example'', ''.env'');/""
],
"post-create-project-cmd": [
"@php artisan key:generate"
],
"post-autoload-dump": [
"Illuminate//Foundation//ComposerScripts::postAutoloadDump",
"@php artisan package:discover"
]
},
"config": {
"preferred-install": "dist",
"sort-packages": true,
"optimize-autoloader": true
}
}

trustedproxy.php (error in line 66--> Illuminate/Http/Request::HEADER_CLIENT_IP => ''X_FORWARDED_FOR'',)

<?php
return [
/*
* Set trusted proxy IP addresses.
*
* Both IPv4 and IPv6 addresses are
* supported, along with CIDR notation.
*
* The "*" character is syntactic sugar
* within TrustedProxy to trust any proxy
* that connects directly to your server,
* a requirement when you cannot know the address
* of your proxy (e.g. if using Rackspace balancers).
*
* The "**" character is syntactic sugar within
* TrustedProxy to trust not just any proxy that
* connects directly to your server, but also
* proxies that connect to those proxies, and all
* the way back until you reach the original source
* IP. It will mean that $request->getClientIp()
* always gets the originating client IP, no matter
* how many proxies that client''s request has
* subsequently passed through.
*/
''proxies'' => [
''192.168.1.10'',
],
/*
* Or, to trust all proxies that connect
* directly to your server, uncomment this:
*/
# ''proxies'' => ''*'',
/*
* Or, to trust ALL proxies, including those that
* are in a chain of forwarding, uncomment this:
*/
# ''proxies'' => ''**'',
/*
* Default Header Names
*
* Change these if the proxy does
* not send the default header names.
*
* Note that headers such as X-Forwarded-For
* are transformed to HTTP_X_FORWARDED_FOR format.
*
* The following are Symfony defaults, found in
* /Symfony/Component/HttpFoundation/Request::$trustedHeaders
*
* You may optionally set headers to ''null'' here if you''d like
* for them to be considered untrusted instead. Ex:
*
* Illuminate/Http/Request::HEADER_CLIENT_HOST => null,
*
* WARNING: If you''re using AWS Elastic Load Balancing or Heroku,
* the FORWARDED and X_FORWARDED_HOST headers should be set to null
* as they are currently unsupported there.
*/
''headers'' => [
(defined(''Illuminate/Http/Request::HEADER_FORWARDED'') ? Illuminate/Http/Request::HEADER_FORWARDED : ''forwarded'') => ''FORWARDED'',
Illuminate/Http/Request::HEADER_CLIENT_IP => ''X_FORWARDED_FOR'',
Illuminate/Http/Request::HEADER_CLIENT_HOST => ''X_FORWARDED_HOST'',
Illuminate/Http/Request::HEADER_CLIENT_PROTO => ''X_FORWARDED_PROTO'',
Illuminate/Http/Request::HEADER_CLIENT_PORT => ''X_FORWARDED_PORT'',
]
];

Illuminate / Http / Solicitud de archivo:

<?php
namespace Illuminate/Http;
use Closure;
use ArrayAccess;
use RuntimeException;
use Illuminate/Support/Arr;
use Illuminate/Support/Str;
use Illuminate/Support/Traits/Macroable;
use Illuminate/Contracts/Support/Arrayable;
use Symfony/Component/HttpFoundation/ParameterBag;
use Symfony/Component/HttpFoundation/Request as SymfonyRequest;
class Request extends SymfonyRequest implements Arrayable, ArrayAccess
{
use Concerns/InteractsWithContentTypes,
Concerns/InteractsWithFlashData,
Concerns/InteractsWithInput,
Macroable;
/**
* The decoded JSON content for the request.
*
* @var /Symfony/Component/HttpFoundation/ParameterBag|null
*/
protected $json;
/**
* All of the converted files for the request.
*
* @var array
*/
protected $convertedFiles;
/**
* The user resolver callback.
*
* @var /Closure
*/
protected $userResolver;
/**
* The route resolver callback.
*
* @var /Closure
*/
protected $routeResolver;
/**
* Create a new Illuminate HTTP request from server variables.
*
* @return static
*/
public static function capture()
{
static::enableHttpMethodParameterOverride();
return static::createFromBase(SymfonyRequest::createFromGlobals());
}
/**
* Return the Request instance.
*
* @return $this
*/
public function instance()
{
return $this;
}
/**
* Get the request method.
*
* @return string
*/
public function method()
{
return $this->getMethod();
}
/**
* Get the root URL for the application.
*
* @return string
*/
public function root()
{
return rtrim($this->getSchemeAndHttpHost().$this->getBaseUrl(), ''/'');
}
/**
* Get the URL (no query string) for the request.
*
* @return string
*/
public function url()
{
return rtrim(preg_replace(''//?.*/'', '''', $this->getUri()), ''/'');
}
/**
* Get the full URL for the request.
*
* @return string
*/
public function fullUrl()
{
$query = $this->getQueryString();
$question = $this->getBaseUrl().$this->getPathInfo() == ''/'' ? ''/?'' : ''?'';
return $query ? $this->url().$question.$query : $this->url();
}
/**
* Get the full URL for the request with the added query string parameters.
*
* @param array $query
* @return string
*/
public function fullUrlWithQuery(array $query)
{
$question = $this->getBaseUrl().$this->getPathInfo() == ''/'' ? ''/?'' : ''?'';
return count($this->query()) > 0
? $this->url().$question.http_build_query(array_merge($this->query(), $query))
: $this->fullUrl().$question.http_build_query($query);
}
/**
* Get the current path info for the request.
*
* @return string
*/
public function path()
{
$pattern = trim($this->getPathInfo(), ''/'');
return $pattern == '''' ? ''/'' : $pattern;
}
/**
* Get the current decoded path info for the request.
*
* @return string
*/
public function decodedPath()
{
return rawurldecode($this->path());
}
/**
* Get a segment from the URI (1 based index).
*
* @param int $index
* @param string|null $default
* @return string|null
*/
public function segment($index, $default = null)
{
return Arr::get($this->segments(), $index - 1, $default);
}
/**
* Get all of the segments for the request path.
*
* @return array
*/
public function segments()
{
$segments = explode(''/'', $this->decodedPath());
return array_values(array_filter($segments, function ($value) {
return $value !== '''';
}));
}
/**
* Determine if the current request URI matches a pattern.
*
* @param dynamic $patterns
* @return bool
*/
public function is(...$patterns)
{
foreach ($patterns as $pattern) {
if (Str::is($pattern, $this->decodedPath())) {
return true;
}
}
return false;
}
/**
* Determine if the route name matches a given pattern.
*
* @param dynamic $patterns
* @return bool
*/
public function routeIs(...$patterns)
{
return $this->route() && $this->route()->named(...$patterns);
}
/**
* Determine if the current request URL and query string matches a pattern.
*
* @param dynamic $patterns
* @return bool
*/
public function fullUrlIs(...$patterns)
{
$url = $this->fullUrl();
foreach ($patterns as $pattern) {
if (Str::is($pattern, $url)) {
return true;
}
}
return false;
}
/**
* Determine if the request is the result of an AJAX call.
*
* @return bool
*/
public function ajax()
{
return $this->isXmlHttpRequest();
}
/**
* Determine if the request is the result of an PJAX call.
*
* @return bool
*/
public function pjax()
{
return $this->headers->get(''X-PJAX'') == true;
}
/**
* Determine if the request is over HTTPS.
*
* @return bool
*/
public function secure()
{
return $this->isSecure();
}
/**
* Get the client IP address.
*
* @return string
*/
public function ip()
{
return $this->getClientIp();
}
/**
* Get the client IP addresses.
*
* @return array
*/
public function ips()
{
return $this->getClientIps();
}
/**
* Get the client user agent.
*
* @return string
*/
public function userAgent()
{
return $this->headers->get(''User-Agent'');
}
/**
* Merge new input into the current request''s input array.
*
* @param array $input
* @return /Illuminate/Http/Request
*/
public function merge(array $input)
{
$this->getInputSource()->add($input);
return $this;
}
/**
* Replace the input for the current request.
*
* @param array $input
* @return /Illuminate/Http/Request
*/
public function replace(array $input)
{
$this->getInputSource()->replace($input);
return $this;
}
/**
* Get the JSON payload for the request.
*
* @param string $key
* @param mixed $default
* @return /Symfony/Component/HttpFoundation/ParameterBag|mixed
*/
public function json($key = null, $default = null)
{
if (! isset($this->json)) {
$this->json = new ParameterBag((array) json_decode($this->getContent(), true));
}
if (is_null($key)) {
return $this->json;
}
return data_get($this->json->all(), $key, $default);
}
/**
* Get the input source for the request.
*
* @return /Symfony/Component/HttpFoundation/ParameterBag
*/
protected function getInputSource()
{
if ($this->isJson()) {
return $this->json();
}
return $this->getRealMethod() == ''GET'' ? $this->query : $this->request;
}
/**
* Create an Illuminate request from a Symfony instance.
*
* @param /Symfony/Component/HttpFoundation/Request $request
* @return /Illuminate/Http/Request
*/
public static function createFromBase(SymfonyRequest $request)
{
if ($request instanceof static) {
return $request;
}
$content = $request->content;
$request = (new static)->duplicate(
$request->query->all(), $request->request->all(), $request->attributes->all(),
$request->cookies->all(), $request->files->all(), $request->server->all()
);
$request->content = $content;
$request->request = $request->getInputSource();
return $request;
}
/**
* {@inheritdoc}
*/
public function duplicate(array $query = null, array $request = null, array $attributes = null, array $cookies = null, array $files = null, array $server = null)
{
return parent::duplicate($query, $request, $attributes, $cookies, $this->filterFiles($files), $server);
}
/**
* Filter the given array of files, removing any empty values.
*
* @param mixed $files
* @return mixed
*/
protected function filterFiles($files)
{
if (! $files) {
return;
}
foreach ($files as $key => $file) {
if (is_array($file)) {
$files[$key] = $this->filterFiles($files[$key]);
}
if (empty($files[$key])) {
unset($files[$key]);
}
}
return $files;
}
/**
* Get the session associated with the request.
*
* @return /Illuminate/Session/Store
*
* @throws /RuntimeException
*/
public function session()
{
if (! $this->hasSession()) {
throw new RuntimeException(''Session store not set on request.'');
}
return $this->session;
}
/**
* Get the session associated with the request.
*
* @return /Illuminate/Session/Store|null
*/
public function getSession()
{
return $this->session;
}
/**
* Set the session instance on the request.
*
* @param /Illuminate/Contracts/Session/Session $session
* @return void
*/
public function setLaravelSession($session)
{
$this->session = $session;
}
/**
* Get the user making the request.
*
* @param string|null $guard
* @return mixed
*/
public function user($guard = null)
{
return call_user_func($this->getUserResolver(), $guard);
}
/**
* Get the route handling the request.
*
* @param string|null $param
*
* @return /Illuminate/Routing/Route|object|string
*/
public function route($param = null)
{
$route = call_user_func($this->getRouteResolver());
if (is_null($route) || is_null($param)) {
return $route;
}
return $route->parameter($param);
}
/**
* Get a unique fingerprint for the request / route / IP address.
*
* @return string
*
* @throws /RuntimeException
*/
public function fingerprint()
{
if (! $route = $this->route()) {
throw new RuntimeException(''Unable to generate fingerprint. Route unavailable.'');
}
return sha1(implode(''|'', array_merge(
$route->methods(), [$route->getDomain(), $route->uri(), $this->ip()]
)));
}
/**
* Set the JSON payload for the request.
*
* @param /Symfony/Component/HttpFoundation/ParameterBag $json
* @return $this
*/
public function setJson($json)
{
$this->json = $json;
return $this;
}
/**
* Get the user resolver callback.
*
* @return /Closure
*/
public function getUserResolver()
{
return $this->userResolver ?: function () {
//
};
}
/**
* Set the user resolver callback.
*
* @param /Closure $callback
* @return $this
*/
public function setUserResolver(Closure $callback)
{
$this->userResolver = $callback;
return $this;
}
/**
* Get the route resolver callback.
*
* @return /Closure
*/
public function getRouteResolver()
{
return $this->routeResolver ?: function () {
//
};
}
/**
* Set the route resolver callback.
*
* @param /Closure $callback
* @return $this
*/
public function setRouteResolver(Closure $callback)
{
$this->routeResolver = $callback;
return $this;
}
/**
* Get all of the input and files for the request.
*
* @return array
*/
public function toArray()
{
return $this->all();
}
/**
* Determine if the given offset exists.
*
* @param string $offset
* @return bool
*/
public function offsetExists($offset)
{
return array_key_exists(
$offset, $this->all() + $this->route()->parameters()
);
}
/**
* Get the value at the given offset.
*
* @param string $offset
* @return mixed
*/
public function offsetGet($offset)
{
return $this->__get($offset);
}
/**
* Set the value at the given offset.
*
* @param string $offset
* @param mixed $value
* @return void
*/
public function offsetSet($offset, $value)
{
$this->getInputSource()->set($offset, $value);
}
/**
* Remove the value at the given offset.
*
* @param string $offset
* @return void
*/
public function offsetUnset($offset)
{
$this->getInputSource()->remove($offset);
}
/**
* Check if an input element is set on the request.
*
* @param string $key
* @return bool
*/
public function __isset($key)
{
return ! is_null($this->__get($key));
}
/**
* Get an input element from the request.
*
* @param string $key
* @return mixed
*/
public function __get($key)
{
if (array_key_exists($key, $this->all())) {
return data_get($this->all(), $key);
}
return $this->route($key);
}
}

Gracias

Answer 1

El objeto Request de Laravel extiende el objeto Request de Symfony. Laravel 5.5 depende de Symfony 3, que tiene esa constante. Laravel 5.6 depende de Symfony 4, que no tiene esa constante.

Según su configuración de servidores proxy de confianza, parece que está utilizando el paquete de servidores proxy de confianza "fuera" de Laravel. Laravel introdujo el paquete de servidores proxy de confianza dentro del marco en 5.5, y creó un middleware dedicado /App/Http/Middleware/TrustProxies para que lo use.

Yo sugeriría mover para usar el middleware y configurarlo como se describe en la documentación de Laravel . Esto ayudará a prevenir este tipo de problemas de compatibilidad en el futuro.

Para hacer el cambio:

1. En la app/Http/Kernel.php , si la /Fideloper/Proxy/TrustProxies::class está en su matriz $middleware , elimínela. Si /App/Http/Middleware/TrustProxies::class no está en su matriz $middleware , agréguela.

2. Abra su app/Http/Middleware/TrustProxies.php y actualícelo con sus proxies.

3. Borre su archivo config/trustedproxy.php .

4. Elimine Fideloper/Proxy/TrustedProxyServiceProvider::class de la matriz de su providers en config/app.php .

5. Actualice su archivo composer.json para usar "fideloper / proxy": "~ 4.0". Ejecute la composer update fideloper/proxy para actualizar el paquete.

Answer 2

He actualizado de 5.5 a 5.6

compositor.json

"minimum-stability":"dev",
"prefer-stable": true,

Esto instalará los últimos paquetes de Laravel, luego habrá un problema con TrustedProxies .

Instala la última versión de proxy para Laravel 5.6.

Por favor use la etiqueta 4.0+ para Laravel 5.6:

composer require fideloper/proxy:~4.0

proxy@4

Answer 3

Hice esto y funciona perfectamente.

1. compositor.json:

Desde:

"require": {
"php": ">=7.0.0",
"fideloper/proxy": "~3.3",
"laravel/framework": "5.5.*",
"laravel/tinker": "~1.0"
},

A:

"require": {
"php": ">=7.1.3",
"fideloper/proxy": "~4.0",
"laravel/framework": "5.6.*",
"laravel/tinker": "~1.0"
},

2. Reemplace el archivo app / Http / Middleware / TrustedProxies.php con el contenido a continuación:

<?php
namespace App/Http/Middleware;
use Illuminate/Http/Request;
use Fideloper/Proxy/TrustProxies as Middleware;
class TrustProxies extends Middleware
{
/**
* The trusted proxies for this application.
*
* @var array
*/
protected $proxies;
/**
* The headers that should be used to detect proxies.
*
* @var string
*/
protected $headers = Request::HEADER_X_FORWARDED_ALL;
}

3. actualización del compositor

Answer 4

Hice lo siguiente y conseguí que mi proyecto se ejecutara en Laravel 5.6-dev:

• Siguió lo que sugirió patricus.
• Cambié fideloper / proxy a "~ 4.0", y añadí "minimum-stability": "dev", "prefer-stable": true al final de mi archivo composer.json.

Answer 5

Ninguna de las sugerencias aquí me funcionó por alguna razón. Estoy usando el panel quickadmin y varias dependencias que pueden tener algo que ver con eso.

Lo que finalmente funcionó fue eliminar laravel / dusk, luego actualizar a "fideloper/proxy": "~4.0", por su cuenta. Luego actualizando laravel / framework a 5.6, luego reinstalando el atardecer.

No necesitaba: "minimum-stability":"dev", "prefer-stable": true,

Tal vez eso fue arreglado con actualizaciones recientes.

Answer 6

Para cualquier persona que haya intentado actualizar directamente desde laravel 5.5 a 5.7, y también haya tenido este problema, elimine el archivo app->config->trustedproxy.php de app->config->trustedproxy.php . Espera que ayude a alguien.

Answer 7

Primero instale Laravel 5.6, también tuve este error. Simplemente sigue los siguientes pasos para solucionarlo:

• Asegúrese de que el archivo composer.json tenga:

"require": { "php": "^7.1.3", "fideloper/proxy": "^4.0", },

• A continuación, intente composer update para asegurarse de que su compositor esté actualizado
• Finalmente ejecute: composer require fideloper/proxy:~4.0
• ¡Hecho!

Answer 8

Reemplace app / Http / Middleware / TrustedProxies.php por:

 <?php
namespace App/Http/Middleware;
use Illuminate/Http/Request;
use Fideloper/Proxy/TrustProxies as Middleware;
class TrustProxies extends Middleware
{
protected $proxies;
protected $headers = Request::HEADER_X_FORWARDED_ALL;
}

Reemplace config / trustedproxy.php por:

<?php
return [
''proxies'' => null,
''headers'' => Illuminate/Http/Request::HEADER_X_FORWARDED_ALL,
];

Answer 9

Se enfrentó al mismo problema y recibió una serie de pautas para resolverlo. Lamentablemente ninguno de los que trabajaron o yo. En realidad, no hay pasos o tareas adicionales que deban abordarse para solucionar este problema.

Simplemente siga la guía de actualización oficial de laravel y junto con eso elimine el archivo de configuración trustedproxy ubicado en config/trustedproxy.php

Answer 10

Su problema proviene de su uso de la biblioteca TrustedProxy .

Utiliza la constante HEADER_CLIENT_IP de Symfony, que quedó en desuso con Symfony 3.3 y se eliminó completamente en Symfony 4.0.

Ya que Laravel 5.6 se ha actualizado para usar los componentes de Symfony 4, esto ya no funcionará.

La forma de resolverlo es hacer lo que Patricus sugiere y utilizar el software intermedio TrustProxies de Laravel.