b2_finish_large_file

Code

FILE_ID=''; # Provided by b2_start_large_file
ACCOUNT_AUTHORIZATION_TOKEN=''; # Provided by b2_authorize_acount
PART_SHA1_ARRAY=('<sha1_part_1>' '<sha1_part_2>' '<sha1_part_3>');

# Create JSON
JSON='{ "partSha1Array":[';
for sha1 in "${PART_SHA1_ARRAY[@]}"; do
	JSON+="\"$sha1\",";
done
JSON="${JSON%?}";
JSON+="], \"fileId\":\"$FILE_ID\"}";

# Do the post
curl \
    -H "Authorization: $ACCOUNT_AUTHORIZATION_TOKEN" \
    -d "$JSON" \
    "$API_URL/b2api/v2/b2_finish_large_file"

Output

{
  "accountId": "YOUR_ACCOUNT_ID",
  "action": "upload",
  "bucketId": "e73ede9c9c8412db49f60715",
  "contentLength": 208158542,
  "contentSha1": "none",
  "contentType": "b2/x-auto",
  "fileId": "4_ze73ede9c9c8412db49f60715_f100b4e93fbae6252_d20150824_m224353_c900_v8881000_t0001",
  "fileInfo": {},
  "fileName": "bigfile.dat",
  "fileRetention": {
    "isClientAuthorizedToRead": true,
    "value": {
      "mode": null,
      "retainUntilTimestamp": null
    }
  },
  "legalHold": {
    "isClientAuthorizedToRead": true,
    "value": null
  },
  "serverSideEncryption": {
    "algorithm": null,
    "mode": null
  },
  "uploadTimestamp": 1460162909000
}

Code

import java.io.*;
import java.util.*;
import javax.json.*;
import java.math.BigInteger;
import java.net.HttpURLConnection;
import java.net.URL;

String fileId = ""; // Provided by b2_start_large_file
String accountAuthorizationToken = ""; // Provided by b2_authorize_account
String apiUrl = ""; // Provided by b2_authorize_account

ArrayList<String> partSha1Array = {"<sha1_of_part_1>","sha1_of_part_2","sha1_of_part_3"}; // See b2_upload_part

// Create Json
JsonArrayBuilder jsonArrayOfSha1Builder = Json.createArrayBuilder();
Enumeration<String> enumerator = Collections.enumeration(partSha1Array);
while(enumerator.hasMoreElements()) {
    jsonArrayOfSha1Builder.add(enumerator.nextElement());
}
JsonObject finishLargeFileJsonObj = Json.createObjectBuilder()
        .add("fileId", fileId)
        .add("partSha1Array", jsonArrayOfSha1Builder)
        .build();

StringWriter sw = new StringWriter();
JsonWriter jw = Json.createWriter(sw);
jw.write(finishLargeFileJsonObj);
jw.close();
postData = sw.toString();

try {
    URL url = new URL(apiUrl + "/b2api/v2/b2_finish_large_file");
    connection = (HttpURLConnection) url.openConnection();
    connection.setRequestMethod("POST");
    connection.setRequestProperty("Authorization", accountAuthorizationToken);
    connection.setRequestProperty("Charset", "UTF-8");
    connection.setRequestProperty("Content-Type", "application/json");
    connection.setDoOutput(true);
    DataOutputStream dataOutputStream = new DataOutputStream(connection.getOutputStream());
    dataOutputStream.writeBytes(postData);
    dataOutputStream.close();
    String jsonResponse = myInputStreamReader(connection.getInputStream());
    System.out.println(jsonResponse);
} catch(Exception ex) {
    ex.printStackTrace();
}

// Input stream reader example. 
static public String myInputStreamReader(InputStream in) throws IOException {
    InputStreamReader reader = new InputStreamReader(in);
    StringBuilder sb = new StringBuilder();
    int c = reader.read();
    while (c != -1) {
        sb.append((char)c);
        c = reader.read();
    }
    reader.close();
    return sb.toString();
}

Output

{
  "accountId": "YOUR_ACCOUNT_ID",
  "action": "upload",
  "bucketId": "e73ede9c9c8412db49f60715",
  "contentLength": 208158542,
  "contentSha1": "none",
  "contentType": "b2/x-auto",
  "fileId": "4_ze73ede9c9c8412db49f60715_f100b4e93fbae6252_d20150824_m224353_c900_v8881000_t0001",
  "fileInfo": {},
  "fileName": "bigfile.dat",
  "fileRetention": {
    "isClientAuthorizedToRead": true,
    "value": {
      "mode": null,
      "retainUntilTimestamp": null
    }
  },
  "legalHold": {
    "isClientAuthorizedToRead": true,
    "value": null
  },
  "serverSideEncryption": {
    "algorithm": null,
    "mode": null
  },
  "uploadTimestamp": 1460162909000
}

Code

import base64
import json
import urllib2

account_authorization_token = "" # Provided by b2_authorize_account
file_id = "" # Provided by b2_start_large_file
part_sha1_array = ["<sha1_of_part_1>","<sha1_of_part_2>","<sha1_of_part_3>"] # See b2_upload_part
request = urllib2.Request(
    '%s/b2api/v2/b2_finish_large_file' % api_url,
    json.dumps({ 'fileId' : file_id, 'partSha1Array': part_sha1_array}),
    headers = { 'Authorization': account_authorization_token }
)
response = urllib2.urlopen(request)
response_data = json.loads(response.read())
response.close()

Output

{
  "accountId": "YOUR_ACCOUNT_ID",
  "action": "upload",
  "bucketId": "e73ede9c9c8412db49f60715",
  "contentLength": 208158542,
  "contentSha1": "none",
  "contentType": "b2/x-auto",
  "fileId": "4_ze73ede9c9c8412db49f60715_f100b4e93fbae6252_d20150824_m224353_c900_v8881000_t0001",
  "fileInfo": {},
  "fileName": "bigfile.dat",
  "fileRetention": {
    "isClientAuthorizedToRead": true,
    "value": {
      "mode": null,
      "retainUntilTimestamp": null
    }
  },
  "legalHold": {
    "isClientAuthorizedToRead": true,
    "value": null
  },
  "serverSideEncryption": {
    "algorithm": null,
    "mode": null
  },
  "uploadTimestamp": 1460162909000
}

Code

import Foundation

let apiUrl = "" // Obtained from b2_authorize_account
let accountAuthorizationToken = "" // Provided by b2_authorize_account
let fileId = "" // Obtained from b2_start_large_file


let partSha1Array = ["<sha1_of_part_1>","<sha1_of_part_2>", "<sha1_of_part_3>"] // See b2_upload_part
let jsonBodyData: [String:Any] = ["fileId": fileId, "partSha1Array": partSha1Array]
let url = URL(string: "\(apiUrl)/b2api/v2/b2_finish_large_file")

// Create the request
var request = URLRequest(url: url!)
request.httpMethod = "POST"
request.addValue(accountAuthorizationToken, forHTTPHeaderField: "Authorization")
do {
	request.httpBody = try JSONSerialization.data(withJSONObject: jsonBodyData, options: .prettyPrinted)
} catch (let error) {
	print(error.localizedDescription)
}

// Create the task
let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
	if let data = data {
		let json = String(data: data, encoding: .utf8)
		print("\(json!)")
	}
}

// Start the task
task.resume()

// Swift 4.1 (swiftlang-902.0.48 clang-902.0.37.1) Xcode 9.3.1 (9E501)

Output

{
  "accountId": "YOUR_ACCOUNT_ID",
  "action": "upload",
  "bucketId": "e73ede9c9c8412db49f60715",
  "contentLength": 208158542,
  "contentSha1": "none",
  "contentType": "b2/x-auto",
  "fileId": "4_ze73ede9c9c8412db49f60715_f100b4e93fbae6252_d20150824_m224353_c900_v8881000_t0001",
  "fileInfo": {},
  "fileName": "bigfile.dat",
  "fileRetention": {
    "isClientAuthorizedToRead": true,
    "value": {
      "mode": null,
      "retainUntilTimestamp": null
    }
  },
  "legalHold": {
    "isClientAuthorizedToRead": true,
    "value": null
  },
  "serverSideEncryption": {
    "algorithm": null,
    "mode": null
  },
  "uploadTimestamp": 1460162909000
}

Code

require 'json'
require 'net/http'

file_id = "" # Provided by b2_start_large_file
sha1_of_parts = ["<sha1 of part 1>","<sha1 of part 2>"] # See b2_upload_part
account_authorization_token = "" # Provided by b2_authorize_account
uri = URI.join("#{api_url}/b2api/v2/b2_finish_large_file")
req = Net::HTTP::Post.new(uri)
req.add_field("Authorization","#{account_authorization_token}")
# NOTE: The array of sha1 for each part you sent using b2_upload_part
params = {"fileId" => fileId, "partSha1Array" => ["<sha1_of_part_1>","<sha1_of_part_2>"]}
jkljreq.body = dump(params)
http = Net::HTTP.new(req.uri.host, req.uri.port)
http.use_ssl = true
res = http.start {|http| http.request(req)}
case res
when Net::HTTPSuccess then
    res.body
when Net::HTTPRedirection then
    fetch(res['location'], limit - 1)
else
    res.error!
end

Output

{
  "accountId": "YOUR_ACCOUNT_ID",
  "action": "upload",
  "bucketId": "e73ede9c9c8412db49f60715",
  "contentLength": 208158542,
  "contentSha1": "none",
  "contentType": "b2/x-auto",
  "fileId": "4_ze73ede9c9c8412db49f60715_f100b4e93fbae6252_d20150824_m224353_c900_v8881000_t0001",
  "fileInfo": {},
  "fileName": "bigfile.dat",
  "fileRetention": {
    "isClientAuthorizedToRead": true,
    "value": {
      "mode": null,
      "retainUntilTimestamp": null
    }
  },
  "legalHold": {
    "isClientAuthorizedToRead": true,
    "value": null
  },
  "serverSideEncryption": {
    "algorithm": null,
    "mode": null
  },
  "uploadTimestamp": 1460162909000
}

Code

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Json;
using System.Runtime.Serialization;         

String authorizationToken = ""; // Provided by b2_authorize_account
String fileId = ""; // Provided by b2_start_large_file
String apiUrl = ""; // Provided by b2_authorize_account
ArrayList partSha1Array = {"<sha1_part1>","<sha1_part2>","<sha1_part3>"}; // See b2_upload_part

// Create a request object and copy it to the memory stream.
B2FinishLargeFileRequest finishLargeFileData = new B2FinishLargeFileRequest();
finishLargeFileData.fileId = fileId;
finishLargeFileData.partSha1Array = partSha1Array;
MemoryStream finishLargeFileMemStream = new MemoryStream();
DataContractJsonSerializer finishLargeFileSerializer = new DataContractJsonSerializer(typeof(B2FinishLargeFileRequest));
finishLargeFileSerializer.WriteObject(finishLargeFileMemStream, finishLargeFileData);

HttpWebRequest finishLargeFileRequest = (HttpWebRequest)WebRequest.Create(authData.apiUrl + "/b2api/v2/b2_finish_large_file");
finishLargeFileRequest.Method = "POST";
finishLargeFileRequest.Headers.Add("Authorization", authorizationToken);
finishLargeFileRequest.ContentType = "application/json; charset=utf-8";
finishLargeFileRequest.ContentLength = finishLargeFileMemStream.Length;
finishLargeFileMemStream.WriteTo(finishLargeFileRequest.GetRequestStream());
HttpWebResponse finishLargeFileResponse = null;
try
{
    finishLargeFileResponse = (HttpWebResponse)finishLargeFileRequest.GetResponse();
}
catch (WebException e)
{
    using (WebResponse r = e.Response)
    {
        HttpWebResponse httpResponse = (HttpWebResponse)r;
        Console.WriteLine("Error code: {0}", httpResponse.StatusCode);
        using (Stream dataE = r.GetResponseStream())
        using (var reader = new StreamReader(dataE))
        {
            string text = reader.ReadToEnd();
            Console.WriteLine(text);
        }
    }
}


// Class used with Json Serialization
[DataContract]
class B2FinishLargeFileRequest
{
    [DataMember]
    public String fileId;
    [DataMember]
    public ArrayList partSha1Array;
}

Output

under construction

Code

<?php

$api_url = ""; // Obtained from b2_authorize_account
$file_id = ""; // Obtained from b2_start_large_file
$sha1_of_parts = ["<sha1_of_first_part>","<sha1_of_second_part>","<sha1_of_third_part>"]; // See b2_upload_part
$session = curl_init($api_url . "/b2api/v2/b2_finish_large_file");

// Add headers
$headers = array();
$headers[] = "Accept: application/json";
$headers[] = "Authorization: " . $account_auth_token;

// Send over the wire
curl_setopt($session, CURLOPT_POSTFIELDS, $post_fields); 
curl_setopt($session, CURLOPT_HTTPHEADER, $headers);  // Add headers
curl_setopt($session, CURLOPT_RETURNTRANSFER, true); // Receive server response
$server_output = curl_exec($session);
curl_close ($session);
print $server_output;

?>

Output

{
  "accountId": "YOUR_ACCOUNT_ID",
  "action": "upload",
  "bucketId": "e73ede9c9c8412db49f60715",
  "contentLength": 208158542,
  "contentSha1": "none",
  "contentType": "b2/x-auto",
  "fileId": "4_ze73ede9c9c8412db49f60715_f100b4e93fbae6252_d20150824_m224353_c900_v8881000_t0001",
  "fileInfo": {},
  "fileName": "bigfile.dat",
  "fileRetention": {
    "isClientAuthorizedToRead": true,
    "value": {
      "mode": null,
      "retainUntilTimestamp": null
    }
  },
  "legalHold": {
    "isClientAuthorizedToRead": true,
    "value": null
  },
  "serverSideEncryption": {
    "algorithm": null,
    "mode": null
  },
  "uploadTimestamp": 1460162909000
}