Examples with ProgressListener com.dropbox.core.util.IOUtil.ProgressListener used on opensource projects

Example 1 with ProgressListener

use of com.dropbox.core.util.IOUtil.ProgressListener in project dropbox-sdk-java by dropbox.

the class Main method uploadFile.

/**
 * Uploads a file in a single request. This approach is preferred for small files since it
 * eliminates unnecessary round-trips to the servers.
 *
 * @param dbxClient Dropbox user authenticated client
 * @param localFIle local file to upload
 * @param dropboxPath Where to upload the file to within Dropbox
 */
private static void uploadFile(DbxClientV2 dbxClient, File localFile, String dropboxPath) {
    try (InputStream in = new FileInputStream(localFile)) {
        ProgressListener progressListener = l -> printProgress(l, localFile.length());
        FileMetadata metadata = dbxClient.files().uploadBuilder(dropboxPath).withMode(WriteMode.ADD).withClientModified(new Date(localFile.lastModified())).uploadAndFinish(in, progressListener);
        System.out.println(metadata.toStringMultiline());
    } catch (UploadErrorException ex) {
        System.err.println("Error uploading to Dropbox: " + ex.getMessage());
        System.exit(1);
    } catch (DbxException ex) {
        System.err.println("Error uploading to Dropbox: " + ex.getMessage());
        System.exit(1);
    } catch (IOException ex) {
        System.err.println("Error reading from file \"" + localFile + "\": " + ex.getMessage());
        System.exit(1);
    }
}

Example 2 with ProgressListener

use of com.dropbox.core.util.IOUtil.ProgressListener in project dropbox-sdk-java by dropbox.

the class Main method chunkedUploadFile.

/**
 * Uploads a file in chunks using multiple requests. This approach is preferred for larger files
 * since it allows for more efficient processing of the file contents on the server side and
 * also allows partial uploads to be retried (e.g. network connection problem will not cause you
 * to re-upload all the bytes).
 *
 * @param dbxClient Dropbox user authenticated client
 * @param localFIle local file to upload
 * @param dropboxPath Where to upload the file to within Dropbox
 */
private static void chunkedUploadFile(DbxClientV2 dbxClient, File localFile, String dropboxPath) {
    long size = localFile.length();
    // below to simplify the logic.
    if (size < CHUNKED_UPLOAD_CHUNK_SIZE) {
        System.err.println("File too small, use upload() instead.");
        System.exit(1);
        return;
    }
    long uploaded = 0L;
    DbxException thrown = null;
    ProgressListener progressListener = new ProgressListener() {

        long uploadedBytes = 0;

        @Override
        public void onProgress(long l) {
            printProgress(l + uploadedBytes, size);
            if (l == CHUNKED_UPLOAD_CHUNK_SIZE)
                uploadedBytes += CHUNKED_UPLOAD_CHUNK_SIZE;
        }
    };
    // Chunked uploads have 3 phases, each of which can accept uploaded bytes:
    // 
    // (1)  Start: initiate the upload and get an upload session ID
    // (2) Append: upload chunks of the file to append to our session
    // (3) Finish: commit the upload and close the session
    // 
    // We track how many bytes we uploaded to determine which phase we should be in.
    String sessionId = null;
    for (int i = 0; i < CHUNKED_UPLOAD_MAX_ATTEMPTS; ++i) {
        if (i > 0) {
            System.out.printf("Retrying chunked upload (%d / %d attempts)\n", i + 1, CHUNKED_UPLOAD_MAX_ATTEMPTS);
        }
        try (InputStream in = new FileInputStream(localFile)) {
            // if this is a retry, make sure seek to the correct offset
            in.skip(uploaded);
            // (1) Start
            if (sessionId == null) {
                sessionId = dbxClient.files().uploadSessionStart().uploadAndFinish(in, CHUNKED_UPLOAD_CHUNK_SIZE, progressListener).getSessionId();
                uploaded += CHUNKED_UPLOAD_CHUNK_SIZE;
                printProgress(uploaded, size);
            }
            UploadSessionCursor cursor = new UploadSessionCursor(sessionId, uploaded);
            // (2) Append
            while ((size - uploaded) > CHUNKED_UPLOAD_CHUNK_SIZE) {
                dbxClient.files().uploadSessionAppendV2(cursor).uploadAndFinish(in, CHUNKED_UPLOAD_CHUNK_SIZE, progressListener);
                uploaded += CHUNKED_UPLOAD_CHUNK_SIZE;
                printProgress(uploaded, size);
                cursor = new UploadSessionCursor(sessionId, uploaded);
            }
            // (3) Finish
            long remaining = size - uploaded;
            CommitInfo commitInfo = CommitInfo.newBuilder(dropboxPath).withMode(WriteMode.ADD).withClientModified(new Date(localFile.lastModified())).build();
            FileMetadata metadata = dbxClient.files().uploadSessionFinish(cursor, commitInfo).uploadAndFinish(in, remaining, progressListener);
            System.out.println(metadata.toStringMultiline());
            return;
        } catch (RetryException ex) {
            thrown = ex;
            // RetryExceptions are never automatically retried by the client for uploads. Must
            // catch this exception even if DbxRequestConfig.getMaxRetries() > 0.
            sleepQuietly(ex.getBackoffMillis());
            continue;
        } catch (NetworkIOException ex) {
            thrown = ex;
            // network issue with Dropbox (maybe a timeout?) try again
            continue;
        } catch (UploadSessionLookupErrorException ex) {
            if (ex.errorValue.isIncorrectOffset()) {
                thrown = ex;
                // server offset into the stream doesn't match our offset (uploaded). Seek to
                // the expected offset according to the server and try again.
                uploaded = ex.errorValue.getIncorrectOffsetValue().getCorrectOffset();
                continue;
            } else {
                // Some other error occurred, give up.
                System.err.println("Error uploading to Dropbox: " + ex.getMessage());
                System.exit(1);
                return;
            }
        } catch (UploadSessionFinishErrorException ex) {
            if (ex.errorValue.isLookupFailed() && ex.errorValue.getLookupFailedValue().isIncorrectOffset()) {
                thrown = ex;
                // server offset into the stream doesn't match our offset (uploaded). Seek to
                // the expected offset according to the server and try again.
                uploaded = ex.errorValue.getLookupFailedValue().getIncorrectOffsetValue().getCorrectOffset();
                continue;
            } else {
                // some other error occurred, give up.
                System.err.println("Error uploading to Dropbox: " + ex.getMessage());
                System.exit(1);
                return;
            }
        } catch (DbxException ex) {
            System.err.println("Error uploading to Dropbox: " + ex.getMessage());
            System.exit(1);
            return;
        } catch (IOException ex) {
            System.err.println("Error reading from file \"" + localFile + "\": " + ex.getMessage());
            System.exit(1);
            return;
        }
    }
    // if we made it here, then we must have run out of attempts
    System.err.println("Maxed out upload attempts to Dropbox. Most recent error: " + thrown.getMessage());
    System.exit(1);
}

Example 3 with ProgressListener

use of com.dropbox.core.util.IOUtil.ProgressListener in project dropbox-sdk-java by dropbox.

the class DbxClientV2IT method testUploadAndDownload.

private void testUploadAndDownload(DbxClientV2 client, boolean trackProgress) throws Exception {
    final byte[] contents = ITUtil.randomBytes(1024 << 8);
    String filename = "testUploadAndDownload.dat";
    String path = ITUtil.path(getClass(), "/" + filename);
    ProgressListener progressListener = null;
    if (trackProgress) {
        progressListener = createTestListener(contents.length);
    }
    FileMetadata metadata = client.files().uploadBuilder(path).withAutorename(false).withMode(WriteMode.ADD).withMute(true).uploadAndFinish(new ByteArrayInputStream(contents), progressListener);
    assertThat(metadata.getName()).isEqualTo(filename);
    assertThat(metadata.getPathLower()).isEqualTo(path.toLowerCase());
    assertThat(metadata.getSize()).isEqualTo(contents.length);
    Metadata actual = client.files().getMetadata(path);
    assertWithMessage(actual.getClass().getCanonicalName()).that(actual instanceof FileMetadata).isTrue();
    try {
        assertThat(actual).isEqualTo(metadata);
        if (trackProgress) {
            progressListener = createTestListener(contents.length);
        }
        DbxDownloader<FileMetadata> downloader = client.files().download(path);
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        downloader.download(out, progressListener);
        byte[] actualContents = out.toByteArray();
        FileMetadata actualResult = downloader.getResult();
        assertThat(actualResult).isEqualTo(metadata);
        assertThat(actualContents).isEqualTo(contents);
        assertThat(downloader.getContentType()).isEqualTo("application/octet-stream");
    } catch (AssertionError e) {
        // so subsequent tests don't fail due to file not being cleaned up
        client.files().deleteV2(path).getMetadata();
        throw e;
    }
    Metadata deleted = client.files().deleteV2(path).getMetadata();
    assertThat(deleted).isEqualTo(metadata);
}