CernVM-FS  2.10.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
params.cc
Go to the documentation of this file.
1 
5 #include "params.h"
6 
7 #include <vector>
8 
9 #include "options.h"
10 #include "util/string.h"
11 
12 namespace receiver {
13 
14 std::string GetSpoolerTempDir(const std::string& spooler_config) {
15  const std::vector<std::string> tokens = SplitString(spooler_config, ',');
16  assert(tokens.size() == 3);
17  return tokens[1];
18 }
19 
20 bool GetParamsFromFile(const std::string& repo_name, Params* params) {
21  const std::string repo_config_file =
22  "/etc/cvmfs/repositories.d/" + repo_name + "/server.conf";
23 
25  new DefaultOptionsTemplateManager(repo_name));
26  if (!parser.TryParsePath(repo_config_file)) {
28  "Could not parse repository configuration: %s.",
29  repo_config_file.c_str());
30  return false;
31  }
32 
33  if (!parser.GetValue("CVMFS_STRATUM0", &params->stratum0)) {
35  "Missing parameter %s in repository configuration file.",
36  "CVMFS_STRATUM0");
37  return false;
38  }
39 
40  if (parser.IsDefined("CVMFS_SERVER_PROXY")) {
41  parser.GetValue("CVMFS_SERVER_PROXY", &params->proxy);
42  }
43 
44  // Note: TEST_CVMFS_RECEIVER_UPSTREAM_STORAGE is used to provide an
45  // an overriding value for CVMFS_UPSTREAM_STORAGE, to be used
46  // only by the cvmfs_receiver application. Useful for testing
47  // when the release manager and the repository gateway are
48  // running on the same machine.
49  if (parser.IsDefined("TEST_CVMFS_RECEIVER_UPSTREAM_STORAGE")) {
50  parser.GetValue("TEST_CVMFS_RECEIVER_UPSTREAM_STORAGE",
51  &params->spooler_configuration);
52  } else {
53  if (!parser.GetValue("CVMFS_UPSTREAM_STORAGE",
54  &params->spooler_configuration)) {
56  "Missing parameter %s in repository configuration file.",
57  "CVMFS_UPSTREAM_STORAGE");
58  return false;
59  }
60  }
61 
62 
63  std::string hash_algorithm_str;
64  if (!parser.GetValue("CVMFS_HASH_ALGORITHM", &hash_algorithm_str)) {
66  "Missing parameter %s in repository configuration file.",
67  "CVMFS_HASH_ALGORITHM");
68  return false;
69  }
70  params->hash_alg = shash::ParseHashAlgorithm(hash_algorithm_str);
71  params->hash_alg_str = hash_algorithm_str;
72 
73  std::string compression_algorithm_str;
74  if (!parser.GetValue("CVMFS_COMPRESSION_ALGORITHM",
75  &compression_algorithm_str)) {
77  "Missing parameter %s in repository configuration file.",
78  "CVMFS_COMPRESSION_ALGORITHM");
79  return false;
80  }
81  params->compression_alg =
82  zlib::ParseCompressionAlgorithm(compression_algorithm_str);
83 
88  params->generate_legacy_bulk_chunks = false;
89 
90  std::string use_chunking_str;
91  if (!parser.GetValue("CVMFS_USE_FILE_CHUNKING", &use_chunking_str)) {
93  "Missing parameter %s in repository configuration file.",
94  "CVMFS_USE_FILE_CHUNKING");
95  return false;
96  }
97  params->use_file_chunking = parser.IsOn(use_chunking_str);
98 
99  std::string min_chunk_size_str;
100  if (!parser.GetValue("CVMFS_MIN_CHUNK_SIZE", &min_chunk_size_str)) {
102  "Missing parameter %s in repository configuration file.",
103  "CVMFS_MIN_CHUNK_SIZE");
104  return false;
105  }
106  params->min_chunk_size = String2Uint64(min_chunk_size_str);
107 
108  std::string avg_chunk_size_str;
109  if (!parser.GetValue("CVMFS_AVG_CHUNK_SIZE", &avg_chunk_size_str)) {
111  "Missing parameter %s in repository configuration file.",
112  "CVMFS_AVG_CHUNK_SIZE");
113  return false;
114  }
115  params->avg_chunk_size = String2Uint64(avg_chunk_size_str);
116 
117  std::string max_chunk_size_str;
118  if (!parser.GetValue("CVMFS_MAX_CHUNK_SIZE", &max_chunk_size_str)) {
120  "Missing parameter %s in repository configuration file.",
121  "CVMFS_MAX_CHUNK_SIZE");
122  return false;
123  }
124  params->max_chunk_size = String2Uint64(max_chunk_size_str);
125 
126  std::string garbage_collection_str;
127  if (!parser.GetValue("CVMFS_GARBAGE_COLLECTION", &garbage_collection_str)) {
129  "Missing parameter %s in repository configuration file.",
130  "CVMFS_GARBAGE_COLLECTION");
131  return false;
132  }
133  params->garbage_collection = parser.IsOn(garbage_collection_str);
134 
135  std::string use_autocatalogs_str;
136  if (!parser.GetValue("CVMFS_AUTOCATALOGS", &use_autocatalogs_str)) {
138  "Missing parameter %s in repository configuration file.",
139  "CVMFS_AUTOCATALOGS");
140  return false;
141  }
142  params->use_autocatalogs = parser.IsOn(use_autocatalogs_str);
143 
144  std::string max_weight_str;
145  if (parser.GetValue("CVMFS_AUTOCATALOGS_MAX_WEIGHT", &max_weight_str)) {
146  params->max_weight = String2Uint64(max_weight_str);
147  }
148 
149  std::string min_weight_str;
150  if (parser.GetValue("CVMFS_AUTOCATALOGS_MIN_WEIGHT", &min_weight_str)) {
151  params->min_weight = String2Uint64(min_weight_str);
152  }
153 
154  std::string enforce_limits_str;
155  if (parser.GetValue("CVMFS_ENFORCE_LIMITS", &enforce_limits_str)) {
156  params->enforce_limits = parser.IsOn(enforce_limits_str);
157  }
158 
159  // TODO(dwd): the next 3 limit variables should take defaults from
160  // SyncParameters
161  params->nested_kcatalog_limit = 0;
162  std::string nested_kcatalog_limit_str;
163  if (parser.GetValue("CVMFS_NESTED_KCATALOG_LIMIT",
164  &nested_kcatalog_limit_str)) {
165  params->nested_kcatalog_limit = String2Uint64(nested_kcatalog_limit_str);
166  }
167 
168  params->root_kcatalog_limit = 0;
169  std::string root_kcatalog_limit_str;
170  if (parser.GetValue("CVMFS_ROOT_KCATALOG_LIMIT", &root_kcatalog_limit_str)) {
171  params->root_kcatalog_limit = String2Uint64(root_kcatalog_limit_str);
172  }
173 
174  params->file_mbyte_limit = 0;
175  std::string file_mbyte_limit_str;
176  if (parser.GetValue("CVMFS_FILE_MBYTE_LIMIT", &file_mbyte_limit_str)) {
177  params->file_mbyte_limit = String2Uint64(file_mbyte_limit_str);
178  }
179 
180  std::string upload_stats_db_str;
181  if (parser.GetValue("CVMFS_UPLOAD_STATS_DB", &upload_stats_db_str)) {
182  params->upload_stats_db = parser.IsOn(upload_stats_db_str);
183  } else {
184  params->upload_stats_db = false;
185  }
186 
187  return true;
188 }
189 
190 } // namespace receiver
#define LogCvmfs(source, mask,...)
Definition: logging.h:20
Algorithms ParseCompressionAlgorithm(const std::string &algorithm_option)
Definition: compression.cc:148
size_t min_weight
Definition: params.h:36
size_t avg_chunk_size
Definition: params.h:27
std::string spooler_configuration
Definition: params.h:20
vector< string > SplitString(const string &str, const char delim, const unsigned max_chunks)
Definition: string.cc:288
zlib::Algorithms compression_alg
Definition: params.h:23
size_t nested_kcatalog_limit
Definition: params.h:30
bool GetParamsFromFile(const std::string &repo_name, Params *params)
Definition: params.cc:20
bool IsOn(const std::string &param_value) const
Definition: options.cc:409
bool use_autocatalogs
Definition: params.h:34
assert((mem||(size==0))&&"Out Of Memory")
std::string GetSpoolerTempDir(const std::string &spooler_config)
Definition: params.cc:14
bool use_file_chunking
Definition: params.h:25
std::string hash_alg_str
Definition: params.h:22
size_t max_weight
Definition: params.h:35
bool TryParsePath(const std::string &config_file)
Definition: options.cc:110
size_t max_chunk_size
Definition: params.h:28
std::string stratum0
Definition: params.h:18
bool GetValue(const std::string &key, std::string *value) const
Definition: options.cc:376
bool garbage_collection
Definition: params.h:33
size_t min_chunk_size
Definition: params.h:26
uint64_t String2Uint64(const string &value)
Definition: string.cc:228
size_t file_mbyte_limit
Definition: params.h:32
Algorithms ParseHashAlgorithm(const string &algorithm_option)
Definition: hash.cc:72
size_t root_kcatalog_limit
Definition: params.h:31
std::string proxy
Definition: params.h:19
bool upload_stats_db
Definition: params.h:37
bool generate_legacy_bulk_chunks
Definition: params.h:24
bool enforce_limits
Definition: params.h:29
bool IsDefined(const std::string &key)
Definition: options.cc:370
shash::Algorithms hash_alg
Definition: params.h:21