Page MenuHomePhabricator
Files F3332956

No OneTemporary
Actions

View Options

diff --git a/keyserver/src/services/blob.js b/keyserver/src/services/blob.js
index 161a48845..a11e6f880 100644
--- a/keyserver/src/services/blob.js
+++ b/keyserver/src/services/blob.js
@@ -1,157 +1,158 @@
// @flow
import blobService from 'lib/facts/blob-service.js';
import type { BlobHashAndHolder } from 'lib/types/holder-types.js';
import {
getBlobFetchableURL,
makeBlobServiceEndpointURL,
} from 'lib/utils/blob-service.js';
import {
uploadBlob,
removeMultipleHolders,
type BlobOperationResult,
} from 'lib/utils/blob-service.js';
import { createHTTPAuthorizationHeader } from 'lib/utils/services-utils.js';
import { verifyUserLoggedIn } from '../user/login.js';
import { getContentSigningKey } from '../utils/olm-utils.js';
async function createRequestHeaders(
includeContentType: boolean = true,
): Promise<{ [string]: string }> {
const [{ userId: userID, accessToken }, deviceID] = await Promise.all([
verifyUserLoggedIn(),
getContentSigningKey(),
]);
const authorization = createHTTPAuthorizationHeader({
userID,
deviceID,
accessToken,
});
return {
Authorization: authorization,
...(includeContentType && { 'Content-Type': 'application/json' }),
};
}
type BlobDescriptor = {
+hash: string,
+holder: string,
};
async function assignHolder(
params: BlobDescriptor,
): Promise<BlobOperationResult> {
const { hash, holder } = params;
const headers = await createRequestHeaders();
const assignHolderResponse = await fetch(
makeBlobServiceEndpointURL(blobService.httpEndpoints.ASSIGN_HOLDER),
{
method: blobService.httpEndpoints.ASSIGN_HOLDER.method,
body: JSON.stringify({
holder,
blob_hash: hash,
}),
headers,
},
);
if (!assignHolderResponse.ok) {
const { status, statusText } = assignHolderResponse;
return { success: false, reason: 'OTHER', status, statusText };
}
return { success: true };
}
async function uploadBlobKeyserverWrapper(
blob: Blob,
hash: string,
): Promise<BlobOperationResult> {
const authHeaders = await createRequestHeaders(false);
return uploadBlob(blob, hash, authHeaders);
}
async function upload(
blob: Blob,
params: BlobDescriptor,
): Promise<
| {
+success: true,
}
| {
+success: false,
+assignHolderResult: BlobOperationResult,
+uploadBlobResult: BlobOperationResult,
},
> {
const { hash, holder } = params;
const [holderResult, uploadResult] = await Promise.all([
assignHolder({ hash, holder }),
uploadBlobKeyserverWrapper(blob, hash),
]);
if (holderResult.success && uploadResult.success) {
return { success: true };
}
return {
success: false,
assignHolderResult: holderResult,
uploadBlobResult: uploadResult,
};
}
export type BlobDownloadResult =
| {
+found: false,
+ +status: number,
}
| {
+found: true,
+blob: Blob,
};
async function download(hash: string): Promise<BlobDownloadResult> {
const url = getBlobFetchableURL(hash);
const headers = await createRequestHeaders();
const response = await fetch(url, {
method: blobService.httpEndpoints.GET_BLOB.method,
headers,
});
if (!response.ok) {
- return { found: false };
+ return { found: false, status: response.status };
}
const blob = await response.blob();
return { found: true, blob };
}
async function deleteBlob(params: BlobDescriptor, instant?: boolean) {
const { hash, holder } = params;
const endpoint = blobService.httpEndpoints.DELETE_BLOB;
const url = makeBlobServiceEndpointURL(endpoint);
const headers = await createRequestHeaders();
await fetch(url, {
method: endpoint.method,
body: JSON.stringify({
holder,
blob_hash: hash,
instant_delete: !!instant,
}),
headers,
});
}
async function removeBlobHolders(holders: $ReadOnlyArray<BlobHashAndHolder>) {
const headers = await createRequestHeaders(false);
await removeMultipleHolders(holders, headers);
}
export {
upload,
uploadBlob,
assignHolder,
download,
deleteBlob,
uploadBlobKeyserverWrapper,
removeBlobHolders,
};

File Metadata

Mime Type
text/x-diff
Expires
Sat, Nov 23, 2:51 AM (23 h, 1 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
2559435
Default Alt Text
(4 KB)

Event Timeline