1//===- BuiltinCAS.cpp -------------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "BuiltinCAS.h"
10#include "llvm/ADT/StringExtras.h"
11#include "llvm/CAS/BuiltinObjectHasher.h"
12#include "llvm/CAS/UnifiedOnDiskCache.h"
13#include "llvm/Support/Process.h"
14
15using namespace llvm;
16using namespace llvm::cas;
17using namespace llvm::cas::builtin;
18
19static StringRef getCASIDPrefix() { return "llvmcas://"; }
20void BuiltinCASContext::anchor() {}
21
22Expected<HashType> BuiltinCASContext::parseID(StringRef Reference) {
23 if (!Reference.consume_front(Prefix: getCASIDPrefix()))
24 return createStringError(EC: std::make_error_code(e: std::errc::invalid_argument),
25 S: "invalid cas-id '" + Reference + "'");
26
27 // FIXME: Allow shortened references?
28 if (Reference.size() != 2 * sizeof(HashType))
29 return createStringError(EC: std::make_error_code(e: std::errc::invalid_argument),
30 S: "wrong size for cas-id hash '" + Reference + "'");
31
32 std::string Binary;
33 if (!tryGetFromHex(Input: Reference, Output&: Binary))
34 return createStringError(EC: std::make_error_code(e: std::errc::invalid_argument),
35 S: "invalid hash in cas-id '" + Reference + "'");
36
37 assert(Binary.size() == sizeof(HashType));
38 HashType Digest;
39 llvm::copy(Range&: Binary, Out: Digest.data());
40 return Digest;
41}
42
43Expected<CASID> BuiltinCAS::parseID(StringRef Reference) {
44 Expected<HashType> Digest = BuiltinCASContext::parseID(Reference);
45 if (!Digest)
46 return Digest.takeError();
47
48 return CASID::create(Context: &getContext(), Hash: toStringRef(Input: *Digest));
49}
50
51void BuiltinCASContext::printID(ArrayRef<uint8_t> Digest, raw_ostream &OS) {
52 SmallString<64> Hash;
53 toHex(Input: Digest, /*LowerCase=*/true, Output&: Hash);
54 OS << getCASIDPrefix() << Hash;
55}
56
57void BuiltinCASContext::printIDImpl(raw_ostream &OS, const CASID &ID) const {
58 BuiltinCASContext::printID(Digest: ID.getHash(), OS);
59}
60
61const BuiltinCASContext &BuiltinCASContext::getDefaultContext() {
62 static BuiltinCASContext DefaultContext;
63 return DefaultContext;
64}
65
66Expected<ObjectRef> BuiltinCAS::store(ArrayRef<ObjectRef> Refs,
67 ArrayRef<char> Data) {
68 return storeImpl(ComputedHash: BuiltinObjectHasher<HasherT>::hashObject(CAS: *this, Refs, Data),
69 Refs, Data);
70}
71
72Error BuiltinCAS::validateObject(const CASID &ID) {
73 auto Ref = getReference(ID);
74 if (!Ref)
75 return createUnknownObjectError(ID);
76
77 auto Handle = load(Ref: *Ref);
78 if (!Handle)
79 return Handle.takeError();
80
81 auto Proxy = ObjectProxy::load(CAS&: *this, Ref: *Ref, Node: *Handle);
82 SmallVector<ObjectRef> Refs;
83 if (auto E = Proxy.forEachReference(Callback: [&](ObjectRef Ref) -> Error {
84 Refs.push_back(Elt: Ref);
85 return Error::success();
86 }))
87 return E;
88
89 ArrayRef<char> Data(Proxy.getData().data(), Proxy.getData().size());
90 auto Hash = BuiltinObjectHasher<HasherT>::hashObject(CAS: *this, Refs, Data);
91 if (!ID.getHash().equals(RHS: Hash))
92 return createCorruptObjectError(ID);
93
94 return Error::success();
95}
96
97Expected<std::unique_ptr<ondisk::UnifiedOnDiskCache>>
98cas::builtin::createBuiltinUnifiedOnDiskCache(StringRef Path) {
99#if LLVM_ENABLE_ONDISK_CAS
100 return ondisk::UnifiedOnDiskCache::open(Path, /*SizeLimit=*/std::nullopt,
101 HashName: BuiltinCASContext::getHashName(),
102 HashByteSize: sizeof(HashType));
103#else
104 return createStringError(inconvertibleErrorCode(), "OnDiskCache is disabled");
105#endif
106}
107
108void cas::builtin::hashingFunc(ArrayRef<ArrayRef<uint8_t>> Refs,
109 ArrayRef<char> Data,
110 SmallVectorImpl<uint8_t> &Result) {
111 auto Hash =
112 BuiltinObjectHasher<llvm::cas::builtin::HasherT>::hashObject(Refs, Data);
113 Result.assign(in_start: Hash.begin(), in_end: Hash.end());
114}
115