Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • cellframe/python-cellframe
1 result
Show changes
Commits on Source (6)
Hide whitespace changes
Inline Side-by-side
Showing
with 910 additions and 274 deletions
CMakeLists.txt
View file @ f69ecb2c
......@@ -42,6 +42,7 @@ add_subdirectory(modules/cellframe-sdk/common)
add_subdirectory(modules/cellframe-sdk/net)
add_subdirectory(modules/cellframe-sdk/net/srv)
add_subdirectory(modules/cellframe-sdk/gdb)
add_subdirectory(modules/cellframe-sdk/services/datum)
add_subdirectory(modules/cellframe-sdk/chain)
add_subdirectory(modules/cellframe-sdk/app-cli)
add_subdirectory(modules/cellframe-sdk/wallet)
......@@ -167,6 +168,7 @@ target_compile_options(dap_stream_ch_chain_net_srv PRIVATE "-fpic")
#target_compile_options(dap_chain_cs_dag_poa PRIVATE "-fpic")
#target_compile_options(dap_chain_cs_dag_pos PRIVATE "-fpic")
target_compile_options(dap_server_core_python_module PRIVATE "-fpic")
target_compile_options(dap_chain_service_datum_python PRIVATE "-fpic")
if (WIN32)
......@@ -186,6 +188,7 @@ target_link_libraries(${PROJECT_NAME} cellframe-sdk dap_python_module
dap_app_cli_python_module
dap_chain_wallet_python_module
dap_server_json_rpc_python_module
dap_chain_service_datum_python
${PYTHON_LIBRARIES}
)
......
CellFrame/python-cellframe.c
View file @ f69ecb2c
......@@ -426,6 +426,7 @@ PyMODINIT_FUNC PyInit_libCellFrame(void){
// === Chain net srv ===
PyType_Ready(&DapChainNetSrvObject_DapChainNetSrvObjectType) < 0 ||
PyType_Ready(&DapChainNetSrvClientObject_DapChainNetSrvClientObjectType) < 0 ||
PyType_Ready(&DapChainNetSrvDatumObject_DapChainNetSrvDatumObjectType) < 0 ||
// =============
PyType_Ready(&DapChainGDBObject_DapChainGDBType) < 0 ||
......@@ -531,6 +532,7 @@ PyMODINIT_FUNC PyInit_libCellFrame(void){
// === Chain net srv ===
PyModule_AddObject(module, "ChainNetSrv", (PyObject*)&DapChainNetSrvObject_DapChainNetSrvObjectType);
PyModule_AddObject(module, "ChainNetSrvClient", (PyObject*)&DapChainNetSrvClientObject_DapChainNetSrvClientObjectType);
PyModule_AddObject(module, "ChainNetSrvDatum", (PyObject*)&DapChainNetSrvDatumObject_DapChainNetSrvDatumObjectType);
// =============
PyModule_AddObject(module, "ChainGDB", (PyObject*)&DapChainGDBObject_DapChainGDBType);
......
include/python-cellframe.h
View file @ f69ecb2c
......@@ -40,6 +40,7 @@
// === Chain net srv ===
#include "wrapping_dap_chain_net_srv.h"
#include "wrapping_dap_chain_net_srv_client.h"
#include "wrapping_dap_chain_net_srv_datum.h"
// ============
......
modules/cellframe-sdk/chain/include/libdap-chain-python.h
View file @ f69ecb2c
......@@ -100,4 +100,12 @@ static PyTypeObject dapChainObject_dapChainType = {
};
static inline bool PyDapChain_Check(PyObject* self){
if (PyObject_TypeCheck(self, &dapChainObject_dapChainType) == 0){
return true;
} else {
return false;
}
}
modules/cellframe-sdk/common/include/wrapping_dap_chain_common.h
View file @ f69ecb2c
......@@ -278,8 +278,8 @@ static PyTypeObject DapChainNetSrvUIDObject_DapChainNetSrvUIDObjectType = {
PyType_GenericNew, /* tp_new */
};
static bool PyDapChainNetSrvUid_Check(PyObject *a_obj){
return PyObject_TypeCheck(a_obj, &DapChainNetSrvUIDObject_DapChainNetSrvUIDObjectType);
static bool PyDapChainNetSrvUid_Check(PyDapChainNetSrvUIDObject *a_obj){
return !PyObject_TypeCheck(a_obj, &DapChainNetSrvUIDObject_DapChainNetSrvUIDObjectType);
}
/*=================*/
......
modules/cellframe-sdk/common/src/wrapping_dap_chain_datum_tx.c
View file @ f69ecb2c
......@@ -112,7 +112,7 @@ PyObject *dap_chain_datum_tx_add_out_cond_item_py(PyObject *self, PyObject *args
return NULL;
void *cond = (void*)PyBytes_AsString(obj_cond_bytes);
int res = dap_chain_datum_tx_add_out_cond_item(&(((PyDapChainDatumTxObject*)self)->datum_tx),
((PyCryptoKeyObject*)obj_key)->key,
((PyDapPkeyObject*)obj_key)->pkey,
((PyDapChainNetSrvUIDObject*)obj_srv_uid)->net_srv_uid,
value, value_max_per_unit,
((PyDapChainNetSrvPriceUnitUIDObject*)obj_srv_price_unit_uid)->price_unit_uid,
......
modules/cellframe-sdk/net/include/libdap_chain_net_python.h
View file @ f69ecb2c
......@@ -152,6 +152,11 @@ static PyTypeObject DapChainNetObject_DapChainNetObjectType = {
PyType_GenericNew, /* tp_new */
};
static bool PyDapChainNet_Check(PyDapChainNetObject *pyNet)
{
return !PyObject_TypeCheck(pyNet, &DapChainNetObject_DapChainNetObjectType);
}
#ifdef __cplusplus
}
#endif
......
modules/cellframe-sdk/net/srv/include/wrapping_dap_chain_net_srv.h
View file @ f69ecb2c
......@@ -2,15 +2,19 @@
#include "Python.h"
#include "dap_chain_net_srv.h"
#include "dap_chain_net_srv_stream_session.h"
#include "uthash.h"
#include "wrapping_dap_chain_net_srv_client.h"
#include "wrapping_dap_chain_common.h"
//#include "wrapping_dap_chain_net_srv_common.h"
#include "wrapping_dap_chain_net_srv_client_remote.h"
typedef struct PyDapChainNetSrv{
PyObject_HEAD
dap_chain_net_srv_t *srv;
bool original;
PyObject *callbackRequested;
PyObject *callbackSuccess;
PyObject *callbackError;
PyObject *callbackReceiptNext;
PyObject *callbackReadWithOutData;
}PyDapChainNetSrvObject;
int PyDapChainNetSrv_init(PyDapChainNetSrvObject* self, PyObject *args, PyObject *kwds);
......@@ -22,6 +26,10 @@ PyObject *wrapping_dap_chain_net_srv_get_price_list(PyObject *self, void *closur
PyObject *wrapping_dap_chain_net_srv_get_ban_list(PyObject *self, void *closure);
PyObject *wrapping_dap_chain_net_srv_get_grace_period(PyObject *self, void *closure);
//Function
PyObject *wrapping_dap_chain_net_srv_set_callback_channel(PyObject *self, PyObject *args);
//PyObject *wrapping_dap_chain_net_srv_issue_receipt(PyObject *self, PyObject *args);
static PyMethodDef DapChainNetSrvMethods[]={
{NULL, NULL, 0, NULL}
};
......@@ -37,7 +45,7 @@ static PyTypeObject DapChainNetSrvObject_DapChainNetSrvObjectType = {
"CellFrame.ChainNetSrv", /* tp_name */
sizeof(PyDapChainNetSrvObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)PyDapChainNetSrv_dealloc, /* tp_dealloc */
0, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
......@@ -54,7 +62,7 @@ static PyTypeObject DapChainNetSrvObject_DapChainNetSrvObjectType = {
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT |
Py_TPFLAGS_BASETYPE, /* tp_flags */
"Chain net srv object", /* tp_doc */
"Chain net service object", /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
......
modules/cellframe-sdk/net/srv/include/wrapping_dap_chain_net_srv_client.h
View file @ f69ecb2c
//
// Created by blus on 05.02.2022.
//
#pragma once
#include "Python.h"
#include "datetime.h"
#include "dap_chain_net_srv.h"
#ifndef WRAPPING_DAP_CHAIN_NET_SRV_CLIENT_H
#define WRAPPING_DAP_CHAIN_NET_SRV_CLIENT_H
#include "dap_chain_net_srv_client.h"
#include "libdap_chain_net_python.h"
typedef struct PyDapChainNetSrvClient{
PyObject_HEAD
dap_chain_net_srv_client_remote_t *srv_client;
dap_chain_net_srv_client_t *srv_client;
PyObject *callback_connected;
PyObject *callback_disconnected;
PyObject *callback_deleted;
PyObject *callback_check;
PyObject *callback_sign;
PyObject *callback_success;
PyObject *callback_error;
PyObject *callback_data;
}PyDapChainNetSrvClientObject;
PyObject *wrapping_dap_chain_net_srv_client_get_ch(PyObject *self, void *closure);
PyObject *wrapping_dap_chain_net_srv_client_get_ts_created(PyObject *self, void *closure);
PyObject *wrapping_dap_chain_net_srv_client_get_created(PyObject *self, void *closure);
PyObject *wrapping_dap_chain_net_srv_client_get_stream_worker(PyObject *self, void *closure);
PyObject *wrapping_dap_chain_net_srv_client_get_session_id(PyObject *self, void *closure);
PyObject *wrapping_dap_chain_net_srv_client_get_bytes_received(PyObject *self, void *closure);
PyObject *wrapping_dap_chain_net_srv_client_get_bytes_send(PyObject *self, void *closure);
//PyObject *wrapping_dap_chain_net_srv_client_get_bytes_prev(PyObject *self, void *closure);
//PyObject *wrapping_dap_chain_net_srv_client_get_bytes_next(PyObject *self, void *closure);
int PyDapChainNetSrvClient_init(PyDapChainNetSrvClientObject* self, PyObject *args, PyObject *kwds);
PyObject *wrapping_dap_chain_net_srv_client_check(PyObject *self, PyObject *args);
PyObject *wrapping_dap_chain_net_srv_client_request(PyObject *self, PyObject *args);
PyObject *wrapping_dap_chain_net_srv_client_write(PyObject *self, PyObject *args);
static PyMethodDef DapChainNetSrvClientMethods[]={
{"check", (PyCFunction)wrapping_dap_chain_net_srv_client_check, METH_VARARGS, ""},
{"request", (PyCFunction)wrapping_dap_chain_net_srv_client_request, METH_VARARGS, ""},
{"write", (PyCFunction)wrapping_dap_chain_net_srv_client_write, METH_VARARGS, ""},
{NULL, NULL, 0, NULL}
};
static PyGetSetDef DapChaiNetSrvClientGetsSets[] = {
{"ch", (getter)wrapping_dap_chain_net_srv_client_get_ch, NULL, NULL, NULL},
{"tsCreated", (getter)wrapping_dap_chain_net_srv_client_get_ts_created, NULL, NULL, NULL},
{"created", (getter)wrapping_dap_chain_net_srv_client_get_created, NULL, NULL, NULL},
{"streamWorker", (getter)wrapping_dap_chain_net_srv_client_get_stream_worker, NULL, NULL, NULL},
{"sessionId", (getter)wrapping_dap_chain_net_srv_client_get_session_id, NULL, NULL, NULL},
{"bytesReceived", (getter)wrapping_dap_chain_net_srv_client_get_bytes_received, NULL, NULL, NULL},
{"bytesSend", (getter)wrapping_dap_chain_net_srv_client_get_bytes_send, NULL, NULL, NULL},
{NULL}
};
static PyTypeObject DapChainNetSrvClientObject_DapChainNetSrvClientObjectType = {
PyVarObject_HEAD_INIT(NULL, 0)
"CellFrame.ChainNetSrvClient", /* tp_name */
......@@ -60,25 +50,23 @@ static PyTypeObject DapChainNetSrvClientObject_DapChainNetSrvClientObjectType =
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT |
Py_TPFLAGS_BASETYPE, /* tp_flags */
"Chain net srv client object", /* tp_doc */
Py_TPFLAGS_BASETYPE, /* tp_flags */
"Chain net service client object",/* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
DapChainNetSrvClientMethods, /* tp_methods */
DapChainNetSrvClientMethods, /* tp_methods */
0, /* tp_members */
DapChaiNetSrvClientGetsSets, /* tp_getset */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
(initproc)PyDapChainNetSrvClient_init, /* tp_init */
0, /* tp_alloc */
PyType_GenericNew, /* tp_new */
};
#endif //WRAPPING_DAP_CHAIN_NET_SRV_CLIENT_H
modules/cellframe-sdk/net/srv/include/wrapping_dap_chain_net_srv_client_remote.h 0 → 100644
View file @ f69ecb2c
//
// Created by blus on 05.02.2022.
//
#include "Python.h"
#include "datetime.h"
#include "dap_chain_net_srv.h"
#ifndef WRAPPING_DAP_CHAIN_NET_SRV_CLIENT_REMOTE_H
#define WRAPPING_DAP_CHAIN_NET_SRV_CLIENT_REMOTE_H
typedef struct PyDapChainNetSrvClientRemote{
PyObject_HEAD
dap_chain_net_srv_client_remote_t *srv_client_remote;
}PyDapChainNetSrvClientRemoteObject;
PyObject *wrapping_dap_chain_net_srv_client_remote_get_ch(PyObject *self, void *closure);
PyObject *wrapping_dap_chain_net_srv_client_remote_get_ts_created(PyObject *self, void *closure);
PyObject *wrapping_dap_chain_net_srv_client_remote_get_created(PyObject *self, void *closure);
PyObject *wrapping_dap_chain_net_srv_client_remote_get_stream_worker(PyObject *self, void *closure);
PyObject *wrapping_dap_chain_net_srv_client_remote_get_session_id(PyObject *self, void *closure);
PyObject *wrapping_dap_chain_net_srv_client_remote_get_bytes_received(PyObject *self, void *closure);
PyObject *wrapping_dap_chain_net_srv_client_remote_get_bytes_send(PyObject *self, void *closure);
//PyObject *wrapping_dap_chain_net_srv_client_remote_get_bytes_prev(PyObject *self, void *closure);
//PyObject *wrapping_dap_chain_net_srv_client_remote_get_bytes_next(PyObject *self, void *closure);
static PyMethodDef DapChainNetSrvClientRemoteMethods[]={
{NULL, NULL, 0, NULL}
};
static PyGetSetDef DapChaiNetSrvClientRemoteGetsSets[] = {
{"ch", (getter)wrapping_dap_chain_net_srv_client_remote_get_ch, NULL, NULL, NULL},
{"tsCreated", (getter)wrapping_dap_chain_net_srv_client_remote_get_ts_created, NULL, NULL, NULL},
{"created", (getter)wrapping_dap_chain_net_srv_client_remote_get_created, NULL, NULL, NULL},
{"streamWorker", (getter)wrapping_dap_chain_net_srv_client_remote_get_stream_worker, NULL, NULL, NULL},
{"sessionId", (getter)wrapping_dap_chain_net_srv_client_remote_get_session_id, NULL, NULL, NULL},
{"bytesReceived", (getter)wrapping_dap_chain_net_srv_client_remote_get_bytes_received, NULL, NULL, NULL},
{"bytesSend", (getter)wrapping_dap_chain_net_srv_client_remote_get_bytes_send, NULL, NULL, NULL},
{NULL}
};
static PyTypeObject DapChainNetSrvClientRemoteObject_DapChainNetSrvClientRemoteObjectType = {
PyVarObject_HEAD_INIT(NULL, 0)
"CellFrame.ChainNetSrvClientRemote", /* tp_name */
sizeof(PyDapChainNetSrvClientRemoteObject), /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
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 */
"Chain net service client remote object", /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
DapChainNetSrvClientRemoteMethods, /* tp_methods */
0, /* tp_members */
DapChaiNetSrvClientRemoteGetsSets, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
PyType_GenericNew, /* tp_new */
};
#endif //WRAPPING_DAP_CHAIN_NET_SRV_CLIENT_REMOTE_H
modules/cellframe-sdk/net/srv/src/wrapping_dap_chain_net_srv.c
View file @ f69ecb2c
#include "wrapping_dap_chain_net_srv.h"
enum _wrapping_dap_chain_net_srv_type_callbacks{
WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_REQUESTED,
WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_RESPONSE_SUCCESS,
WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_RESPONSE_ERROR,
WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_RECEIPT_NEXT_SUCCESS,
WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_STREAM_CH_READ,
WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_CLIENT_SUCCESS
};
typedef struct _wrapping_dap_chain_net_srv_callbacks_key{
enum _wrapping_dap_chain_net_srv_type_callbacks type;
dap_chain_net_srv_t *srv;
}_wrapping_dap_chain_net_srv_callbacks_key_t;
typedef struct _wrapping_dap_chain_net_srv_callbacks{
_wrapping_dap_chain_net_srv_callbacks_key_t *key;
dap_chain_net_srv_uid_t uid;
PyObject *func;
UT_hash_handle hh;
}_wrapping_dap_chain_net_srv_callbacks_t;
static _wrapping_dap_chain_net_srv_callbacks_t *_s_callbacks = NULL;
void _wrapping_dap_chain_net_srv_del(_wrapping_dap_chain_net_srv_callbacks_t *a_callback){
HASH_DEL(_s_callbacks, a_callback);
Py_XINCREF(a_callback->func);
}
PyObject* _wrapping_dap_chain_net_srv_search(_wrapping_dap_chain_net_srv_callbacks_key_t *a_key){
_wrapping_dap_chain_net_srv_callbacks_t *callbacks = NULL;
HASH_FIND(hh, _s_callbacks, a_key, sizeof(_wrapping_dap_chain_net_srv_callbacks_key_t), callbacks);
if (callbacks == NULL){
return Py_None;
} else {
return callbacks->func;
}
}
_wrapping_dap_chain_net_srv_callbacks_t* _wrapping_dap_chain_net_srv_search_el(_wrapping_dap_chain_net_srv_callbacks_key_t *a_key){
_wrapping_dap_chain_net_srv_callbacks_t *callbacks = NULL;
HASH_FIND(hh, _s_callbacks, a_key, sizeof(_wrapping_dap_chain_net_srv_callbacks_key_t), callbacks);
return callbacks;
}
int _wrapping_dap_chain_net_srv_add(
enum _wrapping_dap_chain_net_srv_type_callbacks a_type,
dap_chain_net_srv_t *a_srv,
dap_chain_net_srv_uid_t a_uid,
PyObject *a_obj_func){
if (PyCallable_Check(a_obj_func)){
_wrapping_dap_chain_net_srv_callbacks_t *callbacks = DAP_NEW(_wrapping_dap_chain_net_srv_callbacks_t);
_wrapping_dap_chain_net_srv_callbacks_key_t *l_key = DAP_NEW(_wrapping_dap_chain_net_srv_callbacks_key_t);
l_key->type = a_type;
l_key->srv = a_srv;
callbacks->key = l_key;
callbacks->uid = a_uid;
callbacks->func = a_obj_func;
Py_XINCREF(a_obj_func);
HASH_ADD(hh, _s_callbacks, key, sizeof(_wrapping_dap_chain_net_srv_callbacks_key_t), callbacks);
return 0;
}
return -1;
}
#define LOG_TAG "wrapping_dap_chain_net_srv"
PyObject *_wrapping_dac_chain_callback_data_t_get_tuple(
dap_chain_net_srv_t *a_srv, //NOT USAGE
dap_chain_net_srv_t *a_srv,
uint32_t a_usage_id,
dap_chain_net_srv_client_remote_t * a_srv_client,
const void *a_custom_data,
size_t a_custom_data_size){
PyDapChainNetSrvClientObject *l_obj_srv_client = NULL;
PyDapChainNetSrvObject *pyNetSrvObj = (PyDapChainNetSrvObject *)a_srv->_inheritor;
PyDapChainNetSrvClientRemoteObject *l_obj_srv_client = NULL;
if (a_srv_client == NULL){
l_obj_srv_client = (PyDapChainNetSrvClientObject *)Py_None;
l_obj_srv_client = (PyDapChainNetSrvClientRemoteObject *)Py_None;
} else {
l_obj_srv_client = PyObject_New(PyDapChainNetSrvClientObject,
&DapChainNetSrvClientObject_DapChainNetSrvClientObjectType);
PyObject_Dir((PyObject *) l_obj_srv_client);
l_obj_srv_client->srv_client = a_srv_client;
l_obj_srv_client = PyObject_New(PyDapChainNetSrvClientRemoteObject,
&DapChainNetSrvClientRemoteObject_DapChainNetSrvClientRemoteObjectType);
l_obj_srv_client->srv_client_remote = a_srv_client;
}
PyObject *l_obj_custom_data = NULL;
if (a_custom_data == NULL || a_custom_data_size == 0){
l_obj_custom_data = Py_None;
}else{
l_obj_custom_data = PyBytes_FromStringAndSize((char*)a_custom_data_size, (Py_ssize_t)a_custom_data_size);
l_obj_custom_data = PyBytes_FromStringAndSize((char*)a_custom_data, (Py_ssize_t)a_custom_data_size);
}
return Py_BuildValue("iOO", l_obj_srv_client, l_obj_custom_data);
return Py_BuildValue("OiOO", pyNetSrvObj, a_usage_id, l_obj_srv_client, l_obj_custom_data);
}
int _w_dap_chain_callback_data_t_requested(
......@@ -94,19 +32,20 @@ int _w_dap_chain_callback_data_t_requested(
dap_chain_net_srv_client_remote_t * a_srv_client,
const void *a_custom_data,
size_t a_custom_data_size){
_wrapping_dap_chain_net_srv_callbacks_key_t *l_key = DAP_NEW(_wrapping_dap_chain_net_srv_callbacks_key_t);
l_key->srv = a_srv;
l_key->type = WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_REQUESTED;
PyObject *l_func = _wrapping_dap_chain_net_srv_search(l_key);
Py_INCREF(l_func);
PyDapChainNetSrvObject *pyNetSrvObj = (PyDapChainNetSrvObject *)a_srv->_inheritor;
PyObject *l_func = pyNetSrvObj->callbackRequested;
if (!PyCallable_Check(l_func)){
log_it(L_ERROR, "Python function is not callable");
return -1;
}
PyObject *l_arg = _wrapping_dac_chain_callback_data_t_get_tuple(a_srv, a_usage_id, a_srv_client, a_custom_data, a_custom_data_size);
PyGILState_STATE state = PyGILState_Ensure();
PyObject *result = PyObject_CallObject(l_func, l_arg);
PyGILState_Release(state);
if(result == NULL){
PyErr_Print();
return -1;
}
Py_XINCREF(l_func);
Py_XINCREF(l_arg);
if (!PyLong_Check(result)){
return -1;
}
......@@ -116,22 +55,23 @@ int _w_dap_chain_callback_data_t_requested(
int _w_dap_chain_callback_data_t_response_success(
dap_chain_net_srv_t *a_srv,
uint32_t a_usage_id,
dap_chain_net_srv_client_remote_t * a_srv_client,
dap_chain_net_srv_client_remote_t *a_srv_client,
const void *a_custom_data,
size_t a_custom_data_size){
_wrapping_dap_chain_net_srv_callbacks_key_t *l_key = DAP_NEW(_wrapping_dap_chain_net_srv_callbacks_key_t);
l_key->srv = a_srv;
l_key->type = WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_RESPONSE_SUCCESS;
PyObject *l_func = _wrapping_dap_chain_net_srv_search(l_key);
Py_INCREF(l_func);
PyDapChainNetSrvObject *pyNetSrvObj = (PyDapChainNetSrvObject *)a_srv->_inheritor;
PyObject *l_func = pyNetSrvObj->callbackSuccess;
if (!PyCallable_Check(l_func)){
log_it(L_ERROR, "Python function is not callable");
return -1;
}
PyObject *l_arg = _wrapping_dac_chain_callback_data_t_get_tuple(a_srv, a_usage_id, a_srv_client, a_custom_data, a_custom_data_size);
PyGILState_STATE state = PyGILState_Ensure();
PyObject *result = PyObject_CallObject(l_func, l_arg);
PyGILState_Release(state);
if(result == NULL){
PyErr_Print();
return -1;
}
Py_XINCREF(l_func);
Py_XINCREF(l_arg);
if (!PyLong_Check(result)){
return -1;
}
......@@ -142,22 +82,23 @@ int _w_dap_chain_callback_data_t_response_success(
int _w_dap_chain_callback_data_t_response_error(
dap_chain_net_srv_t *a_srv,
uint32_t a_usage_id,
dap_chain_net_srv_client_remote_t * a_srv_client,
dap_chain_net_srv_client_remote_t *a_srv_client,
const void *a_custom_data,
size_t a_custom_data_size){
_wrapping_dap_chain_net_srv_callbacks_key_t *l_key = DAP_NEW(_wrapping_dap_chain_net_srv_callbacks_key_t);
l_key->srv = a_srv;
l_key->type = WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_RESPONSE_ERROR;
PyObject *l_func = _wrapping_dap_chain_net_srv_search(l_key);
Py_INCREF(l_func);
PyDapChainNetSrvObject *pyNetSrvObj = (PyDapChainNetSrvObject *)a_srv->_inheritor;
PyObject *l_func = pyNetSrvObj->callbackError;
if (!PyCallable_Check(l_func)){
log_it(L_ERROR, "Python function is not callable");
return -1;
}
PyObject *l_arg = _wrapping_dac_chain_callback_data_t_get_tuple(a_srv, a_usage_id, a_srv_client, a_custom_data, a_custom_data_size);
PyGILState_STATE state = PyGILState_Ensure();
PyObject *result = PyObject_CallObject(l_func, l_arg);
PyGILState_Release(state);
if(result == NULL){
PyErr_Print();
return -1;
}
Py_XINCREF(l_func);
Py_XINCREF(l_arg);
if (!PyLong_Check(result)){
return -1;
}
......@@ -168,22 +109,23 @@ int _w_dap_chain_callback_data_t_response_error(
int _w_dap_chain_callback_data_t_receipt_next_success(
dap_chain_net_srv_t *a_srv,
uint32_t a_usage_id,
dap_chain_net_srv_client_remote_t * a_srv_client,
dap_chain_net_srv_client_remote_t *a_srv_client,
const void *a_custom_data,
size_t a_custom_data_size){
_wrapping_dap_chain_net_srv_callbacks_key_t *l_key = DAP_NEW(_wrapping_dap_chain_net_srv_callbacks_key_t);
l_key->srv = a_srv;
l_key->type = WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_RECEIPT_NEXT_SUCCESS;
PyObject *l_func = _wrapping_dap_chain_net_srv_search(l_key);
Py_INCREF(l_func);
PyDapChainNetSrvObject *pyNetSrvObj = (PyDapChainNetSrvObject *)a_srv->_inheritor;
PyObject *l_func = pyNetSrvObj->callbackReceiptNext;
if (!PyCallable_Check(l_func)){
log_it(L_ERROR, "Python function is not callable");
return -1;
}
PyObject *l_arg = _wrapping_dac_chain_callback_data_t_get_tuple(a_srv, a_usage_id, a_srv_client, a_custom_data, a_custom_data_size);
PyGILState_STATE state = PyGILState_Ensure();
PyObject *result = PyObject_CallObject(l_func, l_arg);
PyGILState_Release(state);
if(result == NULL){
PyErr_Print();
return -1;
}
Py_XINCREF(l_func);
Py_XINCREF(l_arg);
if (!PyLong_Check(result)){
return -1;
}
......@@ -191,14 +133,37 @@ int _w_dap_chain_callback_data_t_receipt_next_success(
return res_int;
return 0;
}
int _w_dap_chain_callback_data_t_stream_ch_read(
dap_chain_net_srv_t *a_srv,
uint32_t a_usage_id,
dap_chain_net_srv_client_remote_t * a_srv_client,
const void *a_custom_data,
size_t a_custom_data_size){
return 0;
void *_w_dap_chain_callback_data_t_custom_data(dap_chain_net_srv_t *a_srv,
dap_chain_net_srv_usage_t *a_usage,
const void *a_custom_data,
size_t a_custom_data_size,
size_t *a_out_data_size){
PyDapChainNetSrvObject *pyNetSrvObj = (PyDapChainNetSrvObject *)a_srv->_inheritor;
PyObject *l_func = pyNetSrvObj->callbackReadWithOutData;
if (!PyCallable_Check(l_func)){
log_it(L_ERROR, "Python function is not callable");
return NULL;
}
PyObject *l_arg = _wrapping_dac_chain_callback_data_t_get_tuple(a_srv, a_usage ? a_usage->id : 0,
a_usage ? a_usage->client : NULL,
a_custom_data, a_custom_data_size);
PyGILState_STATE state = PyGILState_Ensure();
PyObject *result = PyObject_CallObject(l_func, l_arg);
PyGILState_Release(state);
if(result == NULL){
PyErr_Print();
return NULL;
}
if (!PyBytes_Check(result)){
return NULL;
}
void *l_data = PyBytes_AsString(result);
if (a_out_data_size)
*a_out_data_size = (size_t)PyBytes_Size(result);
return l_data;
}
int _w_dap_chain_callback_data_t_client_success(
dap_chain_net_srv_t *a_srv,
uint32_t a_usage_id,
......@@ -208,110 +173,63 @@ int _w_dap_chain_callback_data_t_client_success(
return 0;
}
//Conructor
//Constructor
int PyDapChainNetSrv_init(PyDapChainNetSrvObject* self, PyObject *args, PyObject *kwds){
const char *kwlist[] = {
"uid",
"section",
"callbackRequested",
"callbackResponseSuccess",
"callbackResponseError",
"callbackReceiptNextSuccess",
"callbackCustomData",
NULL};
PyObject *obj_uid;
PyObject *obj_callback_requested;
PyObject *obj_callback_response_success;
PyObject *obj_callback_response_error;
PyObject *obj_callback_receipt_next_success;
if(!PyArg_ParseTupleAndKeywords(args, kwds, "OOOOO", (char **)kwlist,
PyDapChainNetSrvUIDObject *obj_uid;
const char *l_section;
if(!PyArg_ParseTupleAndKeywords(args, kwds, "OsOOOOO", (char **)kwlist,
&obj_uid,
&obj_callback_requested,
&obj_callback_response_success,
&obj_callback_response_error,
&obj_callback_receipt_next_success)) {
&l_section,
&self->callbackRequested,
&self->callbackSuccess,
&self->callbackError,
&self->callbackReceiptNext,
&self->callbackReadWithOutData)) {
return -1;
}
if (
PyDapChainNetSrvUid_Check(obj_uid)||
PyCallable_Check(obj_callback_requested)||
PyCallable_Check(obj_callback_response_success)||
PyCallable_Check(obj_callback_response_error)||
PyCallable_Check(obj_callback_receipt_next_success)) {
if (PyDapChainNetSrvUid_Check(obj_uid) &&
PyCallable_Check(self->callbackRequested) &&
PyCallable_Check(self->callbackSuccess) &&
PyCallable_Check(self->callbackError) &&
PyCallable_Check(self->callbackReceiptNext) &&
PyCallable_Check(self->callbackReadWithOutData)) {
self->srv = dap_chain_net_srv_add(
((PyDapChainNetSrvUIDObject*)obj_uid)->net_srv_uid,
obj_uid->net_srv_uid,
l_section,
_w_dap_chain_callback_data_t_requested,
_w_dap_chain_callback_data_t_response_success,
_w_dap_chain_callback_data_t_response_error,
_w_dap_chain_callback_data_t_receipt_next_success
_w_dap_chain_callback_data_t_receipt_next_success,
_w_dap_chain_callback_data_t_custom_data
);
if (self->srv == NULL){
return -3;
}
_wrapping_dap_chain_net_srv_add(
WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_REQUESTED,
self->srv,
((PyDapChainNetSrvUIDObject*)self)->net_srv_uid,
obj_callback_requested);
_wrapping_dap_chain_net_srv_add(
WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_RESPONSE_SUCCESS,
self->srv,
((PyDapChainNetSrvUIDObject*)self)->net_srv_uid,
obj_callback_response_success);
_wrapping_dap_chain_net_srv_add(
WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_RESPONSE_ERROR,
self->srv,
((PyDapChainNetSrvUIDObject*)self)->net_srv_uid,
obj_callback_response_error);
_wrapping_dap_chain_net_srv_add(
WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_RECEIPT_NEXT_SUCCESS,
self->srv,
((PyDapChainNetSrvUIDObject*)self)->net_srv_uid,
obj_callback_receipt_next_success);
self->original = true;
self->srv->_inheritor = self;
Py_INCREF(self);
return 0;
}
return -2;
}
void PyDapChainNetSrv_dealloc(PyDapChainNetSrvObject* self){
if(self->original == true){
_wrapping_dap_chain_net_srv_callbacks_t *callback = NULL;
_wrapping_dap_chain_net_srv_callbacks_key_t *l_key_requested = DAP_NEW(_wrapping_dap_chain_net_srv_callbacks_key_t);
l_key_requested->type = WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_REQUESTED;
l_key_requested->srv = self->srv;
callback = _wrapping_dap_chain_net_srv_search_el(l_key_requested);
_wrapping_dap_chain_net_srv_del(callback);
DAP_FREE(callback);
DAP_FREE(l_key_requested);
_wrapping_dap_chain_net_srv_callbacks_key_t *l_key_success = DAP_NEW(_wrapping_dap_chain_net_srv_callbacks_key_t);;
l_key_success->type = WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_RESPONSE_SUCCESS;
l_key_success->srv = self->srv;
callback = _wrapping_dap_chain_net_srv_search_el(l_key_success);
_wrapping_dap_chain_net_srv_del(callback);
DAP_FREE(callback);
DAP_FREE(l_key_requested);
_wrapping_dap_chain_net_srv_callbacks_key_t *l_key_error = DAP_NEW(_wrapping_dap_chain_net_srv_callbacks_key_t);;
l_key_error->type = WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_RESPONSE_ERROR;
l_key_error->srv = self->srv;
callback = _wrapping_dap_chain_net_srv_search_el(l_key_error);
_wrapping_dap_chain_net_srv_del(callback);
DAP_FREE(callback);
DAP_FREE(l_key_error);
_wrapping_dap_chain_net_srv_callbacks_key_t *l_key_receipt_new_success = DAP_NEW(_wrapping_dap_chain_net_srv_callbacks_key_t);;
l_key_receipt_new_success->type = WRAPPING_DAP_CHAIN_NET_SERV_CALLBACK_DATA_RECEIPT_NEXT_SUCCESS;
l_key_error->srv = self->srv;
callback = _wrapping_dap_chain_net_srv_search_el(l_key_receipt_new_success);
_wrapping_dap_chain_net_srv_del(callback);
DAP_FREE(callback);
DAP_FREE(l_key_receipt_new_success);
dap_chain_net_srv_del(self->srv);
}
dap_chain_net_srv_del(self->srv);
Py_XDECREF(self);
Py_TYPE(self)->tp_free((PyObject*)self);
}
PyObject *wrapping_dap_chain_net_srv_get_uid(PyObject *self, void *closure){
(void)closure;
PyDapChainNetSrvUIDObject *l_obj_srv_uid = PyObject_New(PyDapChainNetSrvUIDObject, &DapChainNetSrvUIDObject_DapChainNetSrvUIDObjectType);
PyObject_Dir((PyObject*)l_obj_srv_uid);
l_obj_srv_uid->net_srv_uid = ((PyDapChainNetSrvObject *)self)->srv->uid;
return (PyObject*)l_obj_srv_uid;
}
......@@ -320,3 +238,19 @@ PyObject *wrapping_dap_chain_net_srv_get_grace_period(PyObject *self, void *clos
(void)closure;
return Py_BuildValue("I", ((PyDapChainNetSrvObject*)self)->srv->grace_period);
}
/* callbacks stream ch */
PyObject *wrapping_dap_chain_net_srv_set_callback_channel(PyObject *self, PyObject *args){
PyObject *obj_ch_open, *obj_ch_write, *obj_ch_closed;
if (!PyArg_ParseTuple(args, "OOO", &obj_ch_open, &obj_ch_write, &obj_ch_closed))
return Py_None;
if (
!PyCallable_Check(obj_ch_open) ||
!PyCallable_Check(obj_ch_write) ||
!PyCallable_Check(obj_ch_closed)){
// TODO wrap channel callbacks
return Py_None;
}
return Py_None;
}
modules/cellframe-sdk/net/srv/src/wrapping_dap_chain_net_srv_client.c
View file @ f69ecb2c
//#include "wrapping_dap_chain_net_"
#include "wrapping_dap_chain_net_srv_client.h"
#define WRAPPING_DAP_CHAIN_NET_SRV_CLIENT(a) ((dap_chain_net_srv_client_remote_t*)((PyDapPyDapChainNetSrvClientObject*)a)->srv_client)
#define _PyDapChainNetSrvClient(a) ((PyDapChainNetSrvClient*)a)
PyObject *wrapping_dap_chain_net_srv_client_get_ch(PyObject *self, void *closure){
(void)closure;
//TODO
return Py_None;
}
PyObject *wrapping_dap_chain_net_srv_client_get_ts_created(PyObject *self, void *closure){
(void)closure;
return Py_BuildValue("k", ((PyDapChainNetSrvClientObject*)self)->srv_client->ts_created);
}
PyObject *wrapping_dap_chain_net_srv_client_get_created(PyObject *self, void *closure){
(void)closure;
PyDateTime_IMPORT;
PyObject *l_obj_long_ts = PyLong_FromDouble(((PyDapChainNetSrvClientObject*)self)->srv_client->ts_created);
PyObject *l_obj_tuple = Py_BuildValue("(O)", l_obj_long_ts);
PyObject *l_obj_dateTime = PyDateTime_FromTimestamp(l_obj_tuple);
return l_obj_dateTime;
}
PyObject *wrapping_dap_chain_net_srv_client_get_stream_worker(PyObject *self, void *closure){
(void)closure;
//TODO
return Py_None;
}
PyObject *wrapping_dap_chain_net_srv_client_get_session_id(PyObject *self, void *closure){
(void)closure;
return Py_BuildValue("i", ((PyDapChainNetSrvClientObject*)self)->srv_client->session_id);
}
PyObject *wrapping_dap_chain_net_srv_client_get_bytes_received(PyObject *self, void *closure){
(void)closure;
dap_chain_net_srv_client_remote_t *l_client = ((PyDapChainNetSrvClientObject*)self)->srv_client;
return Py_BuildValue("k", l_client->bytes_received);
}
PyObject *wrapping_dap_chain_net_srv_client_get_bytes_send(PyObject *self, void *closure){
(void)closure;
dap_chain_net_srv_client_remote_t *l_client = ((PyDapChainNetSrvClientObject*)self)->srv_client;
return Py_BuildValue("k", l_client->bytes_sent);
}
//PyObject *wrapping_dap_chain_net_srv_client_get_bytes_prev(PyObject *self, void *closure){
// (void)closure;
//}
//PyObject *wrapping_dap_chain_net_srv_client_get_bytes_next(PyObject *self, void *closure){
// (void)closure;
// PyDapChain
//}
#define LOG_TAG "wrapping_dap_chain_net_srv_client"
static void _wrapping_dap_chain_net_srv_client_callback_connected(dap_chain_net_srv_client_t* a_client, void *a_arg){
PyDapChainNetSrvClientObject *py_client = (PyDapChainNetSrvClientObject *)a_client->_inheritor;
PyObject *l_call = py_client->callback_connected;
if (PyCallable_Check(l_call)) {
PyObject *l_args = Py_BuildValue("OO", py_client, a_arg);
PyGILState_STATE state = PyGILState_Ensure();
PyEval_CallObject(l_call, l_args);
Py_DECREF(l_args);
PyGILState_Release(state);
} else {
log_it(L_ERROR, "Can't call a python handler on connected event");
}
}
static void _wrapping_dap_chain_net_srv_client_callback_disconnected(dap_chain_net_srv_client_t* a_client, void *a_arg){
UNUSED(a_client);
PyDapChainNetSrvClientObject *py_client = (PyDapChainNetSrvClientObject *)a_client->_inheritor;
PyObject *l_call = py_client->callback_disconnected;
if (PyCallable_Check(l_call)) {
PyObject *l_args = Py_BuildValue("OO", py_client, a_arg);
PyGILState_STATE state = PyGILState_Ensure();
PyEval_CallObject(l_call, l_args);
Py_DECREF(l_args);
PyGILState_Release(state);
} else {
log_it(L_ERROR, "Can't call a python handler on disconnected event");
}
}
static void _wrapping_dap_chain_net_srv_client_callback_deleted(dap_chain_net_srv_client_t* a_client, void *a_arg){
UNUSED(a_client);
PyDapChainNetSrvClientObject *py_client = (PyDapChainNetSrvClientObject *)a_client->_inheritor;
PyObject *l_call = py_client->callback_deleted;
if (PyCallable_Check(l_call)) {
PyObject *l_args = Py_BuildValue("OO", py_client, a_arg);
PyGILState_STATE state = PyGILState_Ensure();
PyEval_CallObject(l_call, l_args);
Py_DECREF(l_args);
PyGILState_Release(state);
} else {
log_it(L_ERROR, "Can't call a python handler on delete event");
}
}
static void _wrapping_dap_chain_net_srv_client_callback_check(dap_chain_net_srv_client_t *a_srv_client,
dap_stream_ch_chain_net_srv_pkt_test_t *a_pkt,
void *a_arg) {
UNUSED(a_pkt);
PyDapChainNetSrvClientObject *py_client = (PyDapChainNetSrvClientObject *)a_srv_client->_inheritor;
PyObject *l_call = py_client->callback_check;
if (PyCallable_Check(l_call)) {
PyObject *l_args = Py_BuildValue("OO", py_client, (PyObject *)a_arg);
PyGILState_STATE state = PyGILState_Ensure();
PyEval_CallObject(l_call, l_args);
Py_DECREF(l_args);
PyGILState_Release(state);
} else {
log_it(L_ERROR, "Can't call a python handler on check response event");
}
}
static dap_chain_datum_tx_receipt_t * _wrapping_dap_chain_net_srv_client_callback_sign(
dap_chain_net_srv_client_t *a_srv_client,
dap_chain_datum_tx_receipt_t *a_receipt,
void *a_arg) {
PyDapChainNetSrvClientObject *py_client = (PyDapChainNetSrvClientObject *)a_srv_client->_inheritor;
PyObject *l_call = py_client->callback_sign;
PyDapChainTXReceiptObject *py_ret = NULL;
if (PyCallable_Check(l_call)) {
PyDapChainTXReceiptObject *py_receipt = PyObject_New(PyDapChainTXReceiptObject,
&DapChainTxReceiptObject_DapChainTxReceiptTypeObjectType);
py_receipt->tx_receipt = a_receipt;
PyObject *l_args = Py_BuildValue("OOO", py_client, py_receipt, (PyObject *)a_arg);
PyGILState_STATE state = PyGILState_Ensure();
py_ret = (PyDapChainTXReceiptObject *)PyEval_CallObject(l_call, l_args);
Py_DECREF(l_args);
PyGILState_Release(state);
} else {
log_it(L_ERROR, "Can't call handler Python in callback sign");
}
if (!py_ret || (PyObject *)py_ret == Py_None || !py_ret->tx_receipt)
return NULL;
return DAP_DUP_SIZE(py_ret->tx_receipt, py_ret->tx_receipt->size);
}
static void _wrapping_dap_chain_net_srv_client_callback_success(dap_chain_net_srv_client_t *a_srv_client,
dap_stream_ch_chain_net_srv_pkt_success_t *a_pkt,
size_t a_pkt_size,
void *a_arg) {
PyDapChainNetSrvClientObject *py_client = (PyDapChainNetSrvClientObject *)a_srv_client->_inheritor;
PyObject *l_call = py_client->callback_success;
if (PyCallable_Check(l_call)) {
PyDapHashFastObject *py_cond_hash = PyObject_New(PyDapHashFastObject,
&DapHashTypeObject_DapChainHashTypeObjectType);
if (a_pkt_size == sizeof(dap_stream_ch_chain_net_srv_pkt_success_t) + sizeof(dap_chain_hash_fast_t)) {
py_cond_hash->hash_fast = DAP_NEW(dap_chain_hash_fast_t);
memcpy(py_cond_hash->hash_fast, a_pkt->custom_data, sizeof(dap_chain_hash_fast_t));
} else
py_cond_hash->hash_fast = NULL;
PyObject *l_args = Py_BuildValue("OOO", py_client, py_cond_hash, (PyObject *)a_arg);
PyGILState_STATE state = PyGILState_Ensure();
PyEval_CallObject(l_call, l_args);
Py_DECREF(l_args);
PyGILState_Release(state);
} else {
log_it(L_ERROR, "Can't call handler Python in callback success");
}
}
static void _wrapping_dap_chain_net_srv_client_callback_error(dap_chain_net_srv_client_t *a_srv_client,
int a_error_code,
void *a_arg) {
PyDapChainNetSrvClientObject *py_client = (PyDapChainNetSrvClientObject *)a_srv_client->_inheritor;
PyObject *l_call = py_client->callback_error;
if (PyCallable_Check(l_call)) {
PyObject *l_args = Py_BuildValue("OiO", py_client, a_error_code, (PyObject *)a_arg);
PyGILState_STATE state = PyGILState_Ensure();
PyEval_CallObject(l_call, l_args);
Py_DECREF(l_args);
PyGILState_Release(state);
} else {
log_it(L_ERROR, "Can't call handler Python in callback error");
}
}
static void _wrapping_dap_chain_net_srv_client_callback_data(dap_chain_net_srv_client_t *a_srv_client,
uint8_t *a_data,
size_t a_data_size,
void *a_arg) {
PyDapChainNetSrvClientObject *py_client = (PyDapChainNetSrvClientObject *)a_srv_client->_inheritor;
PyObject *l_call = py_client->callback_data;
if (PyCallable_Check(l_call)) {
PyObject *l_data = PyBytes_FromStringAndSize((char *)a_data, a_data_size);
PyObject *l_args = Py_BuildValue("OOO", py_client, l_data, (PyObject *)a_arg);
PyGILState_STATE state = PyGILState_Ensure();
PyEval_CallObject(l_call, l_args);
Py_DECREF(l_args);
PyGILState_Release(state);
} else {
log_it(L_ERROR, "Can't call handler Python in callback data");
}
}
int PyDapChainNetSrvClient_init(PyDapChainNetSrvClientObject* self, PyObject *args, PyObject *kwds) {
const char *kwlist[] = {
"net",
"addr",
"port",
"callback_connected",
"callback_disconnected",
"callback_deleted",
"callback_check",
"callback_sign",
"callback_success",
"callback_error",
"callback_data",
"callback_arg",
NULL
};
PyDapChainNetObject *py_net;
PyObject *py_cb_conn, *py_cb_disc, *py_cb_del, *py_cb_check, *py_cb_sign;
PyObject *py_cb_success, *py_cb_error, *py_cb_data, *py_cb_arg;
const char *addr;
uint16_t port;
if (!PyArg_ParseTupleAndKeywords(
args, kwds, "OsHOOOOOOOOO", (char **)kwlist,
&py_net, &addr, &port, &py_cb_conn,
&py_cb_disc, &py_cb_del, &py_cb_check,
&py_cb_sign, &py_cb_success, &py_cb_error,
&py_cb_data, &py_cb_arg
)){
return -1;
}
if (!PyDapChainNet_Check(py_net))
return -2;
if (!PyCallable_Check(py_cb_conn) ||
!PyCallable_Check(py_cb_disc) ||
!PyCallable_Check(py_cb_del) ||
!PyCallable_Check(py_cb_check) ||
!PyCallable_Check(py_cb_sign) ||
!PyCallable_Check(py_cb_success) ||
!PyCallable_Check(py_cb_error) ||
!PyCallable_Check(py_cb_data)) {
return -3;
}
dap_chain_net_srv_client_callbacks_t callbacks = {0};
callbacks.connected = _wrapping_dap_chain_net_srv_client_callback_connected;
callbacks.disconnected = _wrapping_dap_chain_net_srv_client_callback_disconnected;
callbacks.deleted = _wrapping_dap_chain_net_srv_client_callback_deleted;
callbacks.check = _wrapping_dap_chain_net_srv_client_callback_check;
callbacks.sign = _wrapping_dap_chain_net_srv_client_callback_sign;
callbacks.success = _wrapping_dap_chain_net_srv_client_callback_success;
callbacks.error = _wrapping_dap_chain_net_srv_client_callback_error;
callbacks.data = _wrapping_dap_chain_net_srv_client_callback_data;
dap_chain_net_srv_client_t *l_client =
dap_chain_net_srv_client_create_n_connect(py_net->chain_net,
(char *)addr, port, &callbacks, py_cb_arg);
self->srv_client = l_client;
self->callback_connected = py_cb_conn;
self->callback_disconnected = py_cb_disc;
self->callback_deleted = py_cb_del;
self->callback_check = py_cb_check;
self->callback_sign = py_cb_sign;
self->callback_success = py_cb_success;
self->callback_error = py_cb_error;
self->callback_data = py_cb_data;
Py_INCREF(self);
l_client->_inheritor = self;
return 0;
}
PyObject *wrapping_dap_chain_net_srv_client_check(PyObject *self, PyObject *args) {
PyDapChainNetIdObject *obj_net_id;
PyDapChainNetSrvUIDObject *obj_srv_uid;
PyObject *obj_bytes;
if (!PyArg_ParseTuple(args, "OOO", &obj_net_id, &obj_srv_uid, &obj_bytes)) {
return Py_None;
}
if (!PyDapChainNetSrvUid_Check(obj_srv_uid))
return Py_None;
if (PyObject_TypeCheck(obj_net_id, &DapChainNetIdObject_DapChainNetIdObjectType))
return Py_None;
if (!PyBytes_Check(obj_bytes)) {
return Py_None;
}
//Generate packet
size_t l_bytes_size = PyBytes_Size(obj_bytes);
void *l_bytes = PyBytes_AsString(obj_bytes);
size_t l_request_size = sizeof(dap_stream_ch_chain_net_srv_pkt_test_t) + l_bytes_size;
dap_stream_ch_chain_net_srv_pkt_test_t *l_request = DAP_NEW_S_SIZE(dap_stream_ch_chain_net_srv_pkt_test_t,
l_request_size);
memset(l_request, 0, sizeof(dap_stream_ch_chain_net_srv_pkt_test_t));
l_request->net_id.uint64 = obj_net_id->net_id.uint64;
l_request->srv_uid.uint64 = obj_srv_uid->net_srv_uid.uint64;
l_request->data_size_send = l_request->data_size_recv = l_bytes_size;
l_request->data_size = l_bytes_size;
gettimeofday(&l_request->send_time1, NULL);
memcpy(l_request->data, l_bytes, l_bytes_size);
dap_hash_fast(l_request->data, l_request->data_size, &l_request->data_hash);
ssize_t l_res = dap_chain_net_srv_client_write(
((PyDapChainNetSrvClientObject*)self)->srv_client,
DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_CHECK_REQUEST,
l_request, l_request_size);
return Py_BuildValue("L", l_res);
}
PyObject *wrapping_dap_chain_net_srv_client_request(PyObject *self, PyObject *args) {
PyDapChainNetObject *obj_net;
PyDapChainNetSrvUIDObject *obj_srv_uid;
PyDapHashFastObject *obj_tx_cond_hash;
if (!PyArg_ParseTuple(args, "OOO", &obj_net, &obj_srv_uid, &obj_tx_cond_hash))
return Py_None;
if (!PyDapChainNetSrvUid_Check(obj_srv_uid))
return Py_None;
if (!PyDapChainNet_Check(obj_net))
return Py_None;
if (!PyDapHashFast_Check(obj_tx_cond_hash)) {
return Py_None;
}
//Generate packet
dap_stream_ch_chain_net_srv_pkt_request_hdr_t l_hdr = {};
l_hdr.net_id = obj_net->chain_net->pub.id;
l_hdr.srv_uid = obj_srv_uid->net_srv_uid;
memcpy(&l_hdr.tx_cond, obj_tx_cond_hash->hash_fast, sizeof(dap_chain_hash_fast_t));
ssize_t l_res = dap_chain_net_srv_client_write(
((PyDapChainNetSrvClientObject*)self)->srv_client,
DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_REQUEST,
&l_hdr, sizeof(l_hdr));
return Py_BuildValue("L", l_res);
}
PyObject *wrapping_dap_chain_net_srv_client_write(PyObject *self, PyObject *args) {
PyDapChainNetSrvUIDObject *obj_srv_uid;
PyObject *obj_bytes;
if (!PyArg_ParseTuple(args, "OO", &obj_srv_uid, &obj_bytes)) {
return Py_None;
}
if (!PyDapChainNetSrvUid_Check(obj_srv_uid)) {
return Py_None;
}
if (!PyBytes_Check(obj_bytes)) {
return Py_None;
}
//Generate packet
size_t l_bytes_size = PyBytes_Size(obj_bytes);
void *l_bytes = PyBytes_AsString(obj_bytes);
dap_stream_ch_chain_net_srv_pkt_data_t *l_data = DAP_NEW_S_SIZE(void,
sizeof(dap_stream_ch_chain_net_srv_pkt_data_t) + l_bytes_size);
l_data->hdr.version = 1;
l_data->hdr.data_size = (uint16_t)l_bytes_size;
l_data->hdr.usage_id = 0;
l_data->hdr.srv_uid = obj_srv_uid->net_srv_uid;
memcpy(l_data->data, l_bytes, l_bytes_size);
ssize_t l_res = dap_chain_net_srv_client_write(
((PyDapChainNetSrvClientObject*)self)->srv_client,
DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_DATA,
l_data, sizeof(*l_data) + l_bytes_size);
return Py_BuildValue("L", l_res);
}
modules/cellframe-sdk/net/srv/src/wrapping_dap_chain_net_srv_client_remote.c 0 → 100644
View file @ f69ecb2c
//#include "wrapping_dap_chain_net_"
#include "wrapping_dap_chain_net_srv_client_remote.h"
#define WRAPPING_DAP_CHAIN_NET_SRV_CLIENT(a) ((dap_chain_net_srv_client_remote_t*)((PyDapPyDapChainNetSrvClientObject*)a)->srv_client)
#define _PyDapChainNetSrvClient(a) ((PyDapChainNetSrvClient*)a)
PyObject *wrapping_dap_chain_net_srv_client_remote_get_ch(PyObject *self, void *closure){
(void)closure;
//TODO
return Py_None;
}
PyObject *wrapping_dap_chain_net_srv_client_remote_get_ts_created(PyObject *self, void *closure){
(void)closure;
return Py_BuildValue("k", ((PyDapChainNetSrvClientRemoteObject*)self)->srv_client_remote->ts_created);
}
PyObject *wrapping_dap_chain_net_srv_client_remote_get_created(PyObject *self, void *closure){
(void)closure;
PyDateTime_IMPORT;
PyObject *l_obj_long_ts = PyLong_FromDouble(((PyDapChainNetSrvClientRemoteObject*)self)->srv_client_remote->ts_created);
PyObject *l_obj_tuple = Py_BuildValue("(O)", l_obj_long_ts);
PyObject *l_obj_dateTime = PyDateTime_FromTimestamp(l_obj_tuple);
return l_obj_dateTime;
}
PyObject *wrapping_dap_chain_net_srv_client_remote_get_stream_worker(PyObject *self, void *closure){
(void)closure;
//TODO
return Py_None;
}
PyObject *wrapping_dap_chain_net_srv_client_remote_get_session_id(PyObject *self, void *closure){
(void)closure;
return Py_BuildValue("i", ((PyDapChainNetSrvClientRemoteObject*)self)->srv_client_remote->session_id);
}
PyObject *wrapping_dap_chain_net_srv_client_remote_get_bytes_received(PyObject *self, void *closure){
(void)closure;
dap_chain_net_srv_client_remote_t *l_client = ((PyDapChainNetSrvClientRemoteObject*)self)->srv_client_remote;
return Py_BuildValue("k", l_client->bytes_received);
}
PyObject *wrapping_dap_chain_net_srv_client_remote_get_bytes_send(PyObject *self, void *closure){
(void)closure;
dap_chain_net_srv_client_remote_t *l_client = ((PyDapChainNetSrvClientRemoteObject*)self)->srv_client_remote;
return Py_BuildValue("k", l_client->bytes_sent);
}
//PyObject *wrapping_dap_chain_net_srv_client_remote_get_bytes_prev(PyObject *self, void *closure){
// (void)closure;
//}
//PyObject *wrapping_dap_chain_net_srv_client_remote_get_bytes_next(PyObject *self, void *closure){
// (void)closure;
// PyDapChain
//}
modules/cellframe-sdk/services/datum/CMakeLists.txt 0 → 100644
View file @ f69ecb2c
project(dap_chain_service_datum_python C)
cmake_minimum_required(VERSION 3.0)
set(CMAKE_VERBOSE_MAKEFILE ON)
set(CMAKE_COLOR_MAKEFILE ON)
set(CMAKE_C_STANDARD 11)
add_definitions("-fpic")
if(UNIX)
add_definitions("-DDAP_OS_UNIX")
endif()
if(NOT (${SUBMODULES_NO_BUILD} MATCHES ON))
set (SUBMODULES_NO_BUILD ON)
if (NOT (TARGET dap_core))
add_subdirectory(libdap)
target_compile_options(
dap_core PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_crypto))
add_subdirectory(libdap-crypto)
target_compile_options(
dap_crypto PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_chain))
add_subdirectory(libdap-chain)
target_compile_options(
dap_chain PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_chain_crypto))
add_subdirectory(libdap-chain-crypto)
target_compile_options(
dap_chain_crypto PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_chain_mempool))
add_subdirectory(libdap-chain-mempool)
target_compile_options(
dap_chain_mempool PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_chain_net))
add_subdirectory(libdap-chain-net)
target_compile_options(
dap_chain_net PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_server_core))
add_subdirectory(libdap-server-core)
target_compile_options(
dap_server_core PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_chain_global_db))
add_subdirectory(libdap-chain-global-db)
target_compile_options(
dap_chain_global_db PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_client))
add_subdirectory(libdap-client)
target_compile_options(
dap_client PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET libdap-server))
add_subdirectory(libdap-server)
# target_compile_options(
# libdap-server PRIVATE
# "-fpic"
# )
endif()
if (NOT (TARGET dap_stream))
add_subdirectory(libdap-stream)
target_compile_options(
dap_stream PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_stream_ch))
add_subdirectory(libdap-stream-ch)
target_compile_options(
dap_stream_ch PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_stream_ch_chain))
add_subdirectory(libdap-stream-ch-chain)
target_compile_options(
dap_stream_ch_chain PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_stream_ch_chain_net))
add_subdirectory(libdap-stream-ch-chain-net)
target_compile_options(
dap_stream_ch_chain_net PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_udp_server))
add_subdirectory(libdap-server-udp)
target_compile_options(
dap_udp_server PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_chain_net_srv))
add_subdirectory(libdap-chain-net-srv)
target_compile_options(
dap_chain_net_srv PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_chain_wallet))
add_subdirectory(libdap-chain-wallet)
target_compile_options(
dap_chain_wallet PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_chain_gdb))
add_subdirectory(libdap-chain-gdb)
target_compile_options(
dap_chain_gdb PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_python_module))
add_subdirectory(libdap-python)
target_compile_options(
dap_python_module PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_crypto_python_module))
add_subdirectory(libdap-crypto-python)
target_compile_options(
dap_crypto_python_module PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_chain_net_srv_vpn))
add_subdirectory(libdap-chain-net-srv-vpn)
target_compile_options(
dap_chain_net_srv_vpn PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_chain_python_module))
add_subdirectory(libdap-chain-python)
target_compile_options(
dap_chain_python_module PRIVATE
"-fpic"
)
endif()
if (NOT (TARGET dap_client_python_module))
add_subdirectory(libdap-client-python)
target_compile_options(
dap_client_python_module PRIVATE
"-fpic"
)
endif()
endif()
#add_definitions("-DDAP_APP_NAME=\"TestPRJ\" -DSYSTEM_CONFIGS_DIR=\"${CMAKE_CURRENT_BINARY_DIR}\"")
file(GLOB CHAIN_NET_PYTHON_SRCS src/*.c)
file(GLOB CHAIN_NET_PYTHON_HEADERS include/*.h)
set(Python_ADDITIONAL_VERSIONS 3.7 3.6 3.5 3.4)
find_package (PythonLibs REQUIRED)
include_directories(${PYTHON_INCLUDE_DIR} include/)
add_library(${PROJECT_NAME} STATIC ${CHAIN_NET_PYTHON_SRCS} ${CHAIN_NET_PYTHON_HEADERS})
target_link_libraries(${PROJECT_NAME})
target_link_libraries(${PROJECT_NAME} dap_core dap_crypto dap_chain dap_server_core dap_chain_net dap_chain_net_srv_datum dap_chain_python_module dap_client_python_module)
target_include_directories(${PROJECT_NAME} PUBLIC include/ )
modules/cellframe-sdk/services/datum/include/wrapping_dap_chain_net_srv_datum.h 0 → 100644
View file @ f69ecb2c
#pragma once
#include "Python.h"
#include "dap_chain_net_srv_datum.h"
#include "libdap-chain-python.h"
typedef struct PyDapChainNetSrvDatum{
PyObject_HEAD
}PyDapChainNetSrvDatumObject;
PyObject *wrapping_dap_chain_net_srv_datum_create(PyObject *self, PyObject *args);
PyObject *wrapping_dap_chain_net_srv_datum_read(PyObject *self, PyObject *args);
static PyMethodDef DapChainNetSrvDatum_method[] = {
{"create", (PyCFunction) wrapping_dap_chain_net_srv_datum_create, METH_VARARGS | METH_STATIC, ""},
{"read", (PyCFunction) wrapping_dap_chain_net_srv_datum_read, METH_VARARGS|METH_STATIC, ""},
{NULL, NULL, 0, NULL}
};
static PyTypeObject DapChainNetSrvDatumObject_DapChainNetSrvDatumObjectType = {
PyVarObject_HEAD_INIT(NULL, 0)
"CellFrame.ChainNetSrvDatum", /* tp_name */
sizeof(PyDapChainNetSrvDatumObject), /* tp_basicsize */
0, /* tp_itemsize */
0, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
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 */
"Chain net srv datum object", /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
DapChainNetSrvDatum_method, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
PyType_GenericNew, /* tp_new */
};
modules/cellframe-sdk/services/datum/src/wrapping_dap_chain_net_srv_datum.c 0 → 100644
View file @ f69ecb2c
#include "wrapping_dap_chain_net_srv_datum.h"
PyObject *wrapping_dap_chain_net_srv_datum_read(PyObject *self, PyObject *args){
(void)self;
char *str_path;
if (!PyArg_ParseTuple(args, "s", &str_path)){
return NULL;
}
size_t l_size_data = 0;
void* l_data = dap_chain_net_srv_file_datum_data_read(str_path, &l_size_data);
PyObject *obj_bytes = PyBytes_FromStringAndSize(l_data, l_size_data);
return obj_bytes;
}
PyObject *wrapping_dap_chain_net_srv_datum_create(PyObject *self, PyObject *args){
(void)self;
PyObject *obj_chain;
PyObject *obj_data_in_datum;
if (!PyArg_ParseTuple(args, "OO", &obj_chain, &obj_data_in_datum)){
return NULL;
}
if (!PyBytes_Check(obj_data_in_datum)){
PyErr_SetString(PyExc_ValueError, "This function takes an object of type bytes as its second argument.");
return NULL;
}
if (!PyDapChain_Check(obj_chain)){
PyErr_SetString(PyExc_ValueError, "The first argument to this function must be an object of type Chain.");
return NULL;
}
void *l_data = PyBytes_AsString(obj_data_in_datum);
size_t l_data_size = PyBytes_Size(obj_data_in_datum);
char* res = dap_chain_net_srv_datum_custom_add(((PyDapChainObject*)obj_chain)->chain_t, l_data, l_data_size);
if (res == NULL)
return Py_None;
return Py_BuildValue("s", res);
}
modules/dap-sdk/crypto/include/wrapping_dap_hash.h
View file @ f69ecb2c
......@@ -156,6 +156,11 @@ static PyTypeObject DapHashFastObject_DapHashFastObjectType = {
PyType_GenericNew, /* tp_new */
};
static bool PyDapHashFast_Check(PyDapHashFastObject *pyHash)
{
return !PyObject_TypeCheck(pyHash, &DapHashFastObject_DapHashFastObjectType);
}
#ifdef __cplusplus
}
#endif