Creates an S3 PUT request.
<p>
<code>create PUT -&gt; requestObject</code>
</p>

@param aBucket An S3 bucket
@param aKey An S3 key
@param aHandler A response handler
@return An S3 PUT request
345463
public S3ClientRequest createPutRequest(final String aBucket, final String aKey,
            final Handler<HttpClientResponse> aHandler) {
        final HttpClientRequest httpRequest = myHTTPClient.put(PATH_SEP + aBucket + PATH_SEP + aKey, aHandler);
        return new S3ClientRequest("PUT", aBucket, aKey, httpRequest, myAccessKey, mySecretKey, mySessionToken);
    }
262916
public BoundRequestBuilder createRequest()
            throws HttpRequestCreateException {
        BoundRequestBuilder builder = null;

        getLogger().debug("AHC completeUrl " + requestUrl);

        try {

            switch (httpMethod) {
            case GET:
                builder = client.prepareGet(requestUrl);
                break;
            case POST:
                builder = client.preparePost(requestUrl);
                break;
            case PUT:
                builder = client.preparePut(requestUrl);
                break;
            case HEAD:
                builder = client.prepareHead(requestUrl);
                break;
            case OPTIONS:
                builder = client.prepareOptions(requestUrl);
                break;
            case DELETE:
                builder = client.prepareDelete(requestUrl);
                break;
            default:
                break;
            }

            PcHttpUtils.addHeaders(builder, this.httpHeaderMap);
            if (!Strings.isNullOrEmpty(postData)) {
                builder.setBody(postData);
                String charset = "";
                if (null!=this.httpHeaderMap) {
                    charset = this.httpHeaderMap.get("charset");
                }
                if(!Strings.isNullOrEmpty(charset)) {
                    builder.setBodyEncoding(charset);
                }
            }

        } catch (Exception t) {
            throw new HttpRequestCreateException(
                    "Error in creating request in Httpworker. "
                            + " If BoundRequestBuilder is null. Then fail to create.",
                    t);
        }

        return builder;

    }
597398
@Nonnull
  public FineUploaderBasic addCustomHeader (@Nonnull @Nonempty final String sKey, @Nonnull final String sValue)
  {
    ValueEnforcer.notEmpty (sKey, "Key");
    ValueEnforcer.notNull (sValue, "Value");

    m_aRequestCustomHeaders.put (sKey, sValue);
    return this;
  }
707603
private PutObjectRequest newPutObjectRequest(String key,
      ObjectMetadata metadata, InputStream inputStream) {
    PutObjectRequest putObjectRequest = new PutObjectRequest(mBucket, key,
        inputStream, metadata);
    return putObjectRequest;
  }
1164434
protected static void createS3Bucket() throws Exception {
        if (StringUtils.isNullOrEmpty(s3BucketName.trim())) {
            throw new IllegalArgumentException("Bucket name is empty. Please enter a bucket name "
                    + "in firehosetos3sample.properties file");
        }

        // Create S3 bucket if specified in the properties
        if (createS3Bucket) {
            s3Client.createBucket(s3BucketName);
            LOG.info("Created bucket " + s3BucketName + " in S3 to deliver Firehose records");
        }
    }
901666
public Acl updateDefaultBucketAcl(String bucketName) {
    // [START updateDefaultBucketAcl]
    Acl acl =
        storage.updateDefaultAcl(bucketName, Acl.of(User.ofAllAuthenticatedUsers(), Role.OWNER));
    // [END updateDefaultBucketAcl]
    return acl;
  }
772744
public Pairtree getPairtree(final String aBucket, final String aAccessKey, final String aSecretKey) {
        return new S3Pairtree(myVertx, aBucket, aAccessKey, aSecretKey);
    }
577555
public Acl createDefaultBucketAcl(String bucketName) {
    // [START createDefaultBucketAcl]
    Acl acl =
        storage.createDefaultAcl(bucketName, Acl.of(User.ofAllAuthenticatedUsers(), Role.READER));
    // [END createDefaultBucketAcl]
    return acl;
  }
330356
public void setObjectAcl(String bucketName, String key, String versionId,
            AccessControlList acl, RequestMetricCollector requestMetricCollector)
            throws SdkClientException, AmazonServiceException {
        setObjectAcl(new SetObjectAclRequest(bucketName, key, versionId, acl)
                .<SetObjectAclRequest> withRequestMetricCollector(requestMetricCollector));
    }
1104473
protected static void put(String resource, RequestParams params,
            ResponseHandler responseHandler) {
        WonderPushRestClient.put(resource, params, responseHandler);
    }
58973
@Override
    public TDClient withApiKey(String newApiKey)
    {
        return new TDClient(config, httpClient, Optional.of(newApiKey));
    }
1222227
@Nonnull
  public static UnifiedResponse createSimple (@Nonnull final HttpServletRequest aHttpRequest)
  {
    return new UnifiedResponse (RequestHelper.getHttpVersion (aHttpRequest),
                                RequestHelper.getHttpMethod (aHttpRequest),
                                aHttpRequest);
  }
1244990
private Chain<ApiRequest> createRequestChain(IAsyncHandler<ApiRequest> requestHandler) {
        RequestChain chain = new RequestChain(policyImpls, context);
        chain.headHandler(requestHandler);
        chain.policyFailureHandler(failure -> {
            // Jump straight to the response leg.
            // It will likely not have been initialised, so create one.
            if (responseChain == null) {
                // Its response will not be used as we take the failure path only, so we just use an empty lambda.
                responseChain = createResponseChain((ignored) -> {});
            }
            responseChain.doFailure(failure);
        });
        chain.policyErrorHandler(policyErrorHandler);
        return chain;
    }
1358029
public GitlabHTTPRequestor with(String key, Object value) {
        if (value != null && key != null) {
            data.put(key, value);
        }
        return this;
    }
982947
def put(url, params)
      params = convert_hash_keys(params)
      preform(url, :put, params: params) do
        return connection.put(url, params)
      end
    end
286965
public static StorageObjectSummary createFromS3ObjectSummary(S3ObjectSummary objSummary)
  {

    return new StorageObjectSummary(
        objSummary.getBucketName(),
        objSummary.getKey(),
        // S3 ETag is not always MD5, but since this code path is only
        // used in skip duplicate files in PUT command, It's not
        // critical to guarantee that it's MD5
        objSummary.getETag(),
        objSummary.getSize()
    );
  }
323389
public void dhtPutItem(byte[] publicKey, byte[] privateKey, Entry entry, byte[] salt) {
        s.dht_put_item(Vectors.bytes2byte_vector(publicKey),
                Vectors.bytes2byte_vector(privateKey),
                entry.swig(),
                Vectors.bytes2byte_vector(salt));
    }