Fehler beim Upgrade von Laravel 5.5 auf 5.6

Lesezeit: 15 Minuten

Benutzer-Avatar
Süssigkeit

Ich versuche, mein Laravel zu aktualisieren 5.5 zu 5.6. Ich habe die Anweisungen von befolgt Laravel Website, aber ich habe diesen Fehler:

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.

Also habe ich meine gewechselt composer.json Datei und 2 Zeilen hinzugefügt: **"minimum-stability": "dev", "prefer-stable": true,** basierend auf der ersten Antwort auf diese Laracast-Diskussion.

Alles schien gut zu funktionieren, bis ich einen weiteren Fehler bekam:

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

Das Problem in Zeile 66 ist Illuminate\Http\Request::HEADER_CLIENT_IP => ‘X_FORWARDED_FOR’,. Ich habe andere Posts auf Stackoverflow durchsucht, aber immer noch kein Glück. Das letzte, was ich versucht habe, war das Composer Selfupdate und das Composer Global Update, das im Post Composer Dump-Autoload Not Recognized-Befehl erwähnt wurde

Außerdem kann ich „minimum-stability“ nicht entfernen: „dev“, „prefer-stable“: true, denn wenn ich das tue, erhalte ich die folgende Fehlermeldung:

    - 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

Ich habe meine composer.json-Datei bzw. trustedproxy.php angehängt. Jede Hilfe wird sehr geschätzt.

{
    "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
    }
}

vertrauenswürdiger Proxy.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\Request-Datei:

<?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(), "https://stackoverflow.com/");
    }

    /**
     * Get the URL (no query string) for the request.
     *
     * @return string
     */
    public function url()
    {
        return rtrim(preg_replace('/\?.*/', '', $this->getUri()), "https://stackoverflow.com/");
    }

    /**
     * Get the full URL for the request.
     *
     * @return string
     */
    public function fullUrl()
    {
        $query = $this->getQueryString();

        $question = $this->getBaseUrl().$this->getPathInfo() == "https://stackoverflow.com/" ? '/?' : '?';

        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() == "https://stackoverflow.com/" ? '/?' : '?';

        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(), "https://stackoverflow.com/");

        return $pattern == '' ? "https://stackoverflow.com/" : $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("https://stackoverflow.com/", $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);
    }
}

Vielen Dank

  • Ich habe es tatsächlich getan und es ist nicht da. Ich wollte nichts hinzufügen oder ändern, weil ich Angst hatte, dass ich etwas kaputt machen würde.

    – Süssigkeit

    3. Februar 2018 um 7:19 Uhr

  • Dies kann hilfreich sein, um Laravel 5.5 auf 5.7 oder 5.8 zu aktualisieren https://stackoverflow.com/a/56556264/8486565

    – vishal soni

    12. Juni 2019 um 6:58 Uhr

Benutzer-Avatar
Benutzer1040259

Ich habe dies getan und es funktioniert perfekt.

1. komponist.json:

Aus:

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

Zu:

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

2. Ersetzen Sie die Datei app\Http\Middleware\TrustedProxies.php durch den folgenden Inhalt:

<?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. Composer-Update

  • Dass "fideloper/proxy": "~4.0", hat es geschafft. Kann es im Upgrade Guide nicht finden laravel.com/docs/5.6/upgrade – Rest findet sich in der Dokumentation. Vielen Dank!

    – Jöran

    8. Februar 2018 um 8:49 Uhr


  • “fideloper/proxy”: “~4.0” wird in der ersten Zeile @ erwähnt Updating Dependencies.

    – Robert

    9. Februar 2018 um 10:48 Uhr

  • @Robert vielleicht wurde es später hinzugefügt, nur gesagt 🙂

    – Kyslik

    12. Februar 2018 um 5:35 Uhr

  • Ich musste “4.0” statt “~4.0” machen, sonst hat Composer es nicht wirklich aktualisiert.

    – Markus

    18. Februar 2018 um 17:30 Uhr

  • Jede Lösung für Declaration of Illuminate\Support\Carbon::__set_state(array $array) should be compatible with Carbon\Carbon::__set_state($state) ?

    – Wesley Brian Lachenal

    9. März 2018 um 16:33 Uhr

Benutzer-Avatar
Patrikus

Das Request-Objekt von Laravel erweitert das Request-Objekt von Symfony. Laravel 5.5 hängt von Symfony 3 ab, das diese Konstante hat. Laravel 5.6 hängt von Symfony 4 ab, das diese Konstante nicht hat.

Basierend auf Ihrer Trusted-Proxies-Konfiguration sieht es so aus, als würden Sie das Trusted-Proxies-Paket „außerhalb“ von Laravel verwenden. Laravel brachte das Trusted-Proxies-Paket in 5.5 in das Framework und erstellte ein dediziertes \App\Http\Middleware\TrustProxies Middleware, die Sie verwenden können.

Ich würde vorschlagen, zur Verwendung der Middleware zu wechseln und sie wie in beschrieben zu konfigurieren Laravel-Dokumentation. Dies wird dazu beitragen, diese Art von Kompatibilitätsproblemen in Zukunft zu vermeiden.

Um den Schalter zu machen:

  1. In app/Http/Kernel.phpWenn \Fideloper\Proxy\TrustProxies::class ist in deinem $middleware Array, entfernen Sie es. Ob \App\Http\Middleware\TrustProxies::class ist nicht in deinem $middleware Array, fügen Sie es hinzu.

  2. Öffne dein app/Http/Middleware/TrustProxies.php Datei und aktualisieren Sie sie mit Ihren Proxys.

  3. Löschen Sie Ihre config/trustedproxy.php Datei.

  4. Entfernen Fideloper\Proxy\TrustedProxyServiceProvider::class von deiner providers Array ein config/app.php.

  5. Aktualisieren Sie Ihre composer.json-Datei so, dass sie „fideloper/proxy“ verwendet: „~4.0“. Lauf composer update fideloper/proxy um das Paket zu aktualisieren.

  • und was ist damit use Fideloper\Proxy\TrustProxies as Middleware;

    – Matan Jadajew

    3. Februar 2018 um 12:52 Uhr

  • Bitte verwenden Sie Tag 4.0+ für Laravel 5.6: composer require fideloper/proxy:~4.0 [email protected]

    – Sibin Xavier

    3. Februar 2018 um 14:30 Uhr


Benutzer-Avatar
Sibin Xavier

Ich habe von 5.5 auf 5.6 aktualisiert

composer.json

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

Dadurch werden die neuesten Laravel-Pakete installiert, dann wird es Probleme geben TrustedProxies.

Installieren Sie die neueste Proxy-Version für Laravel 5.6.

Bitte verwenden Sie Tag 4.0+ für Laravel 5.6:

composer require fideloper/proxy:~4.0

Mehr Details

  • Wie soll ich vorgehen, wenn ich diese 2 Zeilen aus meiner composer.json entfernen würde? Als ich versuchte, ohne sie auf 5.6 zu aktualisieren, bekam ich den ersten Fehler, der in meinem Beitrag angezeigt wurde

    – Süssigkeit

    3. Februar 2018 um 16:15 Uhr

  • Sie müssen diese 2 Zeilen zu composer.json hinzufügen, ich habe es ohne diese Zeilen versucht, aber es hat nicht funktioniert. "minimum-stability":"dev" wird die meisten Pakete auf instabile Versionen aktualisieren, aber this "prefer-stable":truewird in meinem Fall stabile Versionen herunterladen, außer Laravel, Dusk und Passport, alle Pakete sind stabil, und ich habe Dev-Versionen für Latavel und die anderen beiden.

    – Sibin Xavier

    3. Februar 2018 um 16:24 Uhr

Zuerst installieren Laravel 5.6 ich bin auch auf diesen Fehler gestoßen. Befolgen Sie einfach die folgenden Schritte, um das Problem zu beheben:

  • Stellen Sie sicher, dass Ihre Datei composer.json Anforderung hat:
    "require": {
        "php": "^7.1.3",
        "fideloper/proxy": "^4.0",
            },
  • Dann versuche es composer update um sicherzustellen, dass Ihr Composer auf dem neuesten Stand ist
  • Endlich laufen: composer require fideloper/proxy:~4.0
  • Erledigt!

Für alle, die versucht haben, direkt von Laravel 5.5 auf 5.7 zu aktualisieren, und auch dieses Problem hatten, entfernen Sie die Datei trustedproxy.php aus app->config->trustedproxy.php. Hoffe das hilft jemandem.

  • Dafür möchte ich einfach mal DANKE sagen!!! Ich konnte den Fehler scheinbar nicht beseitigen.

    – Robin Hood

    21. Januar 2019 um 11:44 Uhr


  • Ich bin froh, dass es dir geholfen hat.

    – GabMic

    21. Januar 2019 um 12:32 Uhr

  • Dies scheint die einzige Lösung zu sein, die für mich funktioniert hat

    – Pilzanthrax

    9. Februar um 14:57 Uhr

Benutzer-Avatar
Pawan Verma

Sie müssen nur fideloper/proxy in der Datei composer.json ändern: –

Ihre composer.json-Datei jetzt: –

"fideloper/proxy": "~3.3",

Ändern Sie es in etwa so in ^ 4.0: –

"fideloper/proxy": "^4.0",

Danach müssen Sie Update Composer ausführen, das war’s.

composer update

  • Dafür möchte ich einfach mal DANKE sagen!!! Ich konnte den Fehler scheinbar nicht beseitigen.

    – Robin Hood

    21. Januar 2019 um 11:44 Uhr


  • Ich bin froh, dass es dir geholfen hat.

    – GabMic

    21. Januar 2019 um 12:32 Uhr

  • Dies scheint die einzige Lösung zu sein, die für mich funktioniert hat

    – Pilzanthrax

    9. Februar um 14:57 Uhr

Ihr Problem ergibt sich aus Ihrer Nutzung der Bibliothek TrustedProxy.

Es verwendet Symfonys HEADER_CLIENT_IP konstant was war veraltet mit Symfony 3.3 und vollständig entfernt in Symfony 4.0.

Da Laravel 5.6 aktualisiert wurde, um Symfony 4-Komponenten zu verwenden, funktioniert dies nicht mehr.

Der Weg, es zu lösen, ist mach was patricus vorgeschlagen hat und verwenden Sie die TrustProxies-Middleware von Laravel.

  • Daniel, wie kann ich das beheben? Kann ich sie einfach entfernen?

    – Süssigkeit

    3. Februar 2018 um 7:26 Uhr


1014970cookie-checkFehler beim Upgrade von Laravel 5.5 auf 5.6

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy