1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
module ocda.inventory;
/+ ↓ what a source holds, beyond the one document the model is loaded from.
.
The model is one language of one document. Two questions a reader asks
are about the file instead: which languages it holds, and, for a
database, what else it carries. They are here rather than in a reader
because the answer depends on the input form, which is the library's
to know, and so that a reader asking them does not learn which form it
was handed.
.
languages() answers for every form, and answers the same: the
languages in the order the manifest gave them (which every .ssp
records, in @source languages), each with the markup file it was made
from and the sha256 of its .ssp. The database stores that digest; for a
.ssp and a pod it is taken from the bytes, which are the same bytes.
.
carried() is the database's: a .ocda.db holds the markup, images,
configuration and catalogues it was built from, a .ssp holds none of
them, and a pod's are its archive entries rather than anything the
abstraction says. So it answers for a database and says so otherwise.
+/
import std.algorithm : endsWith, countUntil;
import std.array : array, split;
import std.conv : to;
import std.digest : toHexString, LetterCase;
import std.digest.sha : sha256Of;
import std.file : read;
import std.string : strip;
import ocda.model;
import ocda.load;
import ocda.load_ssp;
import ocda.load_db;
import ocda.load_pod;
import ocda.sqlite;
import ocda.zip;
struct OcdaLanguage {
string lang;
string source_filename; // the markup file the abstraction was made from
string ssp_digest; // sha256 of that language's .ssp, upper case hex
}
struct OcdaCarried {
string role; // source, image, conf, manifest, tools
string compression; // how it is stored: none, zstd
string count;
string bytes; // the files' own size, whatever the storage
string stored; // what they take in the database
}
OcdaLanguage[] languages(string path) {
final switch (sourceOf(path)) {
case Source.ocda_db:
auto db = Db.open(path);
scope(exit) { db.close(); }
OcdaLanguage[] out_;
foreach (l; dbLanguages(db)) {
out_ ~= OcdaLanguage(l.lang, l.source_filename, l.ssp_digest);
}
return out_;
case Source.ssp:
auto bytes = cast(ubyte[]) read(path);
auto doc = parseSsp(cast(string) bytes.idup);
return [ OcdaLanguage(sourceValue(doc, "language"), doc.source_filename, hexOf(bytes)) ];
case Source.pod:
auto archive = archiveBytes(path);
OcdaLanguage[string] found;
string[] order;
foreach (e; zipFindSuffix(zipEntries(archive), ".ssp")) {
auto bytes = zipRead(archive, e);
auto doc = parseSsp(cast(string) bytes.idup);
string lang = langOfSspName(e.name);
found[lang] = OcdaLanguage(lang, doc.source_filename, hexOf(bytes));
if (order.length == 0) {
order = sourceValue(doc, "languages").split;
}
}
/+ ↓ the manifest's order, and anything it did not name after it +/
OcdaLanguage[] out_;
foreach (l; order) { if (auto p = l in found) { out_ ~= *p; } }
foreach (l, v; found) { if (order.countUntil(l) < 0) { out_ ~= v; } }
return out_;
case Source.unknown:
throw new OcdaLoadError(path ~ ": " ~ sourceName(Source.unknown));
}
}
/+ ↓ what a database carries, by role and storage; empty for any other form,
which isCarrier() says in advance +/
bool isCarrier(string path) {
return sourceOf(path) == Source.ocda_db;
}
OcdaCarried[] carried(string path) {
if (!isCarrier(path)) { return []; }
auto db = Db.open(path);
scope(exit) { db.close(); }
if (!db.has("files")) { return []; }
OcdaCarried[] out_;
foreach (r; db.rows(
"SELECT role, compression, count(*), sum(bytes), sum(length(data))
FROM files GROUP BY role, compression ORDER BY role")) {
out_ ~= OcdaCarried(r[0], r[1], r[2], r[3], r[4]);
}
return out_;
}
private string sourceValue(ref OcdaDocument doc, string key) {
if (auto p = key in doc.source) { return *p; }
return "";
}
private string hexOf(const(ubyte)[] bytes) {
return toHexString!(LetterCase.upper)(sha256Of(bytes)).idup;
}
|