%PDF-
%PDF-
Mini Shell
Mini Shell
"use strict";
var bodec = require('bodec');
var inflate = require('../lib/inflate');
var deflate = require('../lib/deflate');
var codec = require('../lib/object-codec');
var parsePackEntry = require('../lib/pack-codec').parseEntry;
var applyDelta = require('../lib/apply-delta');
var sha1 = require('git-sha1');
var pathJoin = require('path').join;
// The fs object has the following interface:
// - readFile(path) => binary
// Must also call callback() with no arguments if the file does not exist.
// - readChunk(path, start, end) => binary
// Must also call callback() with no arguments if the file does not exist.
// - writeFile(path, binary) =>
// Must also make every directory up to parent of path.
// - readDir(path) => array<paths>
// Must also call callback() with no arguments if the file does not exist.
// The repo is expected to have a rootPath property that points to
// the .git folder within the filesystem.
module.exports = function (repo, fs) {
var cachedIndexes = {};
repo.loadAs = loadAs;
repo.saveAs = saveAs;
repo.loadRaw = loadRaw;
repo.saveRaw = saveRaw;
repo.readRef = readRef;
repo.updateRef = updateRef;
repo.hasHash = hasHash;
repo.init = init;
repo.setShallow = setShallow;
function init(ref, callback) {
if (!callback) return init.bind(null, ref);
ref = ref || "refs/heads/master";
var path = pathJoin(repo.rootPath, "HEAD");
fs.writeFile(path, "ref: " + ref, callback);
}
function setShallow(ref, callback) {
if (!callback) return setShallow.bind(null, ref);
var path = pathJoin(repo.rootPath, "shallow");
fs.writeFile(path, ref, callback);
}
function updateRef(ref, hash, callback) {
if (!callback) return updateRef.bind(repo, ref, hash);
var path = pathJoin(repo.rootPath, ref);
var lock = path + ".lock";
fs.writeFile(lock, bodec.fromRaw(hash + "\n"), function(err) {
if(err) return callback(err);
fs.rename(lock, path, callback);
});
}
function readRef(ref, callback) {
if (!callback) return readRef.bind(repo, ref);
var path = pathJoin(repo.rootPath, ref);
fs.readFile(path, function (err, binary) {
if (err) return callback(err);
if (binary === undefined) {
return readPackedRef(ref, callback);
}
var hash;
try { hash = bodec.toRaw(binary).trim(); }
catch (err) { return callback(err); }
callback(null, hash);
});
}
function readPackedRef(ref, callback) {
var path = pathJoin(repo.rootPath, "packed-refs");
fs.readFile(path, function (err, binary) {
if (binary === undefined) return callback(err);
var hash;
try {
var text = bodec.toRaw(binary);
var index = text.indexOf(ref);
if (index >= 0) {
hash = text.substring(index - 41, index - 1);
}
}
catch (err) {
return callback(err);
}
callback(null, hash);
});
}
function saveAs(type, body, callback) {
if (!callback) return saveAs.bind(repo, type, body);
var raw, hash;
try {
raw = codec.frame({
type: type,
body: codec.encoders[type](body)
});
hash = sha1(raw);
}
catch (err) { return callback(err); }
saveRaw(hash, raw, function (err) {
if (err) return callback(err);
callback(null, hash);
});
}
function saveRaw(hash, raw, callback) {
if (!callback) return saveRaw.bind(repo, hash, raw);
var buffer, path;
try {
if (sha1(raw) !== hash) {
throw new Error("Save data does not match hash");
}
buffer = deflate(raw);
path = hashToPath(hash);
}
catch (err) { return callback(err); }
// Try to read the object first.
loadRaw(hash, function (err, data) {
// If it already exists, we're done
if (data) return callback();
// Otherwise write a new file
var tmp = path.replace(/[0-9a-f]+$/, 'tmp_obj_' + Math.random().toString(36).substr(2))
fs.writeFile(tmp, buffer, function(err) {
if(err) return callback(err);
fs.rename(tmp, path, callback);
});
});
}
function loadAs(type, hash, callback) {
if (!callback) return loadAs.bind(repo, type, hash);
loadRaw(hash, function (err, raw) {
if (raw === undefined) return callback(err);
var body;
try {
raw = codec.deframe(raw);
if (raw.type !== type) throw new TypeError("Type mismatch");
body = codec.decoders[raw.type](raw.body);
}
catch (err) { return callback(err); }
callback(null, body);
});
}
function hasHash(hash, callback) {
if (!callback) return hasHash.bind(repo, hash);
loadRaw(hash, function (err, body) {
if (err) return callback(err);
return callback(null, !!body);
});
}
function loadRaw(hash, callback) {
if (!callback) return loadRaw.bind(repo, hash);
var path = hashToPath(hash);
fs.readFile(path, function (err, buffer) {
if (err) return callback(err);
if (buffer) {
var raw;
try { raw = inflate(buffer); }
catch (err) { return callback(err); }
return callback(null, raw);
}
return loadRawPacked(hash, callback);
});
}
function loadRawPacked(hash, callback) {
var packDir = pathJoin(repo.rootPath, "objects/pack");
var packHashes = [];
fs.readDir(packDir, function (err, entries) {
if (!entries) return callback(err);
entries.forEach(function (name) {
var match = name.match(/pack-([0-9a-f]{40}).idx/);
if (match) packHashes.push(match[1]);
});
start();
});
function start() {
var packHash = packHashes.pop();
var offsets;
if (!packHash) return callback();
if (!cachedIndexes[packHash]) loadIndex(packHash);
else onIndex();
function loadIndex() {
var indexFile = pathJoin(packDir, "pack-" + packHash + ".idx" );
fs.readFile(indexFile, function (err, buffer) {
if (!buffer) return callback(err);
try {
cachedIndexes[packHash] = parseIndex(buffer);
}
catch (err) { return callback(err); }
onIndex();
});
}
function onIndex() {
var cached = cachedIndexes[packHash];
var packFile = pathJoin(packDir, "pack-" + packHash + ".pack" );
var index = cached.byHash[hash];
if (!index) return start();
offsets = cached.offsets;
loadChunk(packFile, index.offset, callback);
}
function loadChunk(packFile, start, callback) {
var index = offsets.indexOf(start);
if (index < 0) {
var error = new Error("Can't find chunk starting at " + start);
return callback(error);
}
var end = index + 1 < offsets.length ? offsets[index + 1] : -20;
fs.readChunk(packFile, start, end, function (err, chunk) {
if (!chunk) return callback(err);
var raw;
try {
var entry = parsePackEntry(chunk);
if (entry.type === "ref-delta") {
return loadRaw.call(repo, entry.ref, onBase);
}
else if (entry.type === "ofs-delta") {
return loadChunk(packFile, start - entry.ref, onBase);
}
raw = codec.frame(entry);
}
catch (err) { return callback(err); }
callback(null, raw);
function onBase(err, base) {
if (!base) return callback(err);
var object = codec.deframe(base);
var buffer;
try {
object.body = applyDelta(entry.body, object.body);
buffer = codec.frame(object);
}
catch (err) { return callback(err); }
callback(null, buffer);
}
});
}
}
}
function hashToPath(hash) {
return pathJoin(repo.rootPath, "objects", hash.substring(0, 2), hash.substring(2));
}
};
function parseIndex(buffer) {
if (readUint32(buffer, 0) !== 0xff744f63 ||
readUint32(buffer, 4) !== 0x00000002) {
throw new Error("Only v2 pack indexes supported");
}
// Get the number of hashes in index
// This is the value of the last fan-out entry
var hashOffset = 8 + 255 * 4;
var length = readUint32(buffer, hashOffset);
hashOffset += 4;
var crcOffset = hashOffset + 20 * length;
var lengthOffset = crcOffset + 4 * length;
var largeOffset = lengthOffset + 4 * length;
var checkOffset = largeOffset;
var indexes = new Array(length);
for (var i = 0; i < length; i++) {
var start = hashOffset + i * 20;
var hash = bodec.toHex(bodec.slice(buffer, start, start + 20));
var crc = readUint32(buffer, crcOffset + i * 4);
var offset = readUint32(buffer, lengthOffset + i * 4);
if (offset & 0x80000000) {
offset = largeOffset + (offset &0x7fffffff) * 8;
checkOffset = Math.max(checkOffset, offset + 8);
offset = readUint64(buffer, offset);
}
indexes[i] = {
hash: hash,
offset: offset,
crc: crc
};
}
var packChecksum = bodec.toHex(bodec.slice(buffer, checkOffset, checkOffset + 20));
var checksum = bodec.toHex(bodec.slice(buffer, checkOffset + 20, checkOffset + 40));
if (sha1(bodec.slice(buffer, 0, checkOffset + 20)) !== checksum) {
throw new Error("Checksum mistmatch");
}
var byHash = {};
indexes.sort(function (a, b) {
return a.offset - b.offset;
});
indexes.forEach(function (data) {
byHash[data.hash] = {
offset: data.offset,
crc: data.crc,
};
});
var offsets = indexes.map(function (entry) {
return entry.offset;
}).sort(function (a, b) {
return a - b;
});
return {
offsets: offsets,
byHash: byHash,
checksum: packChecksum
};
}
function readUint32(buffer, offset) {
return (buffer[offset] << 24 |
buffer[offset + 1] << 16 |
buffer[offset + 2] << 8 |
buffer[offset + 3] << 0) >>> 0;
}
// Yes this will lose precision over 2^53, but that can't be helped when
// returning a single integer.
// We simply won't support packfiles over 8 petabytes. I'm ok with that.
function readUint64(buffer, offset) {
var hi = (buffer[offset] << 24 |
buffer[offset + 1] << 16 |
buffer[offset + 2] << 8 |
buffer[offset + 3] << 0) >>> 0;
var lo = (buffer[offset + 4] << 24 |
buffer[offset + 5] << 16 |
buffer[offset + 6] << 8 |
buffer[offset + 7] << 0) >>> 0;
return hi * 0x100000000 + lo;
}
Zerion Mini Shell 1.0