CernVM-FS  2.11.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
magic_xattr.cc
Go to the documentation of this file.
1 
5 #include "magic_xattr.h"
6 
7 #include <cassert>
8 #include <string>
9 #include <vector>
10 
11 #include "catalog_mgr_client.h"
12 #include "crypto/signature.h"
13 #include "fetch.h"
14 #include "mountpoint.h"
15 #include "quota.h"
16 #include "util/logging.h"
17 #include "util/string.h"
18 
20  EVisibility visibility,
21  const std::set<std::string> &protected_xattrs,
22  const std::set<gid_t> &priviledged_xattr_gids)
23  : mount_point_(mountpoint),
24  visibility_(visibility),
25  protected_xattrs_(protected_xattrs),
26  privileged_xattr_gids_(priviledged_xattr_gids),
27  is_frozen_(false)
28 {
29  Register("user.catalog_counters", new CatalogCountersMagicXattr());
30  Register("user.external_host", new ExternalHostMagicXattr());
31  Register("user.external_timeout", new ExternalTimeoutMagicXattr());
32  Register("user.fqrn", new FqrnMagicXattr());
33  Register("user.host", new HostMagicXattr());
34  Register("user.host_list", new HostListMagicXattr());
35  Register("user.ncleanup24", new NCleanup24MagicXattr());
36  Register("user.nclg", new NClgMagicXattr());
37  Register("user.ndiropen", new NDirOpenMagicXattr());
38  Register("user.ndownload", new NDownloadMagicXattr());
39  Register("user.nioerr", new NIOErrMagicXattr());
40  Register("user.nopen", new NOpenMagicXattr());
41  Register("user.hitrate", new HitrateMagicXattr());
42  Register("user.logbuffer", new LogBufferXattr());
43  Register("user.proxy", new ProxyMagicXattr());
44  Register("user.proxy_list", new ProxyListMagicXattr());
45  Register("user.proxy_list_external", new ProxyListExternalMagicXattr());
46  Register("user.pubkeys", new PubkeysMagicXattr());
47  Register("user.repo_counters", new RepoCountersMagicXattr());
48  Register("user.repo_metainfo", new RepoMetainfoMagicXattr());
49  Register("user.revision", new RevisionMagicXattr());
50  Register("user.root_hash", new RootHashMagicXattr());
51  Register("user.rx", new RxMagicXattr());
52  Register("user.speed", new SpeedMagicXattr());
53  Register("user.tag", new TagMagicXattr());
54  Register("user.timeout", new TimeoutMagicXattr());
55  Register("user.timeout_direct", new TimeoutDirectMagicXattr());
56  Register("user.timestamp_last_ioerr", new TimestampLastIOErrMagicXattr());
57  Register("user.usedfd", new UsedFdMagicXattr());
58  Register("user.useddirp", new UsedDirPMagicXattr());
59  Register("user.version", new VersionMagicXattr());
60 
61  Register("user.hash", new HashMagicXattr());
62  Register("user.lhash", new LHashMagicXattr());
63 
64  Register("user.chunk_list", new ChunkListMagicXattr());
65  Register("user.chunks", new ChunksMagicXattr());
66  Register("user.compression", new CompressionMagicXattr());
67  Register("user.direct_io", new DirectIoMagicXattr());
68  Register("user.external_file", new ExternalFileMagicXattr());
69 
70  Register("user.rawlink", new RawlinkMagicXattr());
71  Register("xfsroot.rawlink", new RawlinkMagicXattr());
72 
73  Register("user.authz", new AuthzMagicXattr());
74  Register("user.external_url", new ExternalURLMagicXattr());
75 }
76 
78  if (visibility() == kVisibilityNever) {
79  return "";
80  }
81  // Only the root entry has an empty name
82  if (visibility() == kVisibilityRootOnly && !dirent->name().IsEmpty()) {
83  return "";
84  }
85 
86  std::string result;
87  std::map<std::string, BaseMagicXattr *>::iterator it = xattr_list_.begin();
88  for (; it != xattr_list_.end(); ++it) {
89  MagicXattrFlavor flavor = (*it).second->GetXattrFlavor();
90  // Skip those which should not be displayed
91  switch (flavor) {
92  case kXattrBase:
93  break;
94  case kXattrWithHash:
95  if (dirent->checksum().IsNull()) continue;
96  break;
97  case kXattrRegular:
98  if (!dirent->IsRegular()) continue;
99  break;
100  case kXattrExternal:
101  if (!(dirent->IsRegular() && dirent->IsExternalFile())) continue;
102  break;
103  case kXattrSymlink:
104  if (!dirent->IsLink()) continue;
105  break;
106  case kXattrAuthz:
107  if (!mount_point_->has_membership_req()) continue;
108  break;
109  default:
110  PANIC("unknown magic xattr flavor");
111  }
112  result += (*it).first;
113  result.push_back('\0');
114  }
115 
116  return result;
117 }
118 
120  PathString path,
122 {
123  BaseMagicXattr *result;
124  if (xattr_list_.count(name) > 0) {
125  result = xattr_list_[name];
126  } else {
127  return NULL;
128  }
129 
130  result->Lock(path, d);
131 
132  return result;
133 }
134 
135 void MagicXattrManager::Register(const std::string &name,
136  BaseMagicXattr *magic_xattr)
137 {
138  assert(!is_frozen_);
139  if (xattr_list_.count(name) > 0) {
141  "Magic extended attribute with name %s already registered",
142  name.c_str());
143  }
144  magic_xattr->xattr_mgr_ = this;
145  xattr_list_[name] = magic_xattr;
146 
147  // Mark Xattr protected so that only certain fuse_gids' can access it.
148  // If Xattr with registered "name" is part of *protected_xattrs
149  if (protected_xattrs_.count(name) > 0) {
150  magic_xattr->MarkProtected();
151  }
152 }
153 
155  return privileged_xattr_gids_.count(gid) > 0;
156 }
157 
160  if (is_protected_ && !xattr_mgr_->IsPrivilegedGid(gid)) {
161  return false;
162  }
163 
164  return PrepareValueFenced();
165 }
166 
168  std::set<std::string>::const_iterator iter;
169  std::vector<string> tmp;
170  for (iter = protected_xattrs_.begin();
171  iter != protected_xattrs_.end(); iter++) {
172  if (xattr_list_.find(*iter) == xattr_list_.end()) {
173  tmp.push_back(*iter);
174  }
175  }
176 
177  if (tmp.size() > 0) {
178  std::string msg = JoinStrings(tmp, ",");
180  "Following CVMFS_XATTR_PROTECTED_XATTRS are "
181  "set but not recognized: %s", msg.c_str());
182  }
183 
184  tmp.clear();
185  std::set<gid_t>::const_iterator iter_gid;
186  for (iter_gid = privileged_xattr_gids_.begin();
187  iter_gid != privileged_xattr_gids_.end(); iter_gid++) {
188  tmp.push_back(StringifyUint(*iter_gid));
189  }
190 
191  if (tmp.size() > 0) {
192  std::string msg = JoinStrings(tmp, ",");
194  "Following CVMFS_XATTR_PRIVILEGED_GIDS are set: %s", msg.c_str());
195  }
196 }
197 
200 }
201 
204 }
205 
207  return kXattrAuthz;
208 }
209 
211  counters_ =
213  LookupCounters(path_, &subcatalog_path_, &hash_);
214  return true;
215 }
216 
218  std::string res;
219  res = "catalog_hash: " + hash_.ToString() + "\n";
220  res += "catalog_mountpoint: " + subcatalog_path_ + "\n";
221  res += counters_.GetCsvMap();
222  return res;
223 }
224 
226  chunk_list_ = "hash,offset,size\n";
227  if (!dirent_->IsRegular()) {
228  return false;
229  }
230  if (dirent_->IsChunkedFile()) {
231  FileChunkList chunks;
234  || chunks.IsEmpty())
235  {
236  LogCvmfs(kLogCvmfs, kLogDebug | kLogSyslogErr, "file %s is marked as "
237  "'chunked', but no chunks found.", path_.c_str());
238  return false;
239  } else {
240  for (size_t i = 0; i < chunks.size(); ++i) {
241  chunk_list_ += chunks.At(i).content_hash().ToString() + ",";
242  chunk_list_ += StringifyInt(chunks.At(i).offset()) + ",";
243  chunk_list_ += StringifyUint(chunks.At(i).size()) + "\n";
244  }
245  }
246  } else {
247  chunk_list_ += dirent_->checksum().ToString() + ",";
248  chunk_list_ += "0,";
249  chunk_list_ += StringifyUint(dirent_->size()) + "\n";
250  }
251  return true;
252 }
253 
255  return chunk_list_;
256 }
257 
259  if (!dirent_->IsRegular()) {
260  return false;
261  }
262  if (dirent_->IsChunkedFile()) {
263  FileChunkList chunks;
266  || chunks.IsEmpty())
267  {
268  LogCvmfs(kLogCvmfs, kLogDebug | kLogSyslogErr, "file %s is marked as "
269  "'chunked', but no chunks found.", path_.c_str());
270  return false;
271  } else {
272  n_chunks_ = chunks.size();
273  }
274  } else {
275  n_chunks_ = 1;
276  }
277 
278  return true;
279 }
280 
282  return StringifyUint(n_chunks_);
283 }
284 
286  return dirent_->IsRegular();
287 }
288 
291 }
292 
294  return dirent_->IsRegular();
295 }
296 
298  return dirent_->IsDirectIo() ? "1" : "0";
299 }
300 
302  return dirent_->IsRegular();
303 }
304 
306  return dirent_->IsExternalFile() ? "1" : "0";
307 }
308 
310  std::vector<string> host_chain;
311  std::vector<int> rtt;
312  unsigned current_host;
314  &host_chain, &rtt, &current_host);
315  if (host_chain.size()) {
316  return std::string(host_chain[current_host]);
317  } else {
318  return "internal error: no hosts defined";
319  }
320 }
321 
323  unsigned seconds, seconds_direct;
325  GetTimeout(&seconds, &seconds_direct);
326  return StringifyUint(seconds_direct);
327 }
328 
330  return xattr_mgr_->mount_point()->fqrn();
331 }
332 
334  return !dirent_->checksum().IsNull();
335 }
336 
338  return dirent_->checksum().ToString();
339 }
340 
342  std::vector<std::string> host_chain;
343  std::vector<int> rtt;
344  unsigned current_host;
346  GetHostInfo(&host_chain, &rtt, &current_host);
347  if (host_chain.size()) {
348  return std::string(host_chain[current_host]);
349  } else {
350  return "internal error: no hosts defined";
351  }
352 }
353 
355  std::string result;
356  std::vector<std::string> host_chain;
357  std::vector<int> rtt;
358  unsigned current_host;
360  GetHostInfo(&host_chain, &rtt, &current_host);
361  if (host_chain.size()) {
362  result = host_chain[current_host];
363  for (unsigned i = 1; i < host_chain.size(); ++i) {
364  result +=
365  ";" + host_chain[(i+current_host) % host_chain.size()];
366  }
367  } else {
368  result = "internal error: no hosts defined";
369  }
370  return result;
371 }
372 
374  return !dirent_->checksum().IsNull();
375 }
376 
378  string result;
379  CacheManager::ObjectInfo object_info;
380  object_info.description = path_.ToString();
382  object_info.type = CacheManager::kTypeVolatile;
383  int fd = xattr_mgr_->mount_point()->file_system()->cache_mgr()->Open(
384  CacheManager::Bless(dirent_->checksum(), object_info));
385  if (fd < 0) {
386  result = "Not in cache";
387  } else {
389  int retval_i =
391  ->ChecksumFd(fd, &hash);
392  if (retval_i != 0)
393  result = "I/O error (" + StringifyInt(retval_i) + ")";
394  else
395  result = hash.ToString();
397  }
398  return result;
399 }
400 
401 LogBufferXattr::LogBufferXattr() : BaseMagicXattr(), throttle_(1, 500, 2000) { }
402 
405  std::vector<LogBufferEntry> buffer = GetLogBuffer();
406  std::string result;
407  for (std::vector<LogBufferEntry>::reverse_iterator itr = buffer.rbegin();
408  itr != buffer.rend(); ++itr)
409  {
410  if (itr->message.size() > kMaxLogLine) {
411  itr->message.resize(kMaxLogLine);
412  itr->message += " <snip>";
413  }
414  result += "[" + StringifyTime(itr->timestamp, true /* UTC */) + " UTC] " +
415  itr->message + "\n";
416  }
417  return result;
418 }
419 
421  QuotaManager *quota_mgr =
424  return StringifyInt(-1);
425  } else {
426  const uint64_t period_s = 24 * 60 * 60;
427  const uint64_t rate = quota_mgr->GetCleanupRate(period_s);
428  return StringifyInt(rate);
429  }
430 }
431 
434  return true;
435 }
436 
438  return StringifyInt(n_catalogs_);
439 }
440 
443 }
444 
446  return xattr_mgr_->mount_point()->statistics()->Lookup("fetch.n_downloads")
447  ->Print();
448 }
449 
452  ->count());
453 }
454 
457 }
458 
460  int64_t n_invocations =
461  xattr_mgr_->mount_point()->statistics()->Lookup("fetch.n_invocations")
462  ->Get();
463  if (n_invocations == 0)
464  return "n/a";
465 
466  int64_t n_downloads =
467  xattr_mgr_->mount_point()->statistics()->Lookup("fetch.n_downloads")->Get();
468  float hitrate = 100. * (1. -
469  (static_cast<float>(n_downloads) / static_cast<float>(n_invocations)));
470  return StringifyDouble(hitrate);
471 }
472 
474  vector< vector<download::DownloadManager::ProxyInfo> > proxy_chain;
475  unsigned current_group;
477  &proxy_chain, &current_group, NULL);
478  if (proxy_chain.size()) {
479  return proxy_chain[current_group][0].url;
480  } else {
481  return "DIRECT";
482  }
483 }
484 
485 static std::string ListProxy(download::DownloadManager *dm) {
486  vector< vector<download::DownloadManager::ProxyInfo> > proxy_chain;
487  unsigned current_group;
488  dm->GetProxyInfo(&proxy_chain, &current_group, NULL);
489  std::string buf = "";
490  for (unsigned int i = 0; i < proxy_chain.size(); i++) {
491  for (unsigned int j = 0; j < proxy_chain[i].size(); j++) {
492  buf += proxy_chain[i][j].url;
493  buf += "\n";
494  }
495  }
496  return buf;
497 }
498 
501 }
502 
505 }
506 
509  return true;
510 }
511 
513  return pubkeys_;
514 }
515 
517  return dirent_->IsLink();
518 }
519 
521  return dirent_->symlink().ToString();
522 }
523 
526  ->GetCounters();
527  return true;
528 }
529 
531  return counters_.GetCsvMap();
532 }
533 
535 
537  if (!xattr_mgr_->mount_point()->catalog_mgr()->manifest()) {
538  error_reason_ = "manifest not available";
539  return true;
540  }
541 
543  ->meta_info();
544  if (metainfo_hash_.IsNull()) {
545  error_reason_ = "metainfo not available";
546  return true;
547  }
548  return true;
549 }
550 
552  if (metainfo_hash_.IsNull()) {
553  return error_reason_;
554  }
555 
556  int fd = xattr_mgr_->mount_point()->fetcher()->
558  "metainfo (" + metainfo_hash_.ToString() + ")",
560  if (fd < 0) {
561  return "Failed to open metadata file";
562  }
563  uint64_t actual_size = xattr_mgr_->mount_point()->file_system()->cache_mgr()
564  ->GetSize(fd);
565  if (actual_size > kMaxMetainfoLength) {
567  return "Failed to open: metadata file is too big";
568  }
569  char buffer[kMaxMetainfoLength];
570  int64_t bytes_read =
572  ->Pread(fd, buffer, actual_size, 0);
574  if (bytes_read < 0) {
575  return "Failed to read metadata file";
576  }
577  return string(buffer, buffer + bytes_read);
578 }
579 
582  return true;
583 }
584 
586  return StringifyUint(revision_);
587 }
588 
591  return true;
592 }
593 
595  return root_hash_.ToString();
596 }
597 
598 std::string RxMagicXattr::GetValue() {
600  int64_t rx = statistics->Lookup("download.sz_transferred_bytes")->Get();
601  return StringifyInt(rx/1024);
602 }
603 
606  int64_t rx = statistics->Lookup("download.sz_transferred_bytes")->Get();
607  int64_t time = statistics->Lookup("download.sz_transfer_time")->Get();
608  if (time == 0)
609  return "n/a";
610  else
611  return StringifyInt((1000 * (rx/1024))/time);
612 }
613 
616  return true;
617 }
618 
619 std::string TagMagicXattr::GetValue() {
620  return tag_;
621 }
622 
624  unsigned seconds, seconds_direct;
626  ->GetTimeout(&seconds, &seconds_direct);
627  return StringifyUint(seconds);
628 }
629 
631  unsigned seconds, seconds_direct;
633  ->GetTimeout(&seconds, &seconds_direct);
634  return StringifyUint(seconds_direct);
635 }
636 
638  return StringifyInt(
640  ->timestamp_last());
641 }
642 
645 }
646 
649 }
650 
652  return std::string(VERSION) + "." + std::string(CVMFS_PATCH_LEVEL);
653 }
654 
656  std::vector<std::string> host_chain;
657  std::vector<int> rtt;
658  unsigned current_host;
659  if (xattr_mgr_->mount_point()->external_download_mgr() != NULL) {
661  &host_chain, &rtt, &current_host);
662  if (host_chain.size()) {
663  return std::string(host_chain[current_host]) + std::string(path_.c_str());
664  }
665  }
666  return std::string("");
667 }
668 
670  return dirent_->IsRegular() && dirent_->IsExternalFile();
671 }
std::vector< LogBufferEntry > GetLogBuffer()
Definition: logging.cc:535
#define LogCvmfs(source, mask,...)
Definition: logging.h:25
std::string ToString()
Definition: statistics.cc:24
const std::set< gid_t > privileged_xattr_gids_
Definition: magic_xattr.h:212
int ChecksumFd(int fd, shash::Any *id)
Definition: cache.cc:39
virtual std::string GetValue()
Definition: magic_xattr.cc:420
bool IsExternalFile() const
const Counters & GetCounters() const
Definition: catalog.h:175
bool IsNull() const
Definition: hash.h:383
virtual int64_t GetSize(int fd)=0
FileSystem * file_system()
Definition: mountpoint.h:509
MagicXattrFlavor
Definition: magic_xattr.h:21
Item At(const size_t index) const
Definition: bigvector.h:50
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:225
bool PrepareValueFencedProtected(gid_t gid)
Definition: magic_xattr.cc:158
virtual std::string GetValue()
Definition: magic_xattr.cc:598
cvmfs::Fetcher * fetcher()
Definition: mountpoint.h:505
std::string subcatalog_path_
Definition: magic_xattr.h:227
virtual uint64_t GetCleanupRate(uint64_t period_s)=0
bool IsChunkedFile() const
perf::Statistics * statistics()
Definition: mountpoint.h:528
void Register(const std::string &name, BaseMagicXattr *magic_xattr)
Definition: magic_xattr.cc:135
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:589
virtual std::string GetValue()
Definition: magic_xattr.cc:499
std::string Print()
Definition: statistics.cc:25
MountPoint * mount_point()
Definition: magic_xattr.h:201
#define PANIC(...)
Definition: exception.h:29
virtual std::string GetValue()
Definition: magic_xattr.cc:217
uint64_t size() const
string JoinStrings(const vector< string > &strings, const string &joint)
Definition: string.cc:325
std::string ToString(const bool with_suffix=false) const
Definition: hash.h:249
virtual std::string GetValue()
Definition: magic_xattr.cc:604
virtual std::string GetValue()
Definition: magic_xattr.cc:309
std::string fqrn() const
Definition: mountpoint.h:507
catalog::Counters counters_
Definition: magic_xattr.h:229
void MarkProtected()
Definition: magic_xattr.h:59
BaseMagicXattr * GetLocked(const std::string &name, PathString path, catalog::DirectoryEntry *d)
Definition: magic_xattr.cc:119
const std::set< std::string > protected_xattrs_
Definition: magic_xattr.h:211
virtual std::string GetValue()
Definition: magic_xattr.cc:623
std::string error_reason_
Definition: magic_xattr.h:374
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:669
virtual std::string GetValue()
Definition: magic_xattr.cc:530
const shash::Any & content_hash() const
Definition: file_chunk.h:41
shash::Any root_hash_
Definition: magic_xattr.h:388
virtual std::string GetValue()
Definition: magic_xattr.cc:322
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:614
std::string AlgorithmName(const zlib::Algorithms alg)
Definition: compression.cc:158
assert((mem||(size==0))&&"Out Of Memory")
MountPoint * mount_point_
Definition: cvmfs.cc:124
virtual std::string GetValue()
Definition: magic_xattr.cc:647
bool IsDirectIo() const
virtual std::string GetValue()
Definition: magic_xattr.cc:655
catalog::DirectoryEntry * dirent_
Definition: magic_xattr.h:102
Algorithms algorithm
Definition: hash.h:125
virtual std::string GetValue()
Definition: magic_xattr.cc:281
virtual int Open(const BlessedObject &object)=0
string StringifyTime(const time_t seconds, const bool utc)
Definition: string.cc:105
string StringifyDouble(const double value)
Definition: string.cc:96
virtual std::string GetValue()
Definition: magic_xattr.cc:354
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:285
std::string StringifyUint(const uint64_t value)
Definition: string.cc:84
virtual std::string GetValue()
Definition: magic_xattr.cc:377
shash::Any checksum() const
bool IsPrivilegedGid(gid_t gid)
Definition: magic_xattr.cc:154
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:210
bool has_membership_req()
Definition: mountpoint.h:511
std::string description
Definition: cache.h:97
std::string chunk_list_
Definition: magic_xattr.h:236
virtual std::string GetValue()
Definition: magic_xattr.cc:202
static uint64_t kMaxMetainfoLength
Definition: magic_xattr.h:371
MountPoint * mount_point_
Definition: magic_xattr.h:206
virtual std::string GetValue()
Definition: magic_xattr.cc:459
perf::Counter * n_fs_open()
Definition: mountpoint.h:222
virtual std::string GetValue()
Definition: magic_xattr.cc:403
std::string membership_req()
Definition: mountpoint.h:522
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:432
void Throttle()
Definition: backoff.cc:50
MagicXattrManager * xattr_mgr_
Definition: magic_xattr.h:100
std::string GetListString(catalog::DirectoryEntry *dirent)
Definition: magic_xattr.cc:77
virtual std::string GetValue()
Definition: magic_xattr.cc:305
std::string GetActivePubkeys() const
Definition: signature.cc:385
Counter * Lookup(const std::string &name) const
Definition: statistics.cc:62
NameString name() const
virtual std::string GetValue()
Definition: magic_xattr.cc:585
bool IsLink() const
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:580
void GetProxyInfo(std::vector< std::vector< ProxyInfo > > *proxy_chain, unsigned *current_group, unsigned *fallback_group)
Definition: download.cc:2574
std::string repository_tag()
Definition: mountpoint.h:526
catalog::ClientCatalogManager * catalog_mgr()
Definition: mountpoint.h:496
bool is_frozen() const
Definition: magic_xattr.h:202
bool IsRegular() const
virtual std::string GetValue()
Definition: magic_xattr.cc:619
virtual std::string GetValue()
Definition: magic_xattr.cc:329
ObjectType type
Definition: cache.h:93
virtual std::string GetValue()
Definition: magic_xattr.cc:455
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:524
EVisibility visibility()
Definition: magic_xattr.h:198
perf::Counter * no_open_dirs()
Definition: mountpoint.h:232
virtual std::string GetValue()
Definition: magic_xattr.cc:643
Failures Fetch(const std::string &base_url, const std::string &repository_name, const uint64_t minimum_timestamp, const shash::Any *base_catalog, signature::SignatureManager *signature_manager, download::DownloadManager *download_manager, ManifestEnsemble *ensemble)
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:373
off_t offset() const
Definition: file_chunk.h:42
zlib::Algorithms compression_algorithm() const
CacheManager * cache_mgr()
Definition: mountpoint.h:201
perf::Counter * no_open_files()
Definition: mountpoint.h:233
virtual std::string GetValue()
Definition: magic_xattr.cc:337
LinkString symlink() const
IoErrorInfo * io_error_info()
Definition: mountpoint.h:229
const unsigned int kMaxLogLine
Definition: magic_xattr.h:299
download::DownloadManager * download_mgr()
Definition: mountpoint.h:498
virtual std::string GetValue()
Definition: magic_xattr.cc:651
virtual std::string GetValue()
Definition: magic_xattr.cc:594
string StringifyInt(const int64_t value)
Definition: string.cc:78
virtual std::string GetValue()
Definition: magic_xattr.cc:441
virtual int Close(int fd)=0
virtual std::string GetValue()
Definition: magic_xattr.cc:445
shash::Algorithms hash_algorithm() const
perf::Counter * n_fs_dir_open()
Definition: mountpoint.h:217
virtual std::string GetValue()
Definition: magic_xattr.cc:473
int64_t Get()
Definition: statistics.h:32
virtual std::string GetValue()
Definition: magic_xattr.cc:450
CatalogT * GetRootCatalog() const
Definition: catalog_mgr.h:195
virtual std::string GetValue()
Definition: magic_xattr.cc:503
std::string tag_
Definition: magic_xattr.h:403
bool IsEmpty() const
Definition: bigvector.h:72
static BlessedObject Bless(const shash::Any &id)
Definition: cache.h:125
MagicXattrManager(MountPoint *mountpoint, EVisibility visibility, const std::set< std::string > &protected_xattrs, const std::set< gid_t > &privileged_xattr_gids)
Definition: magic_xattr.cc:19
shash::Any metainfo_hash_
Definition: magic_xattr.h:373
signature::SignatureManager * signature_mgr()
Definition: mountpoint.h:530
BackoffThrottle throttle_
Definition: magic_xattr.h:303
uint64_t n_chunks_
Definition: magic_xattr.h:243
virtual std::string GetValue()
Definition: magic_xattr.cc:254
std::string ToString() const
Definition: shortstring.h:141
virtual std::string GetValue()
Definition: magic_xattr.cc:551
QuotaManager * quota_mgr()
Definition: cache.h:198
virtual std::string GetValue()
Definition: magic_xattr.cc:437
bool IsEmpty() const
Definition: shortstring.h:137
virtual std::string GetValue()
Definition: magic_xattr.cc:341
PathString path_
Definition: magic_xattr.h:101
virtual std::string GetValue()
Definition: magic_xattr.cc:637
virtual std::string GetValue()
Definition: magic_xattr.cc:289
bool ListFileChunks(const PathString &path, const shash::Algorithms interpret_hashes_as, FileChunkList *chunks)
size_t size() const
Definition: file_chunk.h:43
std::map< std::string, BaseMagicXattr * > xattr_list_
Definition: magic_xattr.h:205
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:333
void GetTimeout(unsigned *seconds_proxy, unsigned *seconds_direct)
Definition: download.cc:1914
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:536
virtual bool PrepareValueFenced()
Definition: magic_xattr.h:98
virtual std::string GetValue()
Definition: magic_xattr.cc:297
catalog::Counters counters_
Definition: magic_xattr.h:364
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:507
virtual MagicXattrFlavor GetXattrFlavor()
Definition: magic_xattr.cc:206
static std::string ListProxy(download::DownloadManager *dm)
Definition: magic_xattr.cc:485
std::string pubkeys_
Definition: magic_xattr.h:352
manifest::Manifest * manifest() const
virtual std::string GetValue()
Definition: magic_xattr.cc:630
void Lock(PathString path, catalog::DirectoryEntry *dirent)
Definition: magic_xattr.h:80
std::string GetCsvMap() const
const char * c_str() const
Definition: shortstring.h:145
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:258
void GetHostInfo(std::vector< std::string > *host_chain, std::vector< int > *rtt, unsigned *current_host)
Definition: download.cc:1958
virtual std::string GetValue()
Definition: magic_xattr.cc:512
virtual int64_t Pread(int fd, void *buf, uint64_t size, uint64_t offset)=0
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:293
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:301
void SanityCheckProtectedXattrs()
Definition: magic_xattr.cc:167
shash::Any meta_info() const
Definition: manifest.h:131
virtual bool HasCapability(Capabilities capability)=0
static const uint64_t kSizeUnknown
Definition: cache.h:72
size_t size() const
Definition: bigvector.h:121
download::DownloadManager * external_download_mgr()
Definition: mountpoint.h:499
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:198