diff --git a/cstore/py-datapackstore.h b/cstore/py-datapackstore.h --- a/cstore/py-datapackstore.h +++ b/cstore/py-datapackstore.h @@ -27,6 +27,7 @@ #include "cstore/py-structs.h" #include "cstore/pythonutil.h" #include "cstore/pythonkeyiterator.h" +#include "cstore/pythondatastore.h" #include "cstore/uniondatapackstore.h" // --------- DatapackStore Implementation --------- @@ -205,6 +206,7 @@ try { std::vector stores; + std::vector cSubStores; std::vector pySubStores; PyObject *item; @@ -213,26 +215,30 @@ // Record the substore references, so: // A) We can decref them in case of an error. // B) They don't get GC'd while the uniondatapackstore holds on to them. - pySubStores.push_back(PythonObj(item)); + int iscdatapack = PyObject_IsInstance(item, (PyObject*)&datapackstoreType); - int isinstance = PyObject_IsInstance(item, (PyObject*)&datapackstoreType); - if (isinstance == 0) { - PyErr_SetString(PyExc_RuntimeError, "cuniondatapackstore only accepts cdatapackstore"); - return -1; - } else if (isinstance != 1) { + if (iscdatapack == 1) { + cSubStores.push_back(PythonObj(item)); + py_datapackstore *subStore = (py_datapackstore*)item; + stores.push_back(&subStore->datapackstore); + } else if (iscdatapack == 0) { + pySubStores.push_back(PythonObj(item)); + py_pythondatastore *subStore = (py_pythondatastore*)item; + stores.push_back(&subStore->pythondatastore); + } else { // Error return -1; } - - py_datapackstore *pySubStore = (py_datapackstore*)item; - stores.push_back(&pySubStore->datapackstore); } // We have to manually call the member constructor, since the provided 'self' // is just zerod out memory. new(&self->uniondatapackstore) std::shared_ptr(new UnionDatapackStore(stores)); - new(&self->substores) std::vector(); - self->substores = pySubStores; + new(&self->cstores) std::vector(); + new(&self->pystores) std::vector(); + + self->cstores = cSubStores; + self->pystores = pySubStores; } catch (const std::exception &ex) { PyErr_SetString(PyExc_RuntimeError, ex.what()); return -1; @@ -243,7 +249,8 @@ static void uniondatapackstore_dealloc(py_uniondatapackstore *self) { self->uniondatapackstore.~shared_ptr(); - self->substores.~vector(); + self->cstores.~vector(); + self->pystores.~vector(); PyObject_Del(self); } diff --git a/cstore/py-pythondatastore.h b/cstore/py-pythondatastore.h new file mode 100644 --- /dev/null +++ b/cstore/py-pythondatastore.h @@ -0,0 +1,83 @@ +// python implementation of a common interface +// +// Copyright 2017 Facebook, Inc. +// +// This software may be used and distributed according to the terms of the +// GNU General Public License version 2 or any later version. +// +// no-check-code + +// The PY_SSIZE_T_CLEAN define must be defined before the Python.h include, +// as per the documentation. + +#define PY_SSIZE_T_CLEAN +#include + +#include +#include + +#include "datastore.h" +#include "key.h" +#include "pythonutil.h" +#include "pythonkeyiterator.h" + +static std::shared_ptr pythonstore_getdeltachain(void *_store, + const Key &key) { + PythonObj store((PyObject*)_store); + // Build (name, node) tuple and call getdeltachain + // method of the underlying store + PythonObj pyKey = Py_BuildValue("(s#s#)", (key.name).c_str(), + (key.name).size(), key.node, 20); + PythonObj list = store.callmethod("getdeltachain", pyKey); + + // Extract the delta chain from the list of tuples + // and build a DeltaChain object from them + std::shared_ptr< std::vector > links = + std::make_shared< std::vector >(); + + PythonObj iter = PyObject_GetIter(list); + PyObject *tuple; + while ((tuple = PyIter_Next(iter)) != NULL) { + const char *filename, *deltabasefilename; + const uint8_t *node, *deltabasenode, *delta; + uint16_t filenamesz; + uint64_t deltasz; + + int ok = PyArg_ParseTuple(tuple, "s#zszz#", + &filename, &filenamesz, &node, + &deltabasefilename, &deltabasenode, + &delta, &deltasz); + + // the item is a five tuple + if (ok) { + links->push_back(DeltaChainLink(filename, deltabasefilename, node, + deltabasenode, delta, filenamesz, + deltasz)); + } + } + + return std::make_shared(links); +} + +static std::shared_ptr pythonstore_getmissing(void *_store, KeyIterator &missing) { + PythonObj store((PyObject*)_store); + PythonObj list = PyList_New(0); + + Key *key; + while ((key = missing.next()) != NULL) { + PythonObj pyKey = Py_BuildValue("(s#s#)", key->name.c_str(), + key->name.size(), key->node, 20); + if (PyList_Append(list, (PyObject*)pyKey)) { + return NULL; //throw an error + } + } + + PythonObj keys = store.callmethod("getmissing", list); + return std::make_shared(keys); +} + +static void pythonstore_markforrefresh(void *_store) { + PythonObj store((PyObject*)_store); + PythonObj args = Py_BuildValue(""); + store.callmethod("markforrefresh", args); +} diff --git a/cstore/py-structs.h b/cstore/py-structs.h --- a/cstore/py-structs.h +++ b/cstore/py-structs.h @@ -13,6 +13,7 @@ #include #include "cstore/datapackstore.h" +#include "cstore/pythondatastore.h" #include "cstore/pythonutil.h" #include "cstore/uniondatapackstore.h" @@ -22,13 +23,20 @@ DatapackStore datapackstore; }; +struct py_pythondatastore { + PyObject_HEAD; + + PythonDataStore pythondatastore; +}; + struct py_uniondatapackstore { PyObject_HEAD; std::shared_ptr uniondatapackstore; // Keep a reference to the python objects so we can decref them later. - std::vector substores; + std::vector cstores; + std::vector pystores; }; #endif // FBHGEXT_CSTORE_PY_STRUCTS_H diff --git a/cstore/pythondatastore.h b/cstore/pythondatastore.h new file mode 100644 --- /dev/null +++ b/cstore/pythondatastore.h @@ -0,0 +1,37 @@ +// pythondatastore.h - c++ declarations for a python data store +// +// Copyright 2017 Facebook, Inc. +// +// This software may be used and distributed according to the terms of the +// GNU General Public License version 2 or any later version. +// +// no-check-code + +#ifndef FBHGEXT_PYTHONDATASTORE_H +#define FBHGEXT_PYTHONDATASTORE_H + +#include + +#include "cstore/datastore.h" +#include "cstore/key.h" + +class PythonDataStore : public DataStore { + private: + void* _store; // pointer to python object + public: + PythonDataStore(void* store); + + ~PythonDataStore() = default; + + DeltaChainIterator getDeltaChain(const Key &key); + + std::shared_ptr getMissing(KeyIterator &missing); + + std::shared_ptr getDeltaChainRaw(const Key &key); + + bool contains(const Key &key); + + void markForRefresh(); +}; + +#endif //FBHGEXT_PYTHONDATASTORE_H diff --git a/cstore/pythondatastore.cpp b/cstore/pythondatastore.cpp new file mode 100644 --- /dev/null +++ b/cstore/pythondatastore.cpp @@ -0,0 +1,48 @@ +// pythondatastore.cpp - implementation of a python data store +// +// Copyright 2017 Facebook, Inc. +// +// This software may be used and distributed according to the terms of the +// GNU General Public License version 2 or any later version. +// +// no-check-code + +#include "py-pythondatastore.h" +#include "pythondatastore.h" + +PythonDataStore::PythonDataStore(void* store) : _store(store) {} + +DeltaChainIterator PythonDataStore::getDeltaChain(const Key &key) { + std::shared_ptr chain = pythonstore_getdeltachain(_store, key); + return DeltaChainIterator(chain); +} + +std::shared_ptr PythonDataStore::getDeltaChainRaw(const Key &key) { + return pythonstore_getdeltachain(_store, key); +} + +std::shared_ptr PythonDataStore::getMissing(KeyIterator &missing) { + return pythonstore_getmissing(_store, missing); +} + +void PythonDataStore::markForRefresh() { + pythonstore_markforrefresh(_store); +} + +class Single : public KeyIterator { + public: + Key *_k; + Single(Key *k) : _k(k) {} + Key *next() { + Key *tmp = _k; + _k = NULL; + return tmp; + } +}; + +bool PythonDataStore::contains(const Key &key) { + Key copy = key; + Single iter(©); + std::shared_ptr it = pythonstore_getmissing(_store, iter); + return (!it->next()); +} diff --git a/setup.py b/setup.py --- a/setup.py +++ b/setup.py @@ -242,6 +242,7 @@ 'cstore/deltachain.cpp', 'cstore/py-cstore.cpp', 'cstore/pythonutil.cpp', + 'cstore/pythondatastore.cpp', 'cstore/uniondatapackstore.cpp', 'ctreemanifest/manifest.cpp', 'ctreemanifest/manifest_entry.cpp', diff --git a/tests/test-check-code-hg.t b/tests/test-check-code-hg.t --- a/tests/test-check-code-hg.t +++ b/tests/test-check-code-hg.t @@ -72,8 +72,11 @@ Skipping cstore/py-cdatapack.h it has no-che?k-code (glob) Skipping cstore/py-cstore.cpp it has no-che?k-code (glob) Skipping cstore/py-datapackstore.h it has no-che?k-code (glob) + Skipping cstore/py-pythondatastore.h it has no-che?k-code (glob) Skipping cstore/py-structs.h it has no-che?k-code (glob) Skipping cstore/py-treemanifest.h it has no-che?k-code (glob) + Skipping cstore/pythondatastore.cpp it has no-che?k-code (glob) + Skipping cstore/pythondatastore.h it has no-che?k-code (glob) Skipping cstore/pythonkeyiterator.h it has no-che?k-code (glob) Skipping cstore/pythonutil.cpp it has no-che?k-code (glob) Skipping cstore/pythonutil.h it has no-che?k-code (glob)