Backblaze-B2V2Client
view release on metacpan or search on metacpan
- Enhance b2_list_file_names() to use options provided by the B2V2 API (thanks ESTRABD).
- Make sure all methods return a status value.
- Documentation improvements.
1.5 2021-06-22T04:30:22Z
- Create SSE / server-side encrypted buckets by default.
1.4 2020-09-06T03:42:42Z
- Include a 'b2_client' command line utility for easy download/upload of files
1.3 2020-08-04T17:01:21Z
- Add support for uploading large files (>100MB) via b2_upload_large_file
- Add tests during installation.
1.2 2020-06-24T04:44:05Z
- Fix for respecting 'new_file_name' when using 'file_contents' in b2_upload_file()
- Doc note on B2's new S3-compatible API
- Doc note on using slurp_raw in Path::Tiny when using 'file_contents' in b2_upload_file()
1.1 2019-05-09T04:06:37Z
- Auto-create option for b2_list_buckets
1.0 2019-05-05T03:06:08Z
- original version
# create an API client object
my $b2client = Backblaze::B2V2Client->new(
$application_key_id, $application_key
);
# please encrypt/protect those keys when not in use!
# let's say we have a B2 bucket called 'GingerAnna' and a JPG called 'ginger_was_perfect.jpg'.
# upload a file from your file system
my $operation_status = $b2client->b2_upload_file(
'bucket_name' => 'GingerAnna',
'file_location' => '/path/to/ginger_was_perfect.jpg'
);
# upload a file you have in a scalar
my $operation_status = $b2client->b2_upload_file(
'bucket_name' => 'GingerAnna',
'new_file_name' => 'ginger_was_perfect.jpg',
'file_contents' => $file_contents
);
# B2 file ID (fGUID) is now in $b2client->{b2_response}{fileId}
# Best to load $file_contents via Path::Tiny's slurp_raw() method
# download that file to /opt/majestica/tmp
my $operation_status = $b2client->b2_download_file_by_name('GingerAnna','ginger_was_perfect.jpg','/opt/majestica/tmp');
will need a key with Read and Write access. Be sure to note the Application Key
ID as well as the Application Key itself. They do not show you that Application
Key again, so copy it immediately.
Please store the Application Key pair in a secure way, preferably encrypted
when not in use by your software.
## b2\_client Command Line Utility
Backblaze::B2V2Client includes the 'b2\_client' command line utility to
easily download or upload files from B2. Please execute 'b2\_client help'
for more details, and here are a few examples:
# download a file to current directory
b2_client get MyPictures FamilyPhoto.jpg
# download a file to a target directory
b2_client get MyPictures FamilyPhoto.jpg /home/ginger/photos
# upload a file to B2
b2_client put MyPictures /home/ginger/photos/AnotherFamilyPhoto.jpg
There is also an official command line utility from Backblaze that does a
whole lot more:
https://www.backblaze.com/b2/docs/quick_command_line.html
## BackBlaze B2 also has a S3-compatible API
Backblaze has added an S3-compatible API, which you can read about here:
See https://www.backblaze.com/b2/docs/b2\_download\_file\_by\_id.html
## b2\_download\_file\_by\_name
Works like b2\_download\_file\_by\_id() except that it expects the bucket name
and file name as arguments. The optional third argument is an existing
directory path for auto-saving the file.
See https://www.backblaze.com/b2/docs/b2\_download\_file\_by\_name.html
## b2\_upload\_file
Uploads a new file into B2. Accepts a hash of arguments. The name
of the destination bucket must be provided in 'bucket\_name'.
If you would like to upload a file already saved on disk, specify
the complete file path in 'file\_location'. Alternatively, if the file
is loaded up into a scalar, provide the new file name in 'new\_file\_name'
and assign the loaded scalar into 'file\_contents'.
Example 1: Uploading from a file on disk:
my $operation_status = $b2client->b2_upload_file(
'bucket_name' => 'GingerAnna',
'file_location' => '/opt/majestica/tmp/ginger_was_perfect.jpg',
);
Example 2: Uploading when the file is loaded into a scalar:
my $operation_status = $b2client->b2_upload_file(
'bucket_name' => 'GingerAnna',
'new_file_name' => 'ginger_was_perfect.jpg',
'file_contents' => $file_contents
);
NOTE: If you are going to use the 'file\_contents' method, it's best
to load the scalar using the 'slurp\_raw' method in Path::Tiny.
(I believe 'read\_file' in File::Slurp will work, but have yet to test.)
You can also pass a 'content-type' key with the MIME type for the new
file. The default is 'b2/auto'.
Upon a successful upload, the new GUID for the file will be available
in $b2client->{b2\_response}{fileId} .
See: https://www.backblaze.com/b2/docs/b2\_upload\_file.html
## b2\_upload\_large\_file
Uploads a large file into B2. Recommended for uploading files larger
than 100MB. Accepts a hash of arguments, which
must include the name of the destination bucket in 'bucket\_name'
and the complete file path of the file in 'file\_location'.
Example:
my $operation_status = $b2client->b2_upload_large_file(
'bucket_name' => 'GingerAnna',
'file_location' => '/opt/majestica/tmp/gingers_whole_life_story.mp4',
);
## b2\_list\_file\_names
Required input is `$bucket_name` as the first parameter (required) and
an optional key-value hash of parameters. These parameters can include:
- `prefix`
See: https://www.backblaze.com/b2/docs/b2\_delete\_bucket.html
Example:
my $operation_status = $b2client->b2_delete_bucket('DeletingBucketName');
## b2\_delete\_file\_version
Deletes a version of a file, AKA a stored object. If you use unique
file names for each file you upload, then one version equals one file.
If you upload multiple files with the same name under a single bucket,
you will create multiple versions of a particular file in B2.
The required arguments are the file name and the file ID.
Example:
my $operation_status = $b2client->b2_delete_file_version('SomeFileName.ext','AN84_CHAR_GUID_FROM_B2');
## b2\_talker / b2\_get\_upload\_url / b2\_list\_buckets
b2\_talker() handles all the communications with B2.
You should be able to use this to make calls not explicitly
provided by this library.
If b2\_talker() gets a 200 HTTP status from B2, then the call went
great, the JSON response will be loaded into $b2client->{b2\_response},
and $b2client->{current\_status} will be set to 'OK'.
If a 200 is not received from B2, $b2client->{current\_status} will be
'url' => 'https://SomeB2.API.URL',
'authorization' => $b2client->{account_authorization_token},
'post_params' => {
'param1_name' => 'param1_value',
'param2_name' => 'param2_value',
'param3_name' => 'param3_value',
},
);
Almost all the API calls use the Account Authorization Token for the
authorization header, but the file uploader calls require a bucket-specific
token and upload URL. You can retrieve these via b2\_get\_upload\_url()
with the bucket name as an argument.
Example:
my $operation_status = $b2client->b2_get_upload_url('MyBucketName');
This populates:
my $operation_status = $b2client->{bucket_info}{'MyBucketName'} = {
'upload_url' => $b2client->{b2_response}{uploadUrl},
'authorization_token' => $b2client->{b2_response}{authorizationToken},
};
Note: You have to call b2\_get\_upload\_url on a bucket for each file
upload operation. My b2\_upload\_file method does that for you, so that's
just FYI if you roll your own.
See: https://www.backblaze.com/b2/docs/b2\_get\_upload\_url.html
If you need the ID for one or more buckets, you can use b2\_list\_buckets. If
a bucket name is provided, only that bucket's ID will be retrieved. If no
argument is provided, all the ID's will be retrieved for all buckets in your
account.
Example:
my $operation_status = $b2client->b2_list_buckets('MyBucketName');
Backblaze::B2 - V1 API Client for B2
Paws::S3 - If using Backblaze's S3-compatible API.
# AUTHOR / BUGS
Eric Chernoff <ericschernoff@gmail.com> - Please send me a note with any bugs or suggestions.
ESTRABD <estrabd@cpan.org> - Enhanced b2\_list\_file\_names() to fully use options and a great bugfix
when using the 'file\_contents' option in the b2\_upload\_file() method.
# LICENSE
MIT License
Copyright (c) 2021 Eric Chernoff
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modi...
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
lib/Backblaze/B2V2Client.pm view on Meta::CPAN
package Backblaze::B2V2Client;
# API client library for V2 of the API to Backblaze B2 object storage
# Allows for creating/deleting buckets, listing files in buckets, and uploading/downloading files
$Backblaze::B2V2Client::VERSION = '1.7';
# our dependencies:
use Cpanel::JSON::XS;
use Digest::SHA qw(sha1_hex);
use MIME::Base64;
use Path::Tiny;
use URI::Escape;
use WWW::Mechanize;
lib/Backblaze/B2V2Client.pm view on Meta::CPAN
# call the b2_talker() method to authenticate our session
$self->b2_talker('url' => 'https://api.backblazeb2.com/b2api/v2/b2_authorize_account' );
# if we succeeded, load in our authentication and prepare to proceed
if ($self->{current_status} eq 'OK') {
$self->{account_id} = $self->{b2_response}{accountId};
$self->{api_url} = $self->{b2_response}{apiUrl};
$self->{account_authorization_token} = $self->{b2_response}{authorizationToken};
$self->{download_url} = $self->{b2_response}{downloadUrl};
# for uploading large files
$self->{recommended_part_size} = $self->{b2_response}{recommendedPartSize} || 104857600;
# ready!
# otherwise, not ready!
} else {
$self->{b2_login_error} = 1;
}
# return current status
return $self->{current_status};
lib/Backblaze/B2V2Client.pm view on Meta::CPAN
$save_to_location .= '/'.$self->{b2_response}{'X-Bz-File-Name'};
# i really love Path::Tiny
path($save_to_location)->spew_raw( $self->{b2_response}{file_contents} );
# return current status
return $self->{current_status};
}
# method to upload a file into Backblaze B2
sub b2_upload_file {
my $self = shift;
my (%args) = @_;
# this must include valid entries for 'new_file_name' and 'bucket_name'
# and it has to include either the raw file contents in 'file_contents'
# or a valid location in 'file_location'
# also, you can include 'content_type' (which would be the MIME Type'
# if you do not want B2 to auto-determine the MIME/content-type
# did they provide a file location or path?
if ($args{file_location} && -e "$args{file_location}") {
$args{file_contents} = path( $args{file_location} )->slurp_raw;
# if they didn't provide a file-name, use the one on this file
$args{new_file_name} = path( $args{file_location} )->basename;
}
# were these file contents either provided or found?
if (!length($args{file_contents})) {
$self->error_tracker(qq{You must provide either a valid 'file_location' or 'file_contents' arg for b2_upload_file().});
return 'Error';
}
# check the other needed args
if (!$args{bucket_name} || !$args{new_file_name}) {
$self->error_tracker(qq{You must provide 'bucket_name' and 'new_file_name' args for b2_upload_file().});
return 'Error';
}
# default content-type
$args{content_type} ||= 'b2/x-auto';
# OK, let's continue: get the upload URL and authorization token for this bucket
$self->b2_get_upload_url( $args{bucket_name} );
# send the special request
$self->b2_talker(
'url' => $self->{bucket_info}{ $args{bucket_name} }{upload_url},
'authorization' => $self->{bucket_info}{ $args{bucket_name} }{authorization_token},
'file_contents' => $args{file_contents},
'special_headers' => {
'X-Bz-File-Name' => uri_escape( $args{new_file_name} ),
'X-Bz-Content-Sha1' => sha1_hex( $args{file_contents} ),
'Content-Type' => $args{content_type},
},
);
# b2_talker will handle the rest
# return current status
return $self->{current_status};
}
# method to get the information needed to upload into a specific B2 bucket
sub b2_get_upload_url {
my $self = shift;
# the bucket name is required
my ($bucket_name) = @_;
# bucket_name is required
if (!$bucket_name) {
$self->error_tracker('The bucket_name must be provided for b2_get_upload_url().');
return $self->{current_status};
}
# no need to proceed if we already have done for this bucket this during this session
# return if $self->{bucket_info}{$bucket_name}{upload_url};
# COMMENTED OUT: It seems like B2 wants a new upload_url endpoint for each upload,
# and we may want to upload multiple files into each bucket...so this won't work
# if we don't have the info for the bucket name, retrieve the bucket's ID
if (ref($self->{buckets}{$bucket_name}) ne 'HASH') {
$self->b2_list_buckets($bucket_name);
}
# send the request
$self->b2_talker(
'url' => $self->{api_url}.'/b2api/v2/b2_get_upload_url',
'authorization' => $self->{account_authorization_token},
'post_params' => {
'bucketId' => $self->{buckets}{$bucket_name}{bucket_id},
},
);
# if we succeeded, get the info for this bucket
if ($self->{current_status} eq 'OK') {
$self->{bucket_info}{$bucket_name} = {
'upload_url' => $self->{b2_response}{uploadUrl},
'authorization_token' => $self->{b2_response}{authorizationToken},
};
}
# send the status for consistency
return $self->{current_status};
}
lib/Backblaze/B2V2Client.pm view on Meta::CPAN
'post_params' => {
'fileName' => $file_name,
'fileId' => $file_id,
},
);
return $self->{current_status};
}
# method to upload a large file (>100MB)
sub b2_upload_large_file {
my $self = shift;
my (%args) = @_;
# this must include valid entries for 'new_file_name' and 'bucket_name'
# and it has to a valid location in 'file_location' (Do not load in file contents)
# also, you can include 'content_type' (which would be the MIME Type'
# if you do not want B2 to auto-determine the MIME/content-type
# did they provide a file location or path?
if ($args{file_location} && -e "$args{file_location}") {
# if they didn't provide a file-name, use the one on this file
$args{new_file_name} = path( $args{file_location} )->basename;
} else {
$self->error_tracker(qq{You must provide a valid 'file_location' arg for b2_upload_large_file().});
return $self->{current_status};
}
# protect my sanity...
my ($bucket_name, $file_contents_part, $file_location, $large_file_id, $part_number, $remaining_file_size, $sha1_array, $size_sent, $stat);
$file_location = $args{file_location};
$bucket_name = $args{bucket_name};
# must be 100MB or bigger
$stat = path($file_location)->stat;
if ($stat->size < $self->{recommended_part_size} ) {
$self->error_tracker(qq{Please use b2_upload_large_file() for files larger than $self->{recommended_part_size} .});
return $self->{current_status};
}
# need a bucket name
if (!$bucket_name) {
$self->error_tracker(qq{You must provide a valid 'bucket_name' arg for b2_upload_large_file().});
return $self->{current_status};
}
# default content-type
$args{content_type} ||= 'b2/x-auto';
# get the bucket ID
$self->b2_list_buckets($bucket_name);
# kick off the upload in the API
$self->b2_talker(
'url' => $self->{api_url}.'/b2api/v2/b2_start_large_file',
'authorization' => $self->{account_authorization_token},
'post_params' => {
'bucketId' => $self->{buckets}{$bucket_name}{bucket_id},
'fileName' => $args{new_file_name},
'contentType' => $args{content_type},
},
);
# these are all needed for each b2_upload_part web call
$large_file_id = $self->{b2_response}{fileId};
return 'Error' if !$large_file_id; # there was an error in the request
# open the large file
open(FH, $file_location);
$remaining_file_size = $stat->size;
$part_number = 1;
# cycle thru each chunk of the file
while ($remaining_file_size >= 0) {
# how much to send?
if ($remaining_file_size < $self->{recommended_part_size} ) {
$size_sent = $remaining_file_size;
} else {
$size_sent = $self->{recommended_part_size} ;
}
# get the next upload url for this part
$self->b2_talker(
'url' => $self->{api_url}.'/b2api/v2/b2_get_upload_part_url',
'authorization' => $self->{account_authorization_token},
'post_params' => {
'fileId' => $large_file_id,
},
);
# read in that section of the file and prep the SHA
sysread FH, $file_contents_part, $size_sent;
push(@$sha1_array,sha1_hex( $file_contents_part ));
# upload that part
$self->b2_talker(
'url' => $self->{b2_response}{uploadUrl},
'authorization' => $self->{b2_response}{authorizationToken},
'special_headers' => {
'X-Bz-Content-Sha1' => $$sha1_array[-1],
'X-Bz-Part-Number' => $part_number,
'Content-Length' => $size_sent,
},
'file_contents' => $file_contents_part,
);
# advance
lib/Backblaze/B2V2Client.pm view on Meta::CPAN
return $self->{current_status};
}
# generic method to handle communication to B2
sub b2_talker {
my $self = shift;
# args hash must include 'url' for the target API endpoint URL
# most other requests will also include a 'post_params' hashref, and 'authorization' value for the header
# for the b2_upload_file function, there will be several other headers + a file_contents arg
my (%args) = @_;
if (!$args{url}) {
$self->error_tracker('Can not use b2_talker() without an endpoint URL.');
}
# if they sent an Authorization header, set that value
if ($args{authorization}) {
$self->{mech}->delete_header( 'Authorization' );
$self->{mech}->add_header( 'Authorization' => $args{authorization} );
lib/Backblaze/B2V2Client.pm view on Meta::CPAN
# short-circuit if we had difficulty logging in previously
if ($self->{b2_login_error}) {
# track the error / set current state
$self->error_tracker("Problem logging into Backblaze. Please check the 'errors' array in this object.", $args{url});
return $self->{current_status};
}
# are we uploading a file?
if ($args{url} =~ /b2_upload_file|b2_upload_part/) {
# add the special headers
@header_keys = keys %{ $args{special_headers} };
foreach $header (@header_keys) {
$self->{mech}->delete_header( $header );
$self->{mech}->add_header( $header => $args{special_headers}{$header} );
}
# now upload the file
eval {
$response = $self->{mech}->post( $args{url}, content => $args{file_contents} );
# we want this to be 200
$response_code = $response->{_rc};
$self->{b2_response} = decode_json( $self->{mech}->content() );
};
# remove those special headers, cleaned-up for next time
foreach $header (@header_keys) {
$self->{mech}->delete_header( $header );
}
# if not uploading and they sent POST params, we are doing a POST
} elsif (ref($args{post_params}) eq 'HASH') {
eval {
# send the POST
$response = $self->{mech}->post( $args{url}, content => encode_json($args{post_params}) );
# we want this to be 200
$response_code = $response->code;
# decode results
$self->{b2_response} = decode_json( $self->{mech}->content() );
lib/Backblaze/B2V2Client.pm view on Meta::CPAN
# create an API client object
my $b2client = Backblaze::B2V2Client->new(
$application_key_id, $application_key
);
# please encrypt/protect those keys when not in use!
# let's say we have a B2 bucket called 'GingerAnna' and a JPG called 'ginger_was_perfect.jpg'.
# upload a file from your file system
my $operation_status = $b2client->b2_upload_file(
'bucket_name' => 'GingerAnna',
'file_location' => '/path/to/ginger_was_perfect.jpg'
);
# upload a file you have in a scalar
my $operation_status = $b2client->b2_upload_file(
'bucket_name' => 'GingerAnna',
'new_file_name' => 'ginger_was_perfect.jpg',
'file_contents' => $file_contents
);
# B2 file ID (fGUID) is now in $b2client->{b2_response}{fileId}
# Best to load $file_contents via Path::Tiny's slurp_raw() method
# download that file to /opt/majestica/tmp
my $operation_status = $b2client->b2_download_file_by_name('GingerAnna','ginger_was_perfect.jpg','/opt/majestica/tmp');
lib/Backblaze/B2V2Client.pm view on Meta::CPAN
will need a key with Read and Write access. Be sure to note the Application Key
ID as well as the Application Key itself. They do not show you that Application
Key again, so copy it immediately.
Please store the Application Key pair in a secure way, preferably encrypted
when not in use by your software.
=head2 b2_client Command Line Utility
Backblaze::B2V2Client includes the 'b2_client' command line utility to
easily download or upload files from B2. Please execute 'b2_client help'
for more details, and here are a few examples:
# download a file to current directory
b2_client get MyPictures FamilyPhoto.jpg
# download a file to a target directory
b2_client get MyPictures FamilyPhoto.jpg /home/ginger/photos
# upload a file to B2
b2_client put MyPictures /home/ginger/photos/AnotherFamilyPhoto.jpg
There is also an official command line utility from Backblaze that does a
whole lot more:
https://www.backblaze.com/b2/docs/quick_command_line.html
=head2 BackBlaze B2 also has a S3-compatible API
Backblaze has added an S3-compatible API, which you can read about here:
lib/Backblaze/B2V2Client.pm view on Meta::CPAN
See https://www.backblaze.com/b2/docs/b2_download_file_by_id.html
=head2 b2_download_file_by_name
Works like b2_download_file_by_id() except that it expects the bucket name
and file name as arguments. The optional third argument is an existing
directory path for auto-saving the file.
See https://www.backblaze.com/b2/docs/b2_download_file_by_name.html
=head2 b2_upload_file
Uploads a new file into B2. Accepts a hash of arguments. The name
of the destination bucket must be provided in 'bucket_name'.
If you would like to upload a file already saved on disk, specify
the complete file path in 'file_location'. Alternatively, if the file
is loaded up into a scalar, provide the new file name in 'new_file_name'
and assign the loaded scalar into 'file_contents'.
Example 1: Uploading from a file on disk:
my $operation_status = $b2client->b2_upload_file(
'bucket_name' => 'GingerAnna',
'file_location' => '/opt/majestica/tmp/ginger_was_perfect.jpg',
);
Example 2: Uploading when the file is loaded into a scalar:
my $operation_status = $b2client->b2_upload_file(
'bucket_name' => 'GingerAnna',
'new_file_name' => 'ginger_was_perfect.jpg',
'file_contents' => $file_contents
);
NOTE: If you are going to use the 'file_contents' method, it's best
to load the scalar using the 'slurp_raw' method in Path::Tiny.
(I believe 'read_file' in File::Slurp will work, but have yet to test.)
You can also pass a 'content-type' key with the MIME type for the new
file. The default is 'b2/auto'.
Upon a successful upload, the new GUID for the file will be available
in $b2client->{b2_response}{fileId} .
See: https://www.backblaze.com/b2/docs/b2_upload_file.html
=head2 b2_upload_large_file
Uploads a large file into B2. Recommended for uploading files larger
than 100MB. Accepts a hash of arguments, which
must include the name of the destination bucket in 'bucket_name'
and the complete file path of the file in 'file_location'.
Example:
my $operation_status = $b2client->b2_upload_large_file(
'bucket_name' => 'GingerAnna',
'file_location' => '/opt/majestica/tmp/gingers_whole_life_story.mp4',
);
=head2 b2_list_file_names
Required input is C<$bucket_name> as the first parameter (required) and
an optional key-value hash of parameters. These parameters can include:
=over 3
lib/Backblaze/B2V2Client.pm view on Meta::CPAN
See: https://www.backblaze.com/b2/docs/b2_delete_bucket.html
Example:
my $operation_status = $b2client->b2_delete_bucket('DeletingBucketName');
=head2 b2_delete_file_version
Deletes a version of a file, AKA a stored object. If you use unique
file names for each file you upload, then one version equals one file.
If you upload multiple files with the same name under a single bucket,
you will create multiple versions of a particular file in B2.
The required arguments are the file name and the file ID.
Example:
my $operation_status = $b2client->b2_delete_file_version('SomeFileName.ext','AN84_CHAR_GUID_FROM_B2');
=head2 b2_talker / b2_get_upload_url / b2_list_buckets
b2_talker() handles all the communications with B2.
You should be able to use this to make calls not explicitly
provided by this library.
If b2_talker() gets a 200 HTTP status from B2, then the call went
great, the JSON response will be loaded into $b2client->{b2_response},
and $b2client->{current_status} will be set to 'OK'.
If a 200 is not received from B2, $b2client->{current_status} will be
lib/Backblaze/B2V2Client.pm view on Meta::CPAN
'url' => 'https://SomeB2.API.URL',
'authorization' => $b2client->{account_authorization_token},
'post_params' => {
'param1_name' => 'param1_value',
'param2_name' => 'param2_value',
'param3_name' => 'param3_value',
},
);
Almost all the API calls use the Account Authorization Token for the
authorization header, but the file uploader calls require a bucket-specific
token and upload URL. You can retrieve these via b2_get_upload_url()
with the bucket name as an argument.
Example:
my $operation_status = $b2client->b2_get_upload_url('MyBucketName');
This populates:
my $operation_status = $b2client->{bucket_info}{'MyBucketName'} = {
'upload_url' => $b2client->{b2_response}{uploadUrl},
'authorization_token' => $b2client->{b2_response}{authorizationToken},
};
Note: You have to call b2_get_upload_url on a bucket for each file
upload operation. My b2_upload_file method does that for you, so that's
just FYI if you roll your own.
See: https://www.backblaze.com/b2/docs/b2_get_upload_url.html
If you need the ID for one or more buckets, you can use b2_list_buckets. If
a bucket name is provided, only that bucket's ID will be retrieved. If no
argument is provided, all the ID's will be retrieved for all buckets in your
account.
Example:
my $operation_status = $b2client->b2_list_buckets('MyBucketName');
lib/Backblaze/B2V2Client.pm view on Meta::CPAN
Backblaze::B2 - V1 API Client for B2
Paws::S3 - If using Backblaze's S3-compatible API.
=head1 AUTHOR / BUGS
Eric Chernoff <ericschernoff@gmail.com> - Please send me a note with any bugs or suggestions.
ESTRABD <estrabd@cpan.org> - Enhanced b2_list_file_names() to fully use options and a great bugfix
when using the 'file_contents' option in the b2_upload_file() method.
=head1 LICENSE
MIT License
Copyright (c) 2021 Eric Chernoff
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modi...
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
script/b2_client view on Meta::CPAN
use warnings;
use Backblaze::B2V2Client;
use Path::Tiny;
use Cwd;
# i just love use-warnings
my $dispatch = {
'get' => 'download_file',
'put' => 'upload_file',
'list' => 'list_buckets',
'new_bucket' => 'new_bucket',
'save_tokens' => 'save_b2_tokens',
'help' => 'print_help',
};
$ARGV[0] ||= 'help';
my $subroutine = $$dispatch{ $ARGV[0] } || 'print_help';
script/b2_client view on Meta::CPAN
if (!$args[0] || !$args[1]) {
die "Usage: b2_client get BUCKET_NAME FILE_NAME [DESTINATION_DIRECTORY]\n";
}
# destination directory is optional
if (!$args[2]) {
$args[2] = getcwd;
}
# log in and upload the file
my $b2client = get_b2_session();
$b2client->b2_download_file_by_name(@args);
# print error or success
if ($b2client->{current_status} ne 'OK') {
print get_error_message($b2client);
} else {
print "Success: $args[1] saved to $args[2]\n";
}
}
sub upload_file {
my (@args) = @_;
if (!$args[0] || !$args[1]) {
die "Usage: b2_client put BUCKET_NAME PATH_TO_FILE\n";
}
# login in and upload the file
my $b2client = get_b2_session();
$b2client->b2_upload_file(
'bucket_name' => $args[0],
'file_location' => $args[1],
);
# print error or success
if ($b2client->{current_status} ne 'OK') {
print get_error_message($b2client);
} else {
print "Success: $args[1] uploaded to bucket $args[0]\n";
}
}
sub list_buckets {
# log in and retrieve the buckets
my $b2client = get_b2_session();
$b2client->b2_list_buckets();
# print error if needed
script/b2_client view on Meta::CPAN
print "Success: New bucket '$args[0]' was created.\n";
}
}
sub print_help {
print qq{
b2_client: Simple Backblaze B2 client
This utility can download and upload files from the Backblaze B2 service. It is part of Backblaze::B2V2Client Perl library - https://metacpan.org/pod/Backblaze::B2V2Client
# b2_client save_tokens APPLICATION_KEY_ID APPLICATION_KEY
Both arguments are required. Saves your B2 API key tokens to ~/.b2_tokens . Provision a key under 'App Keys' in the B2 Web UI. Choose carefully on the privileges you wish to give this app key, bearing in mind that the client can only complete the op...
# b2_client get BUCKET_NAME FILE_NAME [DESTINATION_DIRECTORY]
Downloads a file from B2. Required arguments are the name of the bucket containing the file and the name of the file in B2 (not the ID). Optional third argument is a destination directory, defaulting to the current working directory. Be sure you can ...
# b2_client put BUCKET_NAME PATH_TO_FILE
Upload a file to B2. Required arguments are the name of the destination B2 bucket and the path to the file to be uploaded. Best if the file has a standard extension (i.e. .txt, .png, .js, etc.)
# b2_client list
Lists the B2 buckets in your account.
# b2_client new_bucket BUCKET_NAME
Creates a new B2 Bucket with the given name. Alphanumeric characters only.
# b2_client help
( run in 2.399 seconds using v1.01-cache-2.11-cpan-b16cb0d3907 )