upload_spooler_definition.cc

Go to the documentation of this file.

#include "upload_spooler_definition.h"

#include <vector>

#include "util/logging.h"
#include "util/string.h"

namespace upload {

const char* SpoolerDefinition::kDriverNames[] =
  {"S3", "local", "gw", "mock", "unknown"};

SpoolerDefinition::SpoolerDefinition(
    const std::string& definition_string,
    const shash::Algorithms hash_algorithm,
    const zlib::Algorithms compression_algorithm,
    const bool generate_legacy_bulk_chunks,
    const bool use_file_chunking,
    const size_t min_file_chunk_size,
    const size_t avg_file_chunk_size,
    const size_t max_file_chunk_size,
    const std::string& session_token_file,
    const std::string& key_file)
    : driver_type(Unknown),
      hash_algorithm(hash_algorithm),
      compression_alg(compression_algorithm),
      generate_legacy_bulk_chunks(generate_legacy_bulk_chunks),
      use_file_chunking(use_file_chunking),
      min_file_chunk_size(min_file_chunk_size),
      avg_file_chunk_size(avg_file_chunk_size),
      max_file_chunk_size(max_file_chunk_size),
      number_of_concurrent_uploads(kDefaultMaxConcurrentUploads),
      num_upload_tasks(kDefaultNumUploadTasks),
      session_token_file(session_token_file),
      key_file(key_file),
      valid_(false) {
  // check if given file chunking values are sane
  if (use_file_chunking && (min_file_chunk_size >= avg_file_chunk_size ||
                            avg_file_chunk_size >= max_file_chunk_size)) {
    LogCvmfs(kLogSpooler, kLogStderr, "file chunk size values are not sane");
    return;
  }

  // split the spooler driver definition into name and config part
  std::vector<std::string> upstream = SplitString(definition_string, ',');
  if (upstream.size() != 3) {
    LogCvmfs(kLogSpooler, kLogStderr, "Invalid spooler driver");
    return;
  }

  // recognize and configure the spooler driver
  if (upstream[0] == "local") {
    driver_type = Local;
  } else if (upstream[0] == "S3") {
    driver_type = S3;
  } else if (upstream[0] == "gw") {
    driver_type = Gateway;
  } else if (upstream[0] == "mock") {
    driver_type = Mock;  // for unit testing purpose only!
  } else {
    driver_type = Unknown;
    LogCvmfs(kLogSpooler, kLogStderr, "unknown spooler driver: %s",
             upstream[0].c_str());
    return;
  }

  // save data
  temporary_path = upstream[1];
  spooler_configuration = upstream[2];
  valid_ = true;
}

SpoolerDefinition SpoolerDefinition::Dup2DefaultCompression() const {
  SpoolerDefinition result(*this);
  result.compression_alg = zlib::kZlibDefault;
  return result;
}

}  // namespace upload