PHP Client::put方法代码示例

 public function upload($file, $remote_path, $chunk_size)
 {
     if (!file_exists($file) || !is_readable($file) || !($fp = fopen($file, 'rb'))) {
         throw new \Exception(sprintf(__('The file %s does not seem to exist or is not readable.', 'my-wp-backup'), $file));
     }
     $upload_id = null;
     while (!feof($fp)) {
         try {
             $res = $this->client->put('chunked_upload', null, array('upload_id' => $upload_id, 'offset' => ftell($fp)))->setBody(wpb_get_file_chunk($fp, $chunk_size))->send()->json();
             if (null === $upload_id) {
                 $upload_id = $res['upload_id'];
             }
         } catch (BadResponseException $e) {
             $body = $e->getResponse()->getBody(true);
             error_log($e->getRequest()->getRawHeaders());
             error_log($body);
             throw new \Exception($body);
         }
     }
     $req = $this->client->post('commit_chunked_upload/auto/' . ltrim($remote_path, '/'), null, array('upload_id' => $upload_id, 'overwrite' => 'true'));
     try {
         return $req->send()->json();
     } catch (BadResponseException $e) {
         $body = $e->getResponse()->getBody(true);
         error_log($e->getRequest()->getRawHeaders());
         error_log($body);
         throw new \Exception($body);
     }
 }

 /**
  * @inheritdoc
  */
 public function put($url, $params)
 {
     $request = $this->client->put($url, null, json_encode($params));
     $this->setHeaders($request);
     $response = $request->send();
     return $response->getStatusCode() == 204;
 }

 /**
  * Send Create/Update Customer Request
  * @param $id
  * @param $email
  * @param $attributes
  * @return Response
  */
 public function customer($id, $email, $attributes)
 {
     $body = array_merge(array('email' => $email), $attributes);
     try {
         $response = $this->client->put('/api/v1/customers/' . $id, null, $body, array('auth' => $this->auth))->send();
     } catch (RequestException $e) {
         $response = $e->getResponse();
     }
     return new Response($response->getStatusCode(), $response->getReasonPhrase());
 }

 /**
  * Queue an array of responses or a single response on the server.
  *
  * Any currently queued responses will be overwritten.  Subsequent requests
  * on the server will return queued responses in FIFO order.
  *
  * @param array|Response $responses A single or array of Responses to queue
  * @throws BadResponseException
  */
 public function enqueue($responses)
 {
     $data = array();
     foreach ((array) $responses as $response) {
         // Create the response object from a string
         if (is_string($response)) {
             $response = Response::fromMessage($response);
         } elseif (!$response instanceof Response) {
             throw new BadResponseException('Responses must be strings or implement Response');
         }
         $data[] = array('statusCode' => $response->getStatusCode(), 'reasonPhrase' => $response->getReasonPhrase(), 'headers' => $response->getHeaders()->toArray(), 'body' => $response->getBody(true));
     }
     $request = $this->client->put('guzzle-server/responses', null, json_encode($data));
     $request->send();
 }

 /**
  * @param $endpointUrl
  * @param $putData
  * @return \stdClass
  * @throws GenericHTTPError
  * @throws InvalidCredentials
  * @throws MissingEndpoint
  * @throws MissingRequiredParameters
  */
 public function put($endpointUrl, $putData)
 {
     $request = $this->mgClient->put($endpointUrl, array(), $putData);
     $request->getPostFields()->setAggregator(new DuplicateAggregator());
     $response = $request->send();
     return $this->responseHandler($response);
 }

 /**
  * @param int             $facilityId
  * @param int             $doctorId
  * @param int             $addressId
  *
  * @param PutSlotsRequest $putSlots
  *
  * @return PutSlotsResponse
  */
 public function putSlots($facilityId, $doctorId, $addressId, $putSlots)
 {
     $requestBody = $this->serializer->serialize($putSlots, 'json', SerializationContext::create()->setGroups(['Default', 'put_slots']));
     $request = $this->client->put(['facilities/{facilityId}/doctors/{doctorId}/addresses/{addressId}/slots', ['facilityId' => $facilityId, 'doctorId' => $doctorId, 'addressId' => $addressId]], null, $requestBody);
     $putSlotResponse = $this->authorizedRequest($request, PutSlotsResponse::class);
     return $putSlotResponse;
 }

function creat_user()
{
    $name = uniqid('riakcs-');
    $client = new Client('http://localhost:' . cs_port());
    $request = $client->put('/riak-cs/user', array('Content-Type' => 'application/json'), "{\"name\":\"{$name}\", \"email\":\"{$name}@example.com\"}");
    return $request->send()->json();
}

 /**
  * @param NewConnectionRevision $newRevision
  * @return Connection
  */
 public function update(NewConnectionRevision $newRevision)
 {
     $url = $this->getConnectionUrl($newRevision->getConnection()->getId());
     $request = $this->client->put($this->client->getBaseUrl() . $url, $this->HEADERS, $this->serializer->serialize($this->disassembler->disassemble($newRevision), 'json'));
     $response = $request->send();
     $this->statusCodeValidator->validate(201, $url, $request, $response);
     return $this->mapJsonToConnection($response->getBody(true));
 }

 /**
  * Send a simple put request to the Elasticsearch server.
  *
  * @param $uri
  * @param array $data
  *
  * @return \Guzzle\Http\Message\Response
  */
 public static function httpPut($uri, $data = null)
 {
     $client = new HttpClient();
     $host = Config::getFirstHost();
     if ($data) {
         $data = json_encode($data);
     }
     return $client->put($host . '/' . $uri, null, $data)->send();
 }

 public function testAddsBody()
 {
     $this->getServer()->flush();
     $this->getServer()->enqueue("HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nhi");
     $request = $this->client->put('/', array('Foo' => 'Bar'), 'Testing...123');
     $stream = $this->factory->fromRequest($request);
     $this->assertEquals('hi', (string) $stream);
     $headers = $this->factory->getLastResponseHeaders();
     $this->assertContains('HTTP/1.1 200 OK', $headers);
     $this->assertContains('Content-Length: 2', $headers);
     $this->assertSame($headers, $stream->getCustomData('response_headers'));
     $received = $this->getServer()->getReceivedRequests();
     $this->assertEquals(1, count($received));
     $this->assertContains('PUT / HTTP/1.1', $received[0]);
     $this->assertContains('host: ', $received[0]);
     $this->assertContains('user-agent: Guzzle/', $received[0]);
     $this->assertContains('foo: Bar', $received[0]);
     $this->assertContains('content-length: 13', $received[0]);
     $this->assertContains('Testing...123', $received[0]);
 }

 /**
  * Perform the file upload operation.
  *
  * @param  null
  * @return void
  */
 public function finishUpload($requiredHeaders = array())
 {
     $parameters = $this->getParameters();
     if (isset($parameters['_requiredHeaders'])) {
         $requiredHeaders = $parameters['_requiredHeaders'];
     }
     $client = new Client();
     $request = $client->put($parameters['_uploadURL'], $requiredHeaders, fopen($parameters['path'], 'r'));
     $response = $request->send();
     unset($parameters['path']);
     $this->setParameters($parameters);
 }

 public function send(Postmaster_TransportModel $model)
 {
     if (!empty($this->settings->url)) {
         $headers = $this->settings->headers;
         try {
             $client = new Client();
             switch ($this->settings->action) {
                 case 'get':
                     $request = $client->get($this->settings->url, $headers);
                     $query = $request->getQuery();
                     foreach ($this->settings->postVars as $var) {
                         $query->add($var['name'], $var['value']);
                     }
                     break;
                 case 'post':
                     $request = $client->post($this->settings->url, $this->settings->getHeaders(), $this->settings->getRequestVars());
                     break;
                 case 'put':
                     $request = $client->put($this->settings->url, $this->settings->getHeaders(), $this->settings->getRequestVars());
                     break;
                 case 'delete':
                     $request = $client->delete($this->settings->url, $this->settings->getHeaders());
                     break;
             }
             $response = $request->send();
             $model->addData('responseString', (string) $response->getBody());
             $model->addData('responseJson', json_decode($model->getData('responseString')));
             return $this->success($model);
         } catch (ClientErrorResponseException $e) {
             $response = (string) $e->getResponse()->getBody();
             $json = json_decode($response);
             $model->addData('responseString', $response);
             if (is_object($json) && isset($json->errors)) {
                 if (!is_array($json->errors)) {
                     $json->errors = (array) $json->errors;
                 }
                 $model->addData('responseJson', $json);
                 return $this->failed($model, 400, $json->errors);
             } else {
                 $model->addData('responseJson', array($response));
                 return $this->failed($model, 400, array($response));
             }
         } catch (\Exception $e) {
             $error = $e->getMessage();
             $json = !is_array($error) ? array('title' => $error) : $error;
             $model->addData('responseString', $error);
             $model->addData('responseJson', $json);
             return $this->failed($model, 400, $json);
         }
     }
     return $this->failed($model, 400, array(\Craft::t('The ping url is empty.')));
 }

 /**
  * Performs an HTTP PUT on a URI. The result can be read from
  * $this->response* variables.
  *
  * @param string|null $uri
  * @param mixed $payload
  * @param string $content_type
  * @param string $accept_type
  * @param array $custom_headers
  * @param array $options
  */
 public function put($uri = null, $payload = '', $content_type = 'application/json; charset=utf-8', $accept_type = 'application/json; charset=utf-8', array $custom_headers = array(), array $options = array())
 {
     self::preparePayload($content_type, $payload);
     $headers = array('accept' => $accept_type, 'content-type' => $content_type);
     foreach ($custom_headers as $key => $value) {
         $headers[strtolower($key)] = $value;
     }
     if (strlen($payload) == 0) {
         $headers['content-type'] = '';
     }
     $request = $this->client->put($uri, $headers, $payload, $options);
     $this->exec($request);
 }

 /**
  * {@inheritdoc}
  */
 public function makeRequest()
 {
     $json = $this->serializer->serialize($this->data, 'json');
     $client = new Client();
     $request = $client->put($this->url, array(), $json);
     $request->setHeader('Content-Type', 'application/json');
     $request->setHeader('Content-Length', strlen($json));
     $request->addHeader('Accept', 'application/json');
     $response = $request->send();
     if (!in_array($response->getStatusCode(), array(200, 201, 100))) {
         throw new \ErrorException($response->getMessage());
     }
     $responseObject = $this->serializer->deserialize($response->getBody(true), get_class($this->data), 'json');
     return $responseObject;
 }

 public function testHasHelpfulStaticFactoryMethod()
 {
     $s = fopen('php://temp', 'r+');
     $client = new Client();
     $client->addSubscriber(LogPlugin::getDebugPlugin(true, $s));
     $request = $client->put('http://foo.com', array('Content-Type' => 'Foo'), 'Bar');
     $request->setresponse(new Response(200), true);
     $request->send();
     rewind($s);
     $contents = stream_get_contents($s);
     $this->assertContains('# Request:', $contents);
     $this->assertContainsIns('PUT / HTTP/1.1', $contents);
     $this->assertContains('# Response:', $contents);
     $this->assertContainsIns('HTTP/1.1 200 OK', $contents);
     $this->assertContains('# Errors:', $contents);
 }