Java MantaClient類代碼示例

import com.joyent.manta.client.MantaClient; //導入依賴的package包/類
/**
 * Initialization method called after a new FileSystem instance is constructed.
 *
 * @param name a uri whose authority section names the host, port, etc.
 *             for this FileSystem. [Not used for Manta implementation]
 * @param conf Hadoop configuration object
 * @throws IOException thrown when we can't create a Manta Client
 */
@Override
public void initialize(final URI name, final Configuration conf) throws IOException {
    super.initialize(name, conf);

    ChainedConfigContext chained = new ChainedConfigContext(
            new EnvVarConfigContext(),
            new MapConfigContext(System.getProperties()),
            new HadoopConfigurationContext(conf),
            new DefaultsConfigContext()
    );

    dumpConfig(chained);

    this.config = chained;
    this.client = new MantaClient(this.config);

    this.workingDir = getInitialWorkingDirectory();
}
 

import com.joyent.manta.client.MantaClient; //導入依賴的package包/類
@Test
public void canAddSmallFileToNonExistentPath() throws IOException {
    Path file = new Path(testPathPrefix +
            "i-dont-exist" + MantaClient.SEPARATOR + UUID.randomUUID() +
            MantaClient.SEPARATOR +
            "upload-" + UUID.randomUUID() + ".txt");

    try (FSDataOutputStream out = fs.create(file)) {
        out.write(TEST_DATA.getBytes(Charsets.UTF_8));
    }

    boolean exists = client.existsAndIsAccessible(file.toString());
    assertTrue("File didn't get uploaded to path: " + file,
            exists);

    String actual = client.getAsString(file.toString());
    assertEquals("Uploaded contents didn't match", TEST_DATA, actual);
}
 

import com.joyent.manta.client.MantaClient; //導入依賴的package包/類
@Test
public void canCopyFromMantaDirectoryToLocalDirectory() throws IOException {
    String tempDirPath = FileUtils.getTempDirectoryPath() + File.separator
            + "manta-copy-" + UUID.randomUUID() + File.separator;
    File tempDir = new File(tempDirPath);
    String mantaPath = testPathPrefix + "test-dir" + MantaClient.SEPARATOR;
    client.putDirectory(mantaPath);
    client.put(mantaPath + "file-1.txt", TEST_DATA);
    client.put(mantaPath + "file-2.txt", TEST_DATA);

    try {
        fs.copyToLocalFile(true, new Path("manta://" + mantaPath),
                new Path(tempDir.toURI()), false);

        File file1 = new File(tempDirPath + "file-1.txt");
        String actual1 = FileUtils.readFileToString(file1);
        assertEquals("Downloaded contents didn't match", TEST_DATA, actual1);
        File file2 = new File(tempDirPath + "file-2.txt");
        String actual2 = FileUtils.readFileToString(file2);
        assertEquals("Downloaded contents didn't match", TEST_DATA, actual2);
    } finally {
        FileUtils.deleteDirectory(tempDir);
    }
}
 

import com.joyent.manta.client.MantaClient; //導入依賴的package包/類
/**
 * Creates a new instance that uses multiple HTTP range requests to get
 * a single file and glue it all together as a single {@link InputStream}.
 *
 * @param path path to object in Manta
 * @param client reference to an open Manta client
 * @param size size of the object
 * @param noOfSections number of sections to split object into
 */
RangeJoiningInputStream(final String path,
                        final MantaClient client,
                        final long size,
                        final int noOfSections) {
    Objects.requireNonNull(path);
    Objects.requireNonNull(client);

    if (size <= 0) {
        throw new IllegalArgumentException("Size of test object must be greater than zero");
    }

    if (noOfSections <= 1) {
        throw new IllegalArgumentException("Number of sections for test object must be greater than one");
    }

    this.path = path;
    this.client = client;
    this.size = size;
    this.sections = splitIntoSections(size, noOfSections);
    this.streamSupplier = new MantaObjectInputStreamSupplier();

}
 

import com.joyent.manta.client.MantaClient; //導入依賴的package包/類
@BeforeClass
public static void before() throws IOException {

    // Let TestNG configuration take precedence over environment variables
    ConfigContext config = new SystemSettingsConfigContext();

    mantaClient = new MantaClient(config);
    testPathPrefix = String.format("/%s/stor/%s/",
            config.getMantaHomeDirectory(), UUID.randomUUID());
    mantaClient.putDirectory(testPathPrefix, null);
}
 

import com.joyent.manta.client.MantaClient; //導入依賴的package包/類
@Test
public void canMakeMultipleDirectories() throws IOException {
    Path newDirectory = new Path(testPathPrefix + "newDirectory-"  + UUID.randomUUID()
        + MantaClient.SEPARATOR + "subdir1" + MantaClient.SEPARATOR + "subdir2");
    boolean result = fs.mkdirs(newDirectory);

    assertTrue("Directory not indicated as created", result);
    boolean exists = client.existsAndIsAccessible(newDirectory.toString());
    assertTrue("Directory doesn't exist on Manta", exists);
}
 

import com.joyent.manta.client.MantaClient; //導入依賴的package包/類
@Test
public void canCopyLocalDirectoryToManta() throws IOException {
    String mantaPath = testPathPrefix + "wildcard-upload";
    client.putDirectory(mantaPath);

    String tempDirPath = FileUtils.getTempDirectoryPath() + File.separator +
            UUID.randomUUID();
    File tempDir = new File(tempDirPath);
    Assert.assertTrue("Expected temp subdir to be created", tempDir.mkdir());

    try {
        File file1 = new File(tempDirPath + File.separator + "file-1.txt");
        File file2 = new File(tempDirPath + File.separator + "file-2.txt");

        Files.write(file1.toPath(), (TEST_DATA).getBytes(Charsets.UTF_8));
        Files.write(file2.toPath(), (TEST_DATA).getBytes(Charsets.UTF_8));

        fs.copyFromLocalFile(false, false,
                new Path(tempDir.toURI()),
                new Path("manta://" + mantaPath));

        String file1MantaPath = mantaPath + MantaClient.SEPARATOR +
                tempDir.getName() + MantaClient.SEPARATOR + file1.getName();
        Assert.assertEquals(client.getAsString(file1MantaPath), TEST_DATA);
        String file2MantaPath = mantaPath + MantaClient.SEPARATOR +
                tempDir.getName() + MantaClient.SEPARATOR + file2.getName();
        Assert.assertTrue(client.existsAndIsAccessible(file2MantaPath));
        Assert.assertEquals(client.getAsString(file2MantaPath), TEST_DATA);
    } finally {
        FileUtils.deleteDirectory(tempDir);
    }
}
 

import com.joyent.manta.client.MantaClient; //導入依賴的package包/類
@Override
protected MantaClient connect(final HostKeyCallback key, final LoginCallback prompt) throws BackgroundException {
    return new MantaClient(config, new MantaConnectionFactoryConfigurator(builder.build(this, prompt)));
}
 

import com.joyent.manta.client.MantaClient; //導入依賴的package包/類
@Override
public void init(final Config config, final Logger logger) {
    logger.debug("Manta client has started initialization");
    super.init(config, logger);

    // We change the default number of connections to something more
    // fitting for COSBench.
    StandardConfigContext defaults = new StandardConfigContext();
    defaults.overwriteWithContext(new DefaultsConfigContext());
    defaults.setMaximumConnections(MAX_CONNECTIONS);

    final CosbenchMantaConfigContext cosbenchConfig = new CosbenchMantaConfigContext(config);
    final ChainedConfigContext context = new ChainedConfigContext(defaults, new EnvVarConfigContext(),
            new SystemSettingsConfigContext(), cosbenchConfig);

    this.durabilityLevel = cosbenchConfig.getDurabilityLevel();
    this.logging = cosbenchConfig.logging();
    this.sections = cosbenchConfig.getNumberOfSections();
    this.objectSize = cosbenchConfig.getObjectSize();
    this.multipart = cosbenchConfig.isMultipart();

    this.splitSize = cosbenchConfig.getSplitSize();
    if (splitSize == null) {
        splitSize = DEFAULT_SPLIT;
    }
    if (cosbenchConfig.chunked() == null) {
        if (logging) {
            logger.info("Chunked mode is disabled");
        }

        this.chunked = false;
    } else {
        final String status;
        if (cosbenchConfig.chunked()) {
            status = "enabled";
        } else {
            status = "disabled";
        }

        if (logging) {
            logger.info("Chunked mode is " + status);
        }
        this.chunked = cosbenchConfig.chunked();
    }

    if (logging) {
        logger.info(String.format("Client configuration: %s", context));
    }

    try {
        client = new MantaClient(context);

        final String baseDir = Objects.toString(cosbenchConfig.getBaseDirectory(), DEFAULT_COSBENCH_BASE_DIR);

        // We rely on COSBench properly cleaning up after itself.
        currentTestDirectory = String.format("%s/%s", context.getMantaHomeDirectory(), baseDir);

        client.putDirectory(currentTestDirectory, true);

        if (!client.existsAndIsAccessible(currentTestDirectory)) {
            String msg = "Unable to create base test directory";
            throw new StorageException(msg);
        }
    } catch (IOException e) {
        logger.error("Error in initialization", e);
        throw new StorageException(e);
    }

    if (logging) {
        logger.debug("Manta client has been initialized");
    }
    if (cosbenchConfig.isClientEncryptionEnabled()) {
        encryptedMultipartManager = new EncryptedServerSideMultipartManager(client);
    }
    serverMultipartManager = new ServerSideMultipartManager(client);
}
 

import com.joyent.manta.client.MantaClient; //導入依賴的package包/類
/**
 * Package private visibility method for getting the Manta SDK client
 * used for testing.
 *
 * @return reference to the backing Manta client
 */
@VisibleForTesting
MantaClient getMantaClient() {
    return this.client;
}