##// END OF EJS Templates
lfs: only hardlink between the usercache and local store if the blob verifies...
lfs: only hardlink between the usercache and local store if the blob verifies This fixes the issue where verify (and other read commands) would propagate corrupt blobs. I originalled coded this to only hardlink if 'verify=True' for store.read(), but then good blobs weren't being linked, and this broke a bunch of tests. (The blob in repo5 that is being corrupted seems to be linked into repo5 in the loop running dumpflog.py prior to it being corrupted, but only if verify=False is handled too.) It's probably better to do a one time extra verification in order to create these files, so that the repo can be copied to a removable drive. Adding the same check to store.write() was only for completeness, but also needs to do a one time extra verification to avoid breaking tests.

File last commit:

r31796:e0dc4053 default
r35493:bb6a80fc @10 default
Show More
compressionparams.c
253 lines | 7.8 KiB | text/x-c | CLexer
/**
* Copyright (c) 2016-present, Gregory Szorc
* All rights reserved.
*
* This software may be modified and distributed under the terms
* of the BSD license. See the LICENSE file for details.
*/
#include "python-zstandard.h"
void ztopy_compression_parameters(CompressionParametersObject* params, ZSTD_compressionParameters* zparams) {
zparams->windowLog = params->windowLog;
zparams->chainLog = params->chainLog;
zparams->hashLog = params->hashLog;
zparams->searchLog = params->searchLog;
zparams->searchLength = params->searchLength;
zparams->targetLength = params->targetLength;
zparams->strategy = params->strategy;
}
CompressionParametersObject* get_compression_parameters(PyObject* self, PyObject* args) {
int compressionLevel;
unsigned PY_LONG_LONG sourceSize = 0;
Py_ssize_t dictSize = 0;
ZSTD_compressionParameters params;
CompressionParametersObject* result;
if (!PyArg_ParseTuple(args, "i|Kn:get_compression_parameters",
&compressionLevel, &sourceSize, &dictSize)) {
return NULL;
}
params = ZSTD_getCParams(compressionLevel, sourceSize, dictSize);
result = PyObject_New(CompressionParametersObject, &CompressionParametersType);
if (!result) {
return NULL;
}
result->windowLog = params.windowLog;
result->chainLog = params.chainLog;
result->hashLog = params.hashLog;
result->searchLog = params.searchLog;
result->searchLength = params.searchLength;
result->targetLength = params.targetLength;
result->strategy = params.strategy;
return result;
}
static int CompressionParameters_init(CompressionParametersObject* self, PyObject* args, PyObject* kwargs) {
static char* kwlist[] = {
"window_log",
"chain_log",
"hash_log",
"search_log",
"search_length",
"target_length",
"strategy",
NULL
};
unsigned windowLog;
unsigned chainLog;
unsigned hashLog;
unsigned searchLog;
unsigned searchLength;
unsigned targetLength;
unsigned strategy;
ZSTD_compressionParameters params;
size_t zresult;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "IIIIIII:CompressionParameters",
kwlist, &windowLog, &chainLog, &hashLog, &searchLog, &searchLength,
&targetLength, &strategy)) {
return -1;
}
if (windowLog < ZSTD_WINDOWLOG_MIN || windowLog > ZSTD_WINDOWLOG_MAX) {
PyErr_SetString(PyExc_ValueError, "invalid window log value");
return -1;
}
if (chainLog < ZSTD_CHAINLOG_MIN || chainLog > ZSTD_CHAINLOG_MAX) {
PyErr_SetString(PyExc_ValueError, "invalid chain log value");
return -1;
}
if (hashLog < ZSTD_HASHLOG_MIN || hashLog > ZSTD_HASHLOG_MAX) {
PyErr_SetString(PyExc_ValueError, "invalid hash log value");
return -1;
}
if (searchLog < ZSTD_SEARCHLOG_MIN || searchLog > ZSTD_SEARCHLOG_MAX) {
PyErr_SetString(PyExc_ValueError, "invalid search log value");
return -1;
}
if (searchLength < ZSTD_SEARCHLENGTH_MIN || searchLength > ZSTD_SEARCHLENGTH_MAX) {
PyErr_SetString(PyExc_ValueError, "invalid search length value");
return -1;
}
if (targetLength < ZSTD_TARGETLENGTH_MIN || targetLength > ZSTD_TARGETLENGTH_MAX) {
PyErr_SetString(PyExc_ValueError, "invalid target length value");
return -1;
}
if (strategy < ZSTD_fast || strategy > ZSTD_btopt) {
PyErr_SetString(PyExc_ValueError, "invalid strategy value");
return -1;
}
self->windowLog = windowLog;
self->chainLog = chainLog;
self->hashLog = hashLog;
self->searchLog = searchLog;
self->searchLength = searchLength;
self->targetLength = targetLength;
self->strategy = strategy;
ztopy_compression_parameters(self, &params);
zresult = ZSTD_checkCParams(params);
if (ZSTD_isError(zresult)) {
PyErr_Format(PyExc_ValueError, "invalid compression parameters: %s",
ZSTD_getErrorName(zresult));
return -1;
}
return 0;
}
PyDoc_STRVAR(CompressionParameters_estimated_compression_context_size__doc__,
"Estimate the size in bytes of a compression context for compression parameters\n"
);
PyObject* CompressionParameters_estimated_compression_context_size(CompressionParametersObject* self) {
ZSTD_compressionParameters params;
ztopy_compression_parameters(self, &params);
return PyLong_FromSize_t(ZSTD_estimateCCtxSize(params));
}
PyObject* estimate_compression_context_size(PyObject* self, PyObject* args) {
CompressionParametersObject* params;
ZSTD_compressionParameters zparams;
PyObject* result;
if (!PyArg_ParseTuple(args, "O!:estimate_compression_context_size",
&CompressionParametersType, &params)) {
return NULL;
}
ztopy_compression_parameters(params, &zparams);
result = PyLong_FromSize_t(ZSTD_estimateCCtxSize(zparams));
return result;
}
PyDoc_STRVAR(CompressionParameters__doc__,
"CompressionParameters: low-level control over zstd compression");
static void CompressionParameters_dealloc(PyObject* self) {
PyObject_Del(self);
}
static PyMethodDef CompressionParameters_methods[] = {
{
"estimated_compression_context_size",
(PyCFunction)CompressionParameters_estimated_compression_context_size,
METH_NOARGS,
CompressionParameters_estimated_compression_context_size__doc__
},
{ NULL, NULL }
};
static PyMemberDef CompressionParameters_members[] = {
{ "window_log", T_UINT,
offsetof(CompressionParametersObject, windowLog), READONLY,
"window log" },
{ "chain_log", T_UINT,
offsetof(CompressionParametersObject, chainLog), READONLY,
"chain log" },
{ "hash_log", T_UINT,
offsetof(CompressionParametersObject, hashLog), READONLY,
"hash log" },
{ "search_log", T_UINT,
offsetof(CompressionParametersObject, searchLog), READONLY,
"search log" },
{ "search_length", T_UINT,
offsetof(CompressionParametersObject, searchLength), READONLY,
"search length" },
{ "target_length", T_UINT,
offsetof(CompressionParametersObject, targetLength), READONLY,
"target length" },
{ "strategy", T_INT,
offsetof(CompressionParametersObject, strategy), READONLY,
"strategy" },
{ NULL }
};
PyTypeObject CompressionParametersType = {
PyVarObject_HEAD_INIT(NULL, 0)
"CompressionParameters", /* tp_name */
sizeof(CompressionParametersObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)CompressionParameters_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
CompressionParameters__doc__, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
CompressionParameters_methods, /* tp_methods */
CompressionParameters_members, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)CompressionParameters_init, /* tp_init */
0, /* tp_alloc */
PyType_GenericNew, /* tp_new */
};
void compressionparams_module_init(PyObject* mod) {
Py_TYPE(&CompressionParametersType) = &PyType_Type;
if (PyType_Ready(&CompressionParametersType) < 0) {
return;
}
Py_INCREF(&CompressionParametersType);
PyModule_AddObject(mod, "CompressionParameters",
(PyObject*)&CompressionParametersType);
}