/**

 * This file is part of the CernVM File System.

 */

#ifndef CVMFS_OBJECT_FETCHER_H_

#define CVMFS_OBJECT_FETCHER_H_

#include <unistd.h>

#include <string>

#include "catalog.h"

#include "download.h"

#include "history_sqlite.h"

#include "manifest.h"

#include "manifest_fetch.h"

#include "reflog.h"

#include "signature.h"

#include "util/posix.h"

/**

 * Trait class to define the concrete object types produced by the methods of

 * concrete instantiations of AbstractObjectFetcher<>. For each implementation

 * of AbstractObjectFetcher<> one needs to provide a specialisation of this

 * trait. Note that this specialisation can be templated with the actual para-

 * meters, hence the parameter space does not explode.

 *

 * See: http://stackoverflow.com/questions/6006614/

 *      c-static-polymorphism-crtp-and-using-typedefs-from-derived-classes

 */

template <class ConcreteObjectFetcherT>

struct object_fetcher_traits;

  enum Failures {

    kFailOk,

    kFailNotFound,

    kFailLocalIO,

    kFailNetwork,

    kFailDecompression,

    kFailManifestNameMismatch,

    kFailManifestSignatureMismatch,

    kFailBadData,

    kFailUnknown,

    kFailNumEntries

  };

};

  const char *texts[ObjectFetcherFailures::kFailNumEntries + 1];

}

/**

 * This is the default class implementing the data object fetching strategy. It

 * is meant to be used when CVMFS specific data structures need to be downloaded

 * from a backend storage of a repository.

 *

 * ObjectFetchers are supposed to be configured for one specific repository. How

 * this is done depends on the concrete implementation of this base class. When

 * a concrete implementation of ObjectFetcher<> needs to deal with files on the

 * local file system it is obliged to take measures for proper cleanup of those

 * files after usage.

 *

 * It abstracts all accesses to external file or HTTP resources and gathers this

 * access logic in one central point. This also comes in handy when unit testing

 * components that depend on downloading CVMFS data structures from a repository

 * backend storage like CatalogTraversal<> or GarbageCollector<>.

 */

template <class DerivedT>

 public:

  typedef typename object_fetcher_traits<DerivedT>::CatalogTN CatalogTN;

  typedef typename object_fetcher_traits<DerivedT>::HistoryTN HistoryTN;

  typedef typename object_fetcher_traits<DerivedT>::ReflogTN  ReflogTN;

  typedef ObjectFetcherFailures::Failures Failures;

  static const std::string kManifestFilename;

  static const std::string kReflogFilename;

 public:

  /**

   * Fetches and opens the manifest of the repository this object fetcher is

   * configured for. Note that the user is responsible to clean up this object.

   *

   * @param manifest  pointer to a manifest object pointer

   * @return          failure code, specifying the action's result

   */

  }

  /**

   * Downloads and opens (read-only) a history database. Note that the user is

   * responsible to remove the history object after usage. The fetched SQLite

   * database file will be unlinked automatically during the destruction of the

   * HistoryTN object.

   *

   * @param history       pointer to a history database object pointer

   * @param history_hash  (optional) the content hash of the history database

   *                                 if left blank, the latest one is downloaded

   * @return              failure code, specifying the action's result

   */

                        const shash::Any  &history_hash = shash::Any()) {

    // retrieve the current HEAD history hash (if nothing else given)

    shash::Any effective_history_hash = (!history_hash.IsNull())

            ? history_hash

    }

           history_hash.IsNull());

    // download the history hash

    }

    // open the history file

    }

  }

  /**

   * Downloads and opens a catalog. Note that the user is responsible to remove

   * the catalog object after usage.

   *

   * @param catalog_hash   the content hash of the catalog object

   * @param catalog_path   the root_path the catalog is mounted on

   * @param catalog        pointer to the fetched catalog object pointer

   * @param is_nested      a hint if the catalog to be loaded is a nested one

   * @param parent         (optional) parent catalog of the requested catalog

   * @return               failure code, specifying the action's result

   */

                        const std::string  &catalog_path,

                              CatalogTN   **catalog,

                        const bool          is_nested = false,

                              CatalogTN    *parent    = NULL) {

    }

                                       path,

                                       catalog_hash,

                                       parent,

                                       is_nested);

    }

  }

    }

    // Ensure data integrity

    }

    }

  }

  }

                        const shash::Any      &history_hash = shash::Any()) {

  }

                        const std::string           &catalog_path,

                              UniquePtr<CatalogTN>  *catalog,

                        const bool                   is_nested = false,

                              CatalogTN             *parent    = NULL) {

    Failures failure = FetchCatalog(catalog_hash,

                                    catalog_path,

                                    &raw_catalog_ptr,

                                    is_nested,

  }

                       UniquePtr<ReflogTN> *reflog)

  {

  }

  std::string GetUrl(const shash::Any &hash) const {

    return static_cast<DerivedT*>(this)->GetUrl(hash);

  }

  }

  }

 protected:

  /**

   * Internal function used to download objects defined by the given content

   * hash. This needs to be implemented depending on the concrete implementation

   * of this base class.

   *

   * @param object_hash  the content hash of the object to be downloaded

   * @param file_path    temporary file path to store the download result

   * @return             failure code (if not kFailOk, file_path is invalid)

   */

  }

                 const bool         decompress,

                 const bool         nocache,

                       std::string *file_path) {

    return static_cast<DerivedT*>(this)->Fetch(relative_path,

                                               decompress,

                                               nocache,

  }

  /**

   * Retrieves the history content hash of the HEAD history database from the

   * repository's manifest

   *

   * @return  the content hash of the HEAD history db or a null-hash on error

   */

        !manifest.IsValid() ||

        manifest->history().IsNull()) {

    }

  }

 private:

  const std::string temporary_directory_;

};

template <class DerivedT>

                                                              ".cvmfspublished";

template <class DerivedT>

                                                                 ".cvmfsreflog";

/**

 * This is an AbstractObjectFetcher<> accessing locally stored repository files.

 * Note that this implementation does not take care of any repository signature

 * verification.

 */

template <class CatalogT = catalog::Catalog,

          class HistoryT = history::SqliteHistory,

          class ReflogT  = manifest::Reflog>

class LocalObjectFetcher :

  public AbstractObjectFetcher<LocalObjectFetcher<CatalogT, HistoryT, ReflogT> >

 protected:

  typedef LocalObjectFetcher<CatalogT, HistoryT, ReflogT> ThisTN;

  typedef AbstractObjectFetcher<ThisTN>                   BaseTN;

 public:

  typedef typename BaseTN::Failures Failures;

 public:

  /**

   * LocalObjectFetcher can reside on the stack or the heap.

   *

   * @param base_path  the path to the repository's backend storage

   * @param temp_dir   location to store decompressed tmp data

   */

                     const std::string &temp_dir)

    : BaseTN(temp_dir)

  using BaseTN::FetchManifest;  // un-hiding convenience overload

    }

    return (*manifest != NULL) ? BaseTN::kFailOk

  }

  std::string GetUrl(const shash::Any &hash) const {

    return "file://" + BuildPath(BuildRelativePath(hash));

  }

  }

                 const bool         decompress,

                 const bool         nocache,

                       std::string *file_path) {

    // check if the requested file object is available locally

               relative_path.c_str());

    }

    // create a temporary file to store the (decompressed) object file

    const std::string tmp_path = BaseTN::temporary_directory() + "/" +

               "failed to create temp file '%s' (errno: %d)",

               tmp_path.c_str(), errno);

    }

    // decompress or copy the requested object file

    const bool success = (decompress)

      ? zlib::DecompressPath2File(source, f)

    // check the decompression success and remove the temporary file otherwise

                                        "to '%s' (errno: %d)",

               source.c_str(), file_path->c_str(), errno);

    }

  }

 protected:

  }

  }

 private:

  const std::string base_path_;

};

template <class CatalogT, class HistoryT, class ReflogT>

struct object_fetcher_traits<LocalObjectFetcher<CatalogT, HistoryT, ReflogT> > {

    typedef CatalogT CatalogTN;

    typedef HistoryT HistoryTN;

    typedef ReflogT  ReflogTN;

};

/**

 * This implements the AbstractObjectFetcher<> to retrieve repository objects

 * from a remote location through HTTP. It verifies the repository's signature

 * and the downloaded data integrity.

 */

template <class CatalogT = catalog::Catalog,

          class HistoryT = history::SqliteHistory,

          class ReflogT  = manifest::Reflog>

class HttpObjectFetcher :

  public AbstractObjectFetcher<HttpObjectFetcher<CatalogT, HistoryT, ReflogT> >

 protected:

  typedef HttpObjectFetcher<CatalogT, HistoryT, ReflogT>  ThisTN;

  typedef AbstractObjectFetcher<ThisTN>                   BaseTN;

 public:

  typedef typename BaseTN::Failures Failures;

 public:

  /**

   * HttpObjectFetcher<> contains external DownloadManager and SignatureManager

   * hence it essentially is a wrapper object and can be copied.

   *

   * @param repo_name      the name of the repository to download objects from

   * @param repo_url       the URL to the repository's backend storage

   * @param temp_dir       location to store decompressed tmp data

   * @param download_mgr   pointer to the download manager to be used

   * @param signature_mgr  pointer to the signature manager to be used

   *

   * @return               a HttpObjectFetcher<> object or NULL on error

   */

                    const std::string           &repo_url,

                    const std::string           &temp_dir,

                    download::DownloadManager   *download_mgr,

                    signature::SignatureManager *signature_mgr)

    : BaseTN(temp_dir)

    , repo_url_(repo_url)

    , repo_name_(repo_name)

    , download_manager_(download_mgr)

 public:

  using BaseTN::FetchManifest;  // un-hiding convenience overload

    // Download manifest file

    manifest::Failures retval = manifest::Fetch(

                                  repo_url_,

                                  repo_name_,

                                  0,

                                  NULL,

                                  signature_manager_,

                                  download_manager_,

    // Check if manifest was loaded correctly

      case manifest::kFailOk:

      case manifest::kFailNameMismatch:

                 "repository name mismatch. No name provided?");

      case manifest::kFailBadSignature:

      case manifest::kFailBadCertificate:

      case manifest::kFailBadWhitelist:

                 "repository signature mismatch. No key(s) provided?");

      default:

                 "failed to load manifest (%d - %s)",

                 retval, Code2Ascii(retval));

    }

    return (*manifest != NULL) ? BaseTN::kFailOk

  }

  }

  }

                 const bool         decompress,

                 const bool         nocache,

                       std::string *file_path) {

    return Download(relative_path, decompress, nocache, expected_hash,

  }

 protected:

  }

  }

                    const bool         decompress,

                    const bool         nocache,

                    const shash::Any  *expected_hash,

                          std::string *file_path) {

    // create temporary file to host the fetching result

    const std::string tmp_path = BaseTN::temporary_directory() + "/" +

               "failed to create temp file '%s' (errno: %d)",

               tmp_path.c_str(), errno);

    }

    // fetch and decompress the requested object

    download::JobInfo download_job(&url,

                                        decompress,

                                        probe_hosts,

                                        f,

    // check if download worked and remove temporary file if not

                                        "%s to '%s' (%d - %s)",

               relative_path.c_str(), file_path->c_str(),

               retval, Code2Ascii(retval));

      // hand out the error status

        case download::kFailLocalIO:

        case download::kFailBadUrl:

        case download::kFailProxyResolve:

        case download::kFailHostResolve:

        case download::kFailUnsupportedProtocol:

        case download::kFailProxyHttp:

        case download::kFailHostHttp:

          return (download_job.http_code == 404)

            ? BaseTN::kFailNotFound

        case download::kFailBadData:

        case download::kFailTooBig:

        default:

              download::IsHostTransferError(retval)) {

          }

      }

    }

  }

 private:

  const std::string            repo_url_;

  const std::string            repo_name_;

  download::DownloadManager   *download_manager_;

  signature::SignatureManager *signature_manager_;

};

template <class CatalogT, class HistoryT, class ReflogT>

struct object_fetcher_traits<HttpObjectFetcher<CatalogT, HistoryT, ReflogT> > {

    typedef CatalogT CatalogTN;

    typedef HistoryT HistoryTN;

    typedef ReflogT  ReflogTN;

};

#endif  // CVMFS_OBJECT_FETCHER_H_