upload.h

Go to the documentation of this file.

#ifndef CVMFS_UPLOAD_H_
#define CVMFS_UPLOAD_H_

#include <cstdio>
#include <string>
#include <vector>

#include "crypto/hash.h"
#include "file_chunk.h"
#include "ingestion/ingestion_source.h"
#include "ingestion/pipeline.h"
#include "repository_tag.h"
#include "upload_facility.h"
#include "upload_spooler_definition.h"
#include "upload_spooler_result.h"
#include "util/concurrency.h"
#include "util/pointer.h"
#include "util/shared_ptr.h"

namespace upload {

class Spooler : public Observable<SpoolerResult> {
 public:
  static Spooler *Construct(const SpoolerDefinition &spooler_definition,
                              perf::StatisticsTemplate *statistics = NULL);
  virtual ~Spooler();

  std::string backend_name() const;

  bool Create();

  void Upload(const std::string &local_path, const std::string &remote_path);

  void Upload(const std::string &remote_path, IngestionSource *source);

  void UploadManifest(const std::string &local_path);

  void UploadReflog(const std::string &local_path);

  void Process(IngestionSource *source, const bool allow_chunking = true);

  void ProcessCatalog(const std::string &local_path);

  void ProcessHistory(const std::string &local_path);

  void ProcessCertificate(const std::string &local_path);
  void ProcessCertificate(IngestionSource *source);

  void ProcessMetainfo(const std::string &local_path);
  void ProcessMetainfo(IngestionSource *source);

  void RemoveAsync(const std::string &file_to_delete);

  bool Peek(const std::string &path) const;

  bool Mkdir(const std::string &path);

  bool PlaceBootstrappingShortcut(const shash::Any &object) const;

  void WaitForUpload() const;

  bool FinalizeSession(bool commit, const std::string &old_root_hash = "",
                       const std::string &new_root_hash = "",
                       const RepositoryTag &tag = RepositoryTag()) const;

  unsigned int GetNumberOfErrors() const;

  shash::Algorithms GetHashAlgorithm() const {
    return spooler_definition_.hash_algorithm;
  }

  SpoolerDefinition::DriverType GetDriverType() const {
    return spooler_definition_.driver_type;
  }

 protected:
  bool Initialize(perf::StatisticsTemplate *statistics);

  explicit Spooler(const SpoolerDefinition &spooler_definition);

  void ProcessingCallback(const SpoolerResult &data);

  void UploadingCallback(const UploaderResults &data);

  /*
   * @return   the spooler definition that was initially given to any Spooler
   *           constructor.
   */
  inline const SpoolerDefinition &spooler_definition() const {
    return spooler_definition_;
  }

 private:
  // Status Information
  const SpoolerDefinition spooler_definition_;

  UniquePtr<IngestionPipeline> ingestion_pipeline_;
  UniquePtr<AbstractUploader> uploader_;
};

}  // namespace upload

#endif  // CVMFS_UPLOAD_H_