Blame view

addons/antis/library/wework/Http/Middleware.php 3.07 KB
2db47680   hexiaodong   chore: 初始提交 php 遗...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
  <?php

  

  namespace WeWork\Http;

  

  use GuzzleHttp\Exception\ConnectException;

  use GuzzleHttp\Exception\RequestException;

  use GuzzleHttp\MessageFormatter;

  use GuzzleHttp\Psr7\Request;

  use GuzzleHttp\Psr7\Uri;

  use Psr\Http\Message\RequestInterface;

  use Psr\Http\Message\ResponseInterface;

  use Psr\Log\LoggerInterface;

  use Psr\Log\LogLevel;

  use WeWork\ApiCache\Token;

  

  class Middleware

  {

      const RETRY_MAX_RETRIES = 1;

  

      /**

       * @param Token $token

       * @return callable

       */

      public static function auth(Token $token)

      {

          return \GuzzleHttp\Middleware::mapRequest(function (RequestInterface $request) use ($token) {

              return $request->withUri(Uri::withQueryValue($request->getUri(), 'access_token', $token->get()));

          });

      }

  

      /**

       * @param LoggerInterface $logger

       * @return callable

       */

      public static function log(LoggerInterface $logger)

      {

          return \GuzzleHttp\Middleware::log($logger, new MessageFormatter(MessageFormatter::DEBUG), LogLevel::DEBUG);

      }

  

      /**

       * @param LoggerInterface $logger

       * @return callable

       */

      public static function retry(LoggerInterface $logger)

      {

          return \GuzzleHttp\Middleware::retry(function (

              $retries,

              Request $request,

              Response $response = null,

              RequestException $exception = null

          ) use ($logger) {

              if ($retries >= self::RETRY_MAX_RETRIES) {

                  return false;

              }

  

              if (!(self::isServerError($response) || self::isConnectError($exception))) {

                  return false;

              }

  

              $logger->warning(

                  sprintf(

                      'Retrying %s %s %s/%s, %s',

                      $request->getMethod(),

                      $request->getUri(),

                      $retries + 1,

                      self::RETRY_MAX_RETRIES,

                      $response ? 'status code: ' . $response->getStatusCode() : $exception->getMessage()

                  ),

                  [$request->getHeader('Host')[0]]

              );

  

              return true;

          });

      }

  

      /**

       * @return callable

       */

      public static function response()

      {

          return \GuzzleHttp\Middleware::mapResponse(function (ResponseInterface $response) {

              return new Response(

                  $response->getStatusCode(),

                  $response->getHeaders(),

                  $response->getBody(),

                  $response->getProtocolVersion(),

                  $response->getReasonPhrase()

              );

          });

      }

  

      /**

       * @param Response $response

       *

       * @return bool

       */

      private static function isServerError(Response $response = null)

      {

          return $response && $response->getStatusCode() >= 500;

      }

  

      /**

       * @param RequestException $exception

       *

       * @return bool

       */

      private static function isConnectError(RequestException $exception = null)

      {

          return $exception instanceof ConnectException;

      }

  }