Class: Aws::Glacier::MultipartUpload

Inherits:
Object
  • Object
show all
Extended by:
Deprecations
Defined in:
lib/aws-sdk-glacier/multipart_upload.rb

Defined Under Namespace

Classes: Collection

Read-Only Attributes collapse

Actions collapse

Associations collapse

Instance Method Summary collapse

Constructor Details

#initialize(account_id, vault_name, id, options = {}) ⇒ MultipartUpload #initialize(options = {}) ⇒ MultipartUpload

Returns a new instance of MultipartUpload.

Overloads:

  • #initialize(account_id, vault_name, id, options = {}) ⇒ MultipartUpload

    Parameters:

    • account_id (String)
    • vault_name (String)
    • id (String)

    Options Hash (options):

  • #initialize(options = {}) ⇒ MultipartUpload

    Options Hash (options):

    • :account_id (required, String)
    • :vault_name (required, String)
    • :id (required, String)
    • :client (Client) 


26
27
28
29
30
31
32
33
34
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 26

def initialize(*args)
  options = Hash === args.last ? args.pop.dup : {}
  @account_id = (args, options)
  @vault_name = extract_vault_name(args, options)
  @id = extract_id(args, options)
  @data = options.delete(:data)
  @client = options.delete(:client) || Client.new(options)
  @waiter_block_warned = false
end

Instance Method Details

#abort(options = {}) ⇒ EmptyStructure

Examples:

Request syntax with placeholder values


multipart_upload.abort()

Parameters:

  • options (Hash) (defaults to: {}) —

    ({})

Returns:

  • (EmptyStructure) 


217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 217

def abort(options = {})
  options = options.merge(
    account_id: @account_id,
    vault_name: @vault_name,
    upload_id: @id
  )
  resp = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
    @client.abort_multipart_upload(options)
  end
  resp.data
end

#account_id ⇒ String

Returns:

  • (String) 


39
40
41
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 39

def 
  @account_id
end

#archive_description ⇒ String

The description of the archive that was specified in the Initiate Multipart Upload request.

Returns:

  • (String) 


63
64
65
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 63

def archive_description
  data[:archive_description]
end

#client ⇒ Client

Returns:



84
85
86
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 84

def client
  @client
end

#complete(options = {}) ⇒ Types::ArchiveCreationOutput

Examples:

Request syntax with placeholder values


multipart_upload.complete({
  archive_size: 1,
  checksum: "string",
})

Parameters:

  • options (Hash) (defaults to: {}) —

    ({})

Options Hash (options):

  • :archive_size (Integer) —

    The total size, in bytes, of the entire archive. This value should be the sum of all the sizes of the individual parts that you uploaded.

  • :checksum (String) —

    The SHA256 tree hash of the entire archive. It is the tree hash of SHA256 tree hash of the individual parts. If the value you specify in the request does not match the SHA256 tree hash of the final assembled archive as computed by Amazon S3 Glacier (Glacier), Glacier returns an error and the request fails.

Returns:



246
247
248
249
250
251
252
253
254
255
256
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 246

def complete(options = {})
  options = options.merge(
    account_id: @account_id,
    vault_name: @vault_name,
    upload_id: @id
  )
  resp = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
    @client.complete_multipart_upload(options)
  end
  resp.data
end

#creation_date ⇒ Time

The UTC time at which the multipart upload was initiated.

Returns:

  • (Time) 


77
78
79
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 77

def creation_date
  data[:creation_date]
end

#data ⇒ Types::UploadListElement

Returns the data for this Aws::Glacier::MultipartUpload.

Returns:

Raises:

  • (NotImplementedError) —

    Raises when #data_loaded? is ‘false`.



99
100
101
102
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 99

def data
  load unless @data
  @data
end

#data_loaded? ⇒ Boolean

Returns ‘true` if this resource is loaded. Accessing attributes or #data on an unloaded resource will trigger a call to #load.

Returns:

  • (Boolean) —

    Returns ‘true` if this resource is loaded. Accessing attributes or #data on an unloaded resource will trigger a call to #load.



107
108
109
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 107

def data_loaded?
  !!@data
end

#id ⇒ String Also known as: multipart_upload_id

Returns:

  • (String) 


49
50
51
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 49

def id
  @id
end

#identifiers ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Deprecated. 


332
333
334
335
336
337
338
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 332

def identifiers
  {
    account_id: @account_id,
    vault_name: @vault_name,
    id: @id
  }
end

#load ⇒ Object Also known as: reload

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Raises:

  • (NotImplementedError) 


90
91
92
93
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 90

def load
  msg = "#load is not implemented, data only available via enumeration"
  raise NotImplementedError, msg
end

#part_size_in_bytes ⇒ Integer

The part size, in bytes, specified in the Initiate Multipart Upload request. This is the size of all the parts in the upload except the last part, which may be smaller than this size.

Returns:

  • (Integer) 


71
72
73
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 71

def part_size_in_bytes
  data[:part_size_in_bytes]
end

#parts(options = {}) ⇒ Types::ListPartsOutput

Examples:

Request syntax with placeholder values


multipart_upload.parts({
  marker: "string",
  limit: 1,
})

Parameters:

  • options (Hash) (defaults to: {}) —

    ({})

Options Hash (options):

  • :marker (String) —

    An opaque string used for pagination. This value specifies the part at which the listing of parts should begin. Get the marker value from the response of a previous List Parts response. You need only include the marker if you are continuing the pagination of results started in a previous List Parts request.

  • :limit (Integer) —

    The maximum number of parts to be returned. The default limit is 50. The number of parts returned might be fewer than the specified limit, but the number of returned parts never exceeds the limit.

Returns:



276
277
278
279
280
281
282
283
284
285
286
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 276

def parts(options = {})
  options = options.merge(
    account_id: @account_id,
    vault_name: @vault_name,
    upload_id: @id
  )
  resp = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
    @client.list_parts(options)
  end
  resp.data
end

#upload_part(options = {}) ⇒ Types::UploadMultipartPartOutput

Examples:

Request syntax with placeholder values


multipart_upload.upload_part({
  checksum: "string",
  range: "string",
  body: "data",
})

Parameters:

  • options (Hash) (defaults to: {}) —

    ({})

Options Hash (options):

  • :checksum (String) —

    The SHA256 tree hash of the data being uploaded.

  • :range (String) —

    Identifies the range of bytes in the assembled archive that will be uploaded in this part. Amazon S3 Glacier uses this information to assemble the archive in the proper sequence. The format of this header follows RFC 2616. An example header is Content-Range:bytes 0-4194303/*.

  • :body (String, StringIO, File) —

    The data to upload.

Returns:



307
308
309
310
311
312
313
314
315
316
317
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 307

def upload_part(options = {})
  options = options.merge(
    account_id: @account_id,
    vault_name: @vault_name,
    upload_id: @id
  )
  resp = Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
    @client.upload_multipart_part(options)
  end
  resp.data
end

#vault ⇒ Vault

Returns:



322
323
324
325
326
327
328
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 322

def vault
  Vault.new(
    account_id: @account_id,
    name: @vault_name,
    client: @client
  )
end

#vault_arn ⇒ String

The Amazon Resource Name (ARN) of the vault that contains the archive.

Returns:

  • (String) 


56
57
58
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 56

def vault_arn
  data[:vault_arn]
end

#vault_name ⇒ String

Returns:

  • (String) 


44
45
46
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 44

def vault_name
  @vault_name
end

#wait_until(options = {}) {|resource| ... } ⇒ Resource

Deprecated.

Use [Aws::Glacier::Client] #wait_until instead

Note:

The waiting operation is performed on a copy. The original resource remains unchanged.

Waiter polls an API operation until a resource enters a desired state.

## Basic Usage

Waiter will polls until it is successful, it fails by entering a terminal state, or until a maximum number of attempts are made.

# polls in a loop until condition is true
resource.wait_until(options) {|resource| condition}

## Example

instance.wait_until(max_attempts:10, delay:5) do |instance|
  instance.state.name == 'running'
end

## Configuration

You can configure the maximum number of polling attempts, and the delay (in seconds) between each polling attempt. The waiting condition is set by passing a block to #wait_until:

# poll for ~25 seconds
resource.wait_until(max_attempts:5,delay:5) {|resource|...}

## Callbacks

You can be notified before each polling attempt and before each delay. If you throw ‘:success` or `:failure` from these callbacks, it will terminate the waiter.

started_at = Time.now
# poll for 1 hour, instead of a number of attempts
proc = Proc.new do |attempts, response|
  throw :failure if Time.now - started_at > 3600
end

  # disable max attempts
instance.wait_until(before_wait:proc, max_attempts:nil) {...}

## Handling Errors

When a waiter is successful, it returns the Resource. When a waiter fails, it raises an error.

begin
  resource.wait_until(...)
rescue Aws::Waiters::Errors::WaiterFailed
  # resource did not enter the desired state in time
end

attempts attempt in seconds invoked before each attempt invoked before each wait

Parameters:

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :max_attempts (Integer) — default: 10 —

    Maximum number of

  • :delay (Integer) — default: 10 —

    Delay between each

  • :before_attempt (Proc) — default: nil —

    Callback

  • :before_wait (Proc) — default: nil —

    Callback

Yield Parameters:

  • resource (Resource) —

    to be used in the waiting condition.

Returns:

  • (Resource) —

    if the waiter was successful

Raises:

  • (Aws::Waiters::Errors::FailureStateError) —

    Raised when the waiter terminates because the waiter has entered a state that it will not transition out of, preventing success.

    yet successful.

  • (Aws::Waiters::Errors::UnexpectedError) —

    Raised when an error is encountered while polling for a resource that is not expected.

  • (NotImplementedError) —

    Raised when the resource does not



191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
 
# File 'lib/aws-sdk-glacier/multipart_upload.rb', line 191

def wait_until(options = {}, &block)
  self_copy = self.dup
  attempts = 0
  options[:max_attempts] = 10 unless options.key?(:max_attempts)
  options[:delay] ||= 10
  options[:poller] = Proc.new do
    attempts += 1
    if block.call(self_copy)
      [:success, self_copy]
    else
      self_copy.reload unless attempts == options[:max_attempts]
      :retry
    end
  end
  Aws::Plugins::UserAgent.metric('RESOURCE_MODEL') do
    Aws::Waiters::Waiter.new(options).wait({})
  end
end