CernVM-FS  2.12.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 
198 std::string BaseMagicXattr::HeaderMultipageHuman(uint32_t requested_page) {
199  return "# Access page at idx: " + StringifyUint(requested_page) + ". " +
200  "Total num pages: " + StringifyUint(result_pages_.size()) +
201  " (access other pages: xattr~<page_num>, starting " +
202  " with 0; number of pages available: xattr~?)\n";
203 }
204 
205 std::pair<bool, std::string> BaseMagicXattr::GetValue(int32_t requested_page,
206  const MagicXattrMode mode) {
207  assert(requested_page >= -1);
208  result_pages_.clear();
209  FinalizeValue();
210 
211  std::string res = "";
212  if (mode == kXattrMachineMode) {
213  if (requested_page >= static_cast<int32_t>(result_pages_.size())) {
214  return std::pair<bool, std::string> (false, "");
215  }
216  if (requested_page == -1) {
217  return std::pair<bool, std::string> (true,
218  "num_pages, " + StringifyUint(result_pages_.size()));
219  }
220  } else if (mode == kXattrHumanMode) {
221  if (requested_page >= static_cast<int32_t>(result_pages_.size())) {
222  return std::pair<bool, std::string> (true,
223  "Page requested does not exists. There are "
224  + StringifyUint(result_pages_.size()) + " pages available.\n"
225  + "Access them with xattr~<page_num> (machine-readable mode) "
226  + "or xattr@<page_num> (human-readable mode).\n"
227  + "Use xattr@? or xattr~? to get extra info about the attribute");
228  } else if (requested_page == -1) {
229  return std::pair<bool, std::string> (true,
230  "Access xattr with xattr~<page_num> (machine-readable mode) or "
231  + std::string(" xattr@<page_num> (human-readable mode).\n")
232  + "Pages available: " + StringifyUint(result_pages_.size()));
233  } else {
234  res = HeaderMultipageHuman(requested_page);
235  }
236  } else {
238  "Unknown mode of magic xattr requested: %d", mode);
239  }
240 
241  res += result_pages_[requested_page];
242 
243  return std::pair<bool, std::string> (true, res);
244 }
245 
248 }
249 
252 }
253 
255  return kXattrAuthz;
256 }
257 
259  counters_ =
261  LookupCounters(path_, &subcatalog_path_, &hash_);
262  return true;
263 }
264 
266  std::string res;
267  res = "catalog_hash: " + hash_.ToString() + "\n";
268  res += "catalog_mountpoint: " + subcatalog_path_ + "\n";
269  res += counters_.GetCsvMap();
270 
271  result_pages_.push_back(res);
272 }
273 
275  chunk_list_.clear();
276 
277  const std::string header = "hash,offset,size\n";
278  std::string chunk_list_page_(header);
279  if (!dirent_->IsRegular()) {
280  chunk_list_.push_back(chunk_list_page_);
281  return false;
282  }
283  if (dirent_->IsChunkedFile()) {
284  FileChunkList chunks;
287  || chunks.IsEmpty())
288  {
289  LogCvmfs(kLogCvmfs, kLogDebug | kLogSyslogErr, "file %s is marked as "
290  "'chunked', but no chunks found.", path_.c_str());
291  return false;
292  } else {
293  for (size_t i = 0; i < chunks.size(); ++i) {
294  chunk_list_page_ += chunks.At(i).content_hash().ToString() + ",";
295  chunk_list_page_ += StringifyInt(chunks.At(i).offset()) + ",";
296  chunk_list_page_ += StringifyUint(chunks.At(i).size()) + "\n";
297 
298  if (chunk_list_page_.size() > kMaxCharsPerPage) {
299  chunk_list_.push_back(chunk_list_page_);
300  chunk_list_page_ = header;
301  }
302  }
303  }
304  } else {
305  chunk_list_page_ += dirent_->checksum().ToString() + ",";
306  chunk_list_page_ += "0,";
307  chunk_list_page_ += StringifyUint(dirent_->size()) + "\n";
308  }
309 
310  // add the last page
311  if (chunk_list_page_.size() > header.size()) {
312  chunk_list_.push_back(chunk_list_page_);
313  }
314 
315  return true;
316 }
317 
320 }
321 
323  if (!dirent_->IsRegular()) {
324  return false;
325  }
326  if (dirent_->IsChunkedFile()) {
327  FileChunkList chunks;
330  || chunks.IsEmpty())
331  {
332  LogCvmfs(kLogCvmfs, kLogDebug | kLogSyslogErr, "file %s is marked as "
333  "'chunked', but no chunks found.", path_.c_str());
334  return false;
335  } else {
336  n_chunks_ = chunks.size();
337  }
338  } else {
339  n_chunks_ = 1;
340  }
341 
342  return true;
343 }
344 
347 }
348 
350  return dirent_->IsRegular();
351 }
352 
356 }
357 
359  return dirent_->IsRegular();
360 }
361 
363  result_pages_.push_back(dirent_->IsDirectIo() ? "1" : "0");
364 }
365 
367  return dirent_->IsRegular();
368 }
369 
371  result_pages_.push_back(dirent_->IsExternalFile() ? "1" : "0");
372 }
373 
375  std::vector<string> host_chain;
376  std::vector<int> rtt;
377  unsigned current_host;
379  &host_chain, &rtt, &current_host);
380  if (host_chain.size()) {
381  result_pages_.push_back(std::string(host_chain[current_host]));
382  } else {
383  result_pages_.push_back("internal error: no hosts defined");
384  }
385 }
386 
388  unsigned seconds, seconds_direct;
390  GetTimeout(&seconds, &seconds_direct);
391  result_pages_.push_back(StringifyUint(seconds_direct));
392 }
393 
395  result_pages_.push_back(xattr_mgr_->mount_point()->fqrn());
396 }
397 
399  return !dirent_->checksum().IsNull();
400 }
401 
403  result_pages_.push_back(dirent_->checksum().ToString());
404 }
405 
407  std::vector<std::string> host_chain;
408  std::vector<int> rtt;
409  unsigned current_host;
411  GetHostInfo(&host_chain, &rtt, &current_host);
412  if (host_chain.size()) {
413  result_pages_.push_back(std::string(host_chain[current_host]));
414  } else {
415  result_pages_.push_back("internal error: no hosts defined");
416  }
417 }
418 
420  std::string result;
421  std::vector<std::string> host_chain;
422  std::vector<int> rtt;
423  unsigned current_host;
425  GetHostInfo(&host_chain, &rtt, &current_host);
426  if (host_chain.size()) {
427  result = host_chain[current_host];
428  for (unsigned i = 1; i < host_chain.size(); ++i) {
429  result +=
430  ";" + host_chain[(i+current_host) % host_chain.size()];
431  }
432  } else {
433  result = "internal error: no hosts defined";
434  }
435  result_pages_.push_back(result);
436 }
437 
439  return !dirent_->checksum().IsNull();
440 }
441 
443  string result;
444  CacheManager::Label label;
445  label.path = path_.ToString();
448  int fd = xattr_mgr_->mount_point()->file_system()->cache_mgr()->Open(
450  if (fd < 0) {
451  result = "Not in cache";
452  } else {
454  int retval_i =
456  ->ChecksumFd(fd, &hash);
457  if (retval_i != 0)
458  result = "I/O error (" + StringifyInt(retval_i) + ")";
459  else
460  result = hash.ToString();
462  }
463  result_pages_.push_back(result);
464 }
465 
466 LogBufferXattr::LogBufferXattr() : BaseMagicXattr(), throttle_(1, 500, 2000) { }
467 
470  std::vector<LogBufferEntry> buffer = GetLogBuffer();
471  std::string result;
472  for (std::vector<LogBufferEntry>::reverse_iterator itr = buffer.rbegin();
473  itr != buffer.rend(); ++itr)
474  {
475  if (itr->message.size() > kMaxLogLine) {
476  itr->message.resize(kMaxLogLine);
477  itr->message += " <snip>";
478  }
479  result += "[" + StringifyTime(itr->timestamp, true /* UTC */) + " UTC] " +
480  itr->message + "\n";
481  }
482  result_pages_.push_back(result);
483 }
484 
486  QuotaManager *quota_mgr =
489  result_pages_.push_back(StringifyInt(-1));
490  } else {
491  const uint64_t period_s = 24 * 60 * 60;
492  const uint64_t rate = quota_mgr->GetCleanupRate(period_s);
493  result_pages_.push_back(StringifyUint(rate));
494  }
495 }
496 
499  return true;
500 }
501 
504 }
505 
507  result_pages_.push_back(xattr_mgr_->mount_point()->
508  file_system()->n_fs_dir_open()->ToString());
509 }
510 
513  ->Lookup("fetch.n_downloads")->Print());
514 }
515 
518  ->io_error_info()->count()));
519 }
520 
523  ->ToString());
524 }
525 
527  int64_t n_invocations =
528  xattr_mgr_->mount_point()->statistics()->Lookup("fetch.n_invocations")
529  ->Get();
530  if (n_invocations == 0) {
531  result_pages_.push_back("n/a");
532  return;
533  }
534 
535  int64_t n_downloads =
536  xattr_mgr_->mount_point()->statistics()->Lookup("fetch.n_downloads")->Get();
537  float hitrate = 100. * (1. -
538  (static_cast<float>(n_downloads) / static_cast<float>(n_invocations)));
539  result_pages_.push_back(StringifyDouble(hitrate));
540 }
541 
543  vector< vector<download::DownloadManager::ProxyInfo> > proxy_chain;
544  unsigned current_group;
546  &proxy_chain, &current_group, NULL);
547  if (proxy_chain.size()) {
548  result_pages_.push_back(proxy_chain[current_group][0].url);
549  } else {
550  result_pages_.push_back("DIRECT");
551  }
552 }
553 
555  std::vector<std::string> *result_pages) {
556  vector< vector<download::DownloadManager::ProxyInfo> > proxy_chain;
557  unsigned current_group;
558  dm->GetProxyInfo(&proxy_chain, &current_group, NULL);
559  std::string buf = "";
560  for (unsigned int i = 0; i < proxy_chain.size(); i++) {
561  for (unsigned int j = 0; j < proxy_chain[i].size(); j++) {
562  buf += proxy_chain[i][j].url;
563  buf += "\n";
564  }
565 
566  if (buf.size() > BaseMagicXattr::kMaxCharsPerPage) {
567  result_pages->push_back(buf);
568  buf = "";
569  }
570  }
571 
572  if (buf.size() > 0 || result_pages->size() == 0) {
573  result_pages->push_back(buf);
574  }
575 }
576 
579 }
580 
583 }
584 
588  return true;
589 }
590 
592  size_t full_size = 0;
593 
594  for (size_t i = 0; i < pubkeys_.size(); i++) {
595  full_size += pubkeys_[i].size();
596  }
597 
598  if (full_size == 0) {
599  return;
600  }
601 
602  size_t size_within_page = 0;
603  std::string res = "";
604 
605  for (size_t i = 0; i < pubkeys_.size(); i++) {
606  if (size_within_page + pubkeys_[i].size() >= kMaxCharsPerPage) {
607  result_pages_.push_back(res);
608  res = "";
609  size_within_page = 0;
610  }
611 
612  res += pubkeys_[i];
613  size_within_page += pubkeys_[i].size();
614  }
615  if (res.size() > 0) {
616  result_pages_.push_back(res);
617  }
618 }
619 
621  return dirent_->IsLink();
622 }
623 
625  result_pages_.push_back(dirent_->symlink().ToString());
626 }
627 
630  ->GetCounters();
631  return true;
632 }
633 
635  result_pages_.push_back(counters_.GetCsvMap());
636 }
637 
639 
641  if (!xattr_mgr_->mount_point()->catalog_mgr()->manifest()) {
642  error_reason_ = "manifest not available";
643  return true;
644  }
645 
647  ->meta_info();
648  if (metainfo_hash_.IsNull()) {
649  error_reason_ = "metainfo not available";
650  return true;
651  }
652  return true;
653 }
654 
656  if (metainfo_hash_.IsNull()) {
657  result_pages_.push_back(error_reason_);
658  return;
659  }
660 
661  CacheManager::Label label;
662  label.path = xattr_mgr_->mount_point()->fqrn() +
663  "(" + metainfo_hash_.ToString() + ")";
665  int fd = xattr_mgr_->mount_point()->fetcher()->Fetch(
667  if (fd < 0) {
668  result_pages_.push_back("Failed to open metadata file");
669  return;
670  }
671  uint64_t actual_size = xattr_mgr_->mount_point()->file_system()->cache_mgr()
672  ->GetSize(fd);
673  if (actual_size > kMaxMetainfoLength) {
675  result_pages_.push_back("Failed to open: metadata file is too big");
676  return;
677  }
678  char buffer[kMaxMetainfoLength];
679  int64_t bytes_read =
681  ->Pread(fd, buffer, actual_size, 0);
683  if (bytes_read < 0) {
684  result_pages_.push_back("Failed to read metadata file");
685  return;
686  }
687  result_pages_.push_back(string(buffer, buffer + bytes_read));
688 }
689 
692  return true;
693 }
694 
697 }
698 
701  return true;
702 }
703 
705  result_pages_.push_back(root_hash_.ToString());
706 }
707 
710  int64_t rx = statistics->Lookup("download.sz_transferred_bytes")->Get();
711  result_pages_.push_back(StringifyInt(rx/1024));
712 }
713 
716  int64_t rx = statistics->Lookup("download.sz_transferred_bytes")->Get();
717  int64_t time = statistics->Lookup("download.sz_transfer_time")->Get();
718  if (time == 0) {
719  result_pages_.push_back("n/a");
720  } else {
721  result_pages_.push_back(StringifyInt((1000 * (rx/1024))/time));
722  }
723 }
724 
727  return true;
728 }
729 
731  result_pages_.push_back(tag_);
732 }
733 
735  unsigned seconds, seconds_direct;
737  ->GetTimeout(&seconds, &seconds_direct);
738  result_pages_.push_back(StringifyUint(seconds));
739 }
740 
742  unsigned seconds, seconds_direct;
744  ->GetTimeout(&seconds, &seconds_direct);
745  result_pages_.push_back(StringifyUint(seconds_direct));
746 }
747 
750  file_system()->io_error_info()->timestamp_last()));
751 }
752 
755  no_open_files()->ToString());
756 }
757 
760  no_open_dirs()->ToString());
761 }
762 
764  result_pages_.push_back(std::string(VERSION) + "."
765  + std::string(CVMFS_PATCH_LEVEL));
766 }
767 
769  std::vector<std::string> host_chain;
770  std::vector<int> rtt;
771  unsigned current_host;
772  if (xattr_mgr_->mount_point()->external_download_mgr() != NULL) {
774  &host_chain, &rtt, &current_host);
775  if (host_chain.size()) {
776  result_pages_.push_back(std::string(host_chain[current_host])
777  + std::string(path_.c_str()));
778  return;
779  }
780  }
781  result_pages_.push_back("");
782 }
783 
785  return dirent_->IsRegular() && dirent_->IsExternalFile();
786 }
std::vector< LogBufferEntry > GetLogBuffer()
Definition: logging.cc:535
std::string ToString()
Definition: statistics.cc:24
const std::set< gid_t > privileged_xattr_gids_
Definition: magic_xattr.h:262
int ChecksumFd(int fd, shash::Any *id)
Definition: cache.cc:39
bool IsExternalFile() const
const Counters & GetCounters() const
Definition: catalog.h:175
virtual void FinalizeValue()
Definition: magic_xattr.cc:406
bool IsNull() const
Definition: hash.h:383
virtual int64_t GetSize(int fd)=0
FileSystem * file_system()
Definition: mountpoint.h:515
MagicXattrFlavor
Definition: magic_xattr.h:23
Item At(const size_t index) const
Definition: bigvector.h:50
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:274
static void ListProxy(download::DownloadManager *dm, std::vector< std::string > *result_pages)
Definition: magic_xattr.cc:554
bool PrepareValueFencedProtected(gid_t gid)
Definition: magic_xattr.cc:158
virtual void FinalizeValue()
Definition: magic_xattr.cc:581
virtual void FinalizeValue()
Definition: magic_xattr.cc:708
cvmfs::Fetcher * fetcher()
Definition: mountpoint.h:510
std::string subcatalog_path_
Definition: magic_xattr.h:278
virtual void FinalizeValue()
Definition: magic_xattr.cc:734
virtual uint64_t GetCleanupRate(uint64_t period_s)=0
bool IsChunkedFile() const
virtual void FinalizeValue()
Definition: magic_xattr.cc:374
perf::Statistics * statistics()
Definition: mountpoint.h:534
void Register(const std::string &name, BaseMagicXattr *magic_xattr)
Definition: magic_xattr.cc:135
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:699
static const int kLabelMetainfo
Definition: cache.h:86
std::string Print()
Definition: statistics.cc:25
MountPoint * mount_point()
Definition: magic_xattr.h:251
virtual void FinalizeValue()
Definition: magic_xattr.cc:695
#define PANIC(...)
Definition: exception.h:29
virtual void FinalizeValue()
Definition: magic_xattr.cc:763
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 void FinalizeValue()
Definition: magic_xattr.cc:353
std::string fqrn() const
Definition: mountpoint.h:512
virtual void FinalizeValue()
Definition: magic_xattr.cc:768
catalog::Counters counters_
Definition: magic_xattr.h:280
void MarkProtected()
Definition: magic_xattr.h:82
BaseMagicXattr * GetLocked(const std::string &name, PathString path, catalog::DirectoryEntry *d)
Definition: magic_xattr.cc:119
virtual void FinalizeValue()
Definition: magic_xattr.cc:250
const std::set< std::string > protected_xattrs_
Definition: magic_xattr.h:261
virtual void FinalizeValue()
Definition: magic_xattr.cc:542
std::string error_reason_
Definition: magic_xattr.h:429
virtual void FinalizeValue()
Definition: magic_xattr.cc:394
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:784
const shash::Any & content_hash() const
Definition: file_chunk.h:41
shash::Any root_hash_
Definition: magic_xattr.h:443
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:725
virtual void FinalizeValue()
Definition: magic_xattr.cc:730
std::string AlgorithmName(const zlib::Algorithms alg)
Definition: compression.cc:158
assert((mem||(size==0))&&"Out Of Memory")
MountPoint * mount_point_
Definition: cvmfs.cc:128
virtual void FinalizeValue()
Definition: magic_xattr.cc:577
bool IsDirectIo() const
catalog::DirectoryEntry * dirent_
Definition: magic_xattr.h:151
std::vector< std::string > chunk_list_
Definition: magic_xattr.h:291
Algorithms algorithm
Definition: hash.h:125
string StringifyTime(const time_t seconds, const bool utc)
Definition: string.cc:105
string StringifyDouble(const double value)
Definition: string.cc:96
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:349
std::string StringifyUint(const uint64_t value)
Definition: string.cc:84
shash::Any checksum() const
bool IsPrivilegedGid(gid_t gid)
Definition: magic_xattr.cc:154
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:258
bool has_membership_req()
Definition: mountpoint.h:517
virtual void FinalizeValue()
Definition: magic_xattr.cc:741
static uint64_t kMaxMetainfoLength
Definition: magic_xattr.h:426
MagicXattrMode
Definition: magic_xattr.h:32
MountPoint * mount_point_
Definition: magic_xattr.h:256
virtual int Open(const LabeledObject &object)=0
perf::Counter * n_fs_open()
Definition: mountpoint.h:226
std::string membership_req()
Definition: mountpoint.h:528
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:497
void Throttle()
Definition: backoff.cc:50
MagicXattrManager * xattr_mgr_
Definition: magic_xattr.h:149
std::string GetListString(catalog::DirectoryEntry *dirent)
Definition: magic_xattr.cc:77
static const uint32_t kMaxCharsPerPage
Definition: magic_xattr.h:137
std::vector< std::string > GetActivePubkeysAsVector() const
Definition: signature.cc:397
Counter * Lookup(const std::string &name) const
Definition: statistics.cc:62
NameString name() const
bool IsLink() const
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:690
virtual void FinalizeValue()
Definition: magic_xattr.cc:387
void GetProxyInfo(std::vector< std::vector< ProxyInfo > > *proxy_chain, unsigned *current_group, unsigned *fallback_group)
Definition: download.cc:2710
virtual void FinalizeValue()
Definition: magic_xattr.cc:591
virtual void FinalizeValue()
Definition: magic_xattr.cc:362
std::string repository_tag()
Definition: mountpoint.h:532
catalog::ClientCatalogManager * catalog_mgr()
Definition: mountpoint.h:501
std::string HeaderMultipageHuman(uint32_t requested_page)
Definition: magic_xattr.cc:198
bool is_frozen() const
Definition: magic_xattr.h:252
bool IsRegular() const
virtual void FinalizeValue()
Definition: magic_xattr.cc:442
virtual void FinalizeValue()
Definition: magic_xattr.cc:655
virtual void FinalizeValue()
Definition: magic_xattr.cc:511
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:628
int Fetch(const CacheManager::LabeledObject &object, const std::string &alt_url="")
Definition: fetch.cc:81
EVisibility visibility()
Definition: magic_xattr.h:248
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:438
off_t offset() const
Definition: file_chunk.h:42
virtual void FinalizeValue()
Definition: magic_xattr.cc:468
virtual void FinalizeValue()
Definition: magic_xattr.cc:758
zlib::Algorithms compression_algorithm() const
CacheManager * cache_mgr()
Definition: mountpoint.h:205
virtual void FinalizeValue()
Definition: magic_xattr.cc:318
virtual void FinalizeValue()
Definition: magic_xattr.cc:704
virtual void FinalizeValue()
Definition: magic_xattr.cc:753
std::pair< bool, std::string > GetValue(int32_t requested_page, const MagicXattrMode mode)
Definition: magic_xattr.cc:205
LinkString symlink() const
virtual void FinalizeValue()
Definition: magic_xattr.cc:526
IoErrorInfo * io_error_info()
Definition: mountpoint.h:233
const unsigned int kMaxLogLine
Definition: magic_xattr.h:351
download::DownloadManager * download_mgr()
Definition: mountpoint.h:503
virtual void FinalizeValue()
Definition: magic_xattr.cc:634
virtual void FinalizeValue()
Definition: magic_xattr.cc:485
virtual void FinalizeValue()
Definition: magic_xattr.cc:714
virtual void FinalizeValue()
Definition: magic_xattr.cc:265
string StringifyInt(const int64_t value)
Definition: string.cc:78
virtual void FinalizeValue()
Definition: magic_xattr.cc:506
virtual int Close(int fd)=0
virtual void FinalizeValue()
Definition: magic_xattr.cc:521
shash::Algorithms hash_algorithm() const
virtual void FinalizeValue()
Definition: magic_xattr.cc:370
virtual void FinalizeValue()
Definition: magic_xattr.cc:419
int64_t Get()
Definition: statistics.h:32
static const int kLabelVolatile
Definition: cache.h:82
CatalogT * GetRootCatalog() const
Definition: catalog_mgr.h:312
std::string tag_
Definition: magic_xattr.h:458
bool IsEmpty() const
Definition: bigvector.h:72
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
virtual void FinalizeValue()
Definition: magic_xattr.cc:345
shash::Any metainfo_hash_
Definition: magic_xattr.h:428
signature::SignatureManager * signature_mgr()
Definition: mountpoint.h:536
BackoffThrottle throttle_
Definition: magic_xattr.h:355
uint64_t n_chunks_
Definition: magic_xattr.h:295
std::string ToString() const
Definition: shortstring.h:141
QuotaManager * quota_mgr()
Definition: cache.h:193
bool IsEmpty() const
Definition: shortstring.h:137
std::vector< std::string > pubkeys_
Definition: magic_xattr.h:407
PathString path_
Definition: magic_xattr.h:150
bool ListFileChunks(const PathString &path, const shash::Algorithms interpret_hashes_as, FileChunkList *chunks)
virtual void FinalizeValue()
Definition: magic_xattr.h:145
size_t size() const
Definition: file_chunk.h:43
std::map< std::string, BaseMagicXattr * > xattr_list_
Definition: magic_xattr.h:255
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:398
void GetTimeout(unsigned *seconds_proxy, unsigned *seconds_direct)
Definition: download.cc:2038
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:640
virtual void FinalizeValue()
Definition: magic_xattr.cc:402
virtual bool PrepareValueFenced()
Definition: magic_xattr.h:144
catalog::Counters counters_
Definition: magic_xattr.h:419
virtual void FinalizeValue()
Definition: magic_xattr.cc:502
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:585
std::string path
Definition: cache.h:133
virtual MagicXattrFlavor GetXattrFlavor()
Definition: magic_xattr.cc:254
manifest::Manifest * manifest() const
void Lock(PathString path, catalog::DirectoryEntry *dirent)
Definition: magic_xattr.h:123
std::string GetCsvMap() const
const char * c_str() const
Definition: shortstring.h:145
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:322
void GetHostInfo(std::vector< std::string > *host_chain, std::vector< int > *rtt, unsigned *current_host)
Definition: download.cc:2082
static void size_t size
Definition: smalloc.h:54
virtual void FinalizeValue()
Definition: magic_xattr.cc:516
virtual int64_t Pread(int fd, void *buf, uint64_t size, uint64_t offset)=0
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:358
std::vector< std::string > result_pages_
Definition: magic_xattr.h:155
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:366
void SanityCheckProtectedXattrs()
Definition: magic_xattr.cc:167
shash::Any meta_info() const
Definition: manifest.h:139
virtual bool HasCapability(Capabilities capability)=0
size_t size() const
Definition: bigvector.h:121
download::DownloadManager * external_download_mgr()
Definition: mountpoint.h:504
virtual bool PrepareValueFenced()
Definition: magic_xattr.cc:246
CVMFS_EXPORT void LogCvmfs(const LogSource source, const int mask, const char *format,...)
Definition: logging.cc:528