CernVM-FS  2.9.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  // Note: TEST_CVMFS_RECEIVER_UPSTREAM_STORAGE is used to provide an
41  // an overriding value for CVMFS_UPSTREAM_STORAGE, to be used
42  // only by the cvmfs_receiver application. Useful for testing
43  // when the release manager and the repository gateway are
44  // running on the same machine.
45  if (parser.IsDefined("TEST_CVMFS_RECEIVER_UPSTREAM_STORAGE")) {
46  parser.GetValue("TEST_CVMFS_RECEIVER_UPSTREAM_STORAGE",
47  &params->spooler_configuration);
48  } else {
49  if (!parser.GetValue("CVMFS_UPSTREAM_STORAGE",
50  &params->spooler_configuration)) {
52  "Missing parameter %s in repository configuration file.",
53  "CVMFS_UPSTREAM_STORAGE");
54  return false;
55  }
56  }
57 
58 
59  std::string hash_algorithm_str;
60  if (!parser.GetValue("CVMFS_HASH_ALGORITHM", &hash_algorithm_str)) {
62  "Missing parameter %s in repository configuration file.",
63  "CVMFS_HASH_ALGORITHM");
64  return false;
65  }
66  params->hash_alg = shash::ParseHashAlgorithm(hash_algorithm_str);
67  params->hash_alg_str = hash_algorithm_str;
68 
69  std::string compression_algorithm_str;
70  if (!parser.GetValue("CVMFS_COMPRESSION_ALGORITHM",
71  &compression_algorithm_str)) {
73  "Missing parameter %s in repository configuration file.",
74  "CVMFS_COMPRESSION_ALGORITHM");
75  return false;
76  }
77  params->compression_alg =
78  zlib::ParseCompressionAlgorithm(compression_algorithm_str);
79 
84  params->generate_legacy_bulk_chunks = false;
85 
86  std::string use_chunking_str;
87  if (!parser.GetValue("CVMFS_USE_FILE_CHUNKING", &use_chunking_str)) {
89  "Missing parameter %s in repository configuration file.",
90  "CVMFS_USE_FILE_CHUNKING");
91  return false;
92  }
93  params->use_file_chunking = parser.IsOn(use_chunking_str);
94 
95  std::string min_chunk_size_str;
96  if (!parser.GetValue("CVMFS_MIN_CHUNK_SIZE", &min_chunk_size_str)) {
98  "Missing parameter %s in repository configuration file.",
99  "CVMFS_MIN_CHUNK_SIZE");
100  return false;
101  }
102  params->min_chunk_size = String2Uint64(min_chunk_size_str);
103 
104  std::string avg_chunk_size_str;
105  if (!parser.GetValue("CVMFS_AVG_CHUNK_SIZE", &avg_chunk_size_str)) {
107  "Missing parameter %s in repository configuration file.",
108  "CVMFS_AVG_CHUNK_SIZE");
109  return false;
110  }
111  params->avg_chunk_size = String2Uint64(avg_chunk_size_str);
112 
113  std::string max_chunk_size_str;
114  if (!parser.GetValue("CVMFS_MAX_CHUNK_SIZE", &max_chunk_size_str)) {
116  "Missing parameter %s in repository configuration file.",
117  "CVMFS_MAX_CHUNK_SIZE");
118  return false;
119  }
120  params->max_chunk_size = String2Uint64(max_chunk_size_str);
121 
122  std::string garbage_collection_str;
123  if (!parser.GetValue("CVMFS_GARBAGE_COLLECTION", &garbage_collection_str)) {
125  "Missing parameter %s in repository configuration file.",
126  "CVMFS_GARBAGE_COLLECTION");
127  return false;
128  }
129  params->garbage_collection = parser.IsOn(garbage_collection_str);
130 
131  std::string use_autocatalogs_str;
132  if (!parser.GetValue("CVMFS_AUTOCATALOGS", &use_autocatalogs_str)) {
134  "Missing parameter %s in repository configuration file.",
135  "CVMFS_AUTOCATALOGS");
136  return false;
137  }
138  params->use_autocatalogs = parser.IsOn(use_autocatalogs_str);
139 
140  std::string max_weight_str;
141  if (parser.GetValue("CVMFS_AUTOCATALOGS_MAX_WEIGHT", &max_weight_str)) {
142  params->max_weight = String2Uint64(max_weight_str);
143  }
144 
145  std::string min_weight_str;
146  if (parser.GetValue("CVMFS_AUTOCATALOGS_MIN_WEIGHT", &min_weight_str)) {
147  params->min_weight = String2Uint64(min_weight_str);
148  }
149 
150  std::string enforce_limits_str;
151  if (parser.GetValue("CVMFS_ENFORCE_LIMITS", &enforce_limits_str)) {
152  params->enforce_limits = parser.IsOn(enforce_limits_str);
153  }
154 
155  // TODO(dwd): the next 3 limit variables should take defaults from
156  // SyncParameters
157  params->nested_kcatalog_limit = 0;
158  std::string nested_kcatalog_limit_str;
159  if (parser.GetValue("CVMFS_NESTED_KCATALOG_LIMIT",
160  &nested_kcatalog_limit_str)) {
161  params->nested_kcatalog_limit = String2Uint64(nested_kcatalog_limit_str);
162  }
163 
164  params->root_kcatalog_limit = 0;
165  std::string root_kcatalog_limit_str;
166  if (parser.GetValue("CVMFS_ROOT_KCATALOG_LIMIT", &root_kcatalog_limit_str)) {
167  params->root_kcatalog_limit = String2Uint64(root_kcatalog_limit_str);
168  }
169 
170  params->file_mbyte_limit = 0;
171  std::string file_mbyte_limit_str;
172  if (parser.GetValue("CVMFS_FILE_MBYTE_LIMIT", &file_mbyte_limit_str)) {
173  params->file_mbyte_limit = String2Uint64(file_mbyte_limit_str);
174  }
175 
176  std::string upload_stats_db_str;
177  if (parser.GetValue("CVMFS_UPLOAD_STATS_DB", &upload_stats_db_str)) {
178  params->upload_stats_db = parser.IsOn(upload_stats_db_str);
179  } else {
180  params->upload_stats_db = false;
181  }
182 
183  return true;
184 }
185 
186 } // namespace receiver
#define LogCvmfs(source, mask,...)
Definition: logging.h:20
Algorithms ParseCompressionAlgorithm(const std::string &algorithm_option)
Definition: compression.cc:148
bool GetValue(const std::string &key, std::string *value)
Definition: options.cc:376
size_t min_weight
Definition: params.h:35
size_t avg_chunk_size
Definition: params.h:26
std::string spooler_configuration
Definition: params.h:19
vector< string > SplitString(const string &str, const char delim, const unsigned max_chunks)
Definition: string.cc:287
zlib::Algorithms compression_alg
Definition: params.h:22
size_t nested_kcatalog_limit
Definition: params.h:29
bool GetParamsFromFile(const std::string &repo_name, Params *params)
Definition: params.cc:20
bool use_autocatalogs
Definition: params.h:33
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:24
std::string hash_alg_str
Definition: params.h:21
size_t max_weight
Definition: params.h:34
bool TryParsePath(const std::string &config_file)
Definition: options.cc:110
size_t max_chunk_size
Definition: params.h:27
std::string stratum0
Definition: params.h:18
bool garbage_collection
Definition: params.h:32
size_t min_chunk_size
Definition: params.h:25
uint64_t String2Uint64(const string &value)
Definition: string.cc:227
size_t file_mbyte_limit
Definition: params.h:31
Algorithms ParseHashAlgorithm(const string &algorithm_option)
Definition: hash.cc:72
size_t root_kcatalog_limit
Definition: params.h:30
bool upload_stats_db
Definition: params.h:36
bool generate_legacy_bulk_chunks
Definition: params.h:23
bool enforce_limits
Definition: params.h:28
bool IsDefined(const std::string &key)
Definition: options.cc:370
bool IsOn(const std::string &param_value)
Definition: options.cc:409
shash::Algorithms hash_alg
Definition: params.h:20