pyxcp 0.21.9__cp311-cp311-win_amd64.whl → 0.22.23__cp311-cp311-win_amd64.whl

pyxcp/cxx/iasyncioservice.hpp

@@ -1,31 +0,0 @@
-/*
- *
- * Interface for asynchronous I/O services (IOCP, epoll, kqueue...).
- *
- *
- */
-
-#if !defined(__IASYNCHIOSERVICE_HPP)
-#define __IASYNCHIOSERVICE_HPP
-
-#include <cstdlib>
-#include <cstdint>
-
-#include "socket.hpp"
-
-enum class MessageCode : uint64_t {
-    QUIT,
-    TIMEOUT
-};
-
-class IAsyncIoService {
-public:
-    virtual ~IAsyncIoService() = default;
-    virtual void registerSocket(Socket& socket) = 0;
-    virtual void postUserMessage(MessageCode messageCode, void * data = nullptr) const = 0;
-    virtual void postQuitMessage() const = 0;
-    virtual HANDLE getHandle() const = 0;
-
-};
-
-#endif // __IASYNCHIOSERVICE_HPP

pyxcp/cxx/iresource.hpp

@@ -1,17 +0,0 @@
-#if !defined(__IRESOURCE_HPP)
-#define __IRESOURCE_HPP
-
-/*
- *
- * Interface for pool-able resources.
- *
- */
-class IResource {
-public:
-
-    virtual ~IResource() = default;
-    virtual void reset() = 0;
-
-};
-
-#endif // __IRESOURCE_HPP

pyxcp/cxx/isocket.hpp

@@ -1,22 +0,0 @@
-#if !defined(__ISOCKET_HPP)
-#define __ISOCKET_HPP
-
-struct CAddress {
-    int length;
-    struct sockaddr address;
-};
-
-
-class ISocket {
-public:
-    ~ISocket() = default;
-
-    virtual void connect(CAddress & address) = 0;
-    virtual void bind(CAddress & address) = 0;
-    virtual void listen(int backlog = 10) = 0;
-    virtual void accept(CAddress & peerAddress) = 0;
-    virtual void option(int optname, int level, int * value) = 0;
-    virtual bool getaddrinfo(int family, int socktype, int protocol, const char * hostname, int port, CAddress & address, int flags = AI_PASSIVE) = 0;
-};
-
-#endif  // __ISOCKET_HPP

pyxcp/cxx/linux/epoll.cpp

@@ -1,51 +0,0 @@
-#include "epoll.hpp"
-
-constexpr size_t MAX_EVENTS = 8;
-
-static struct epoll_event events[MAX_EVENTS];
-
-void * WorkerThread(void * param)
-{
-    Epoll const * const epoll = reinterpret_cast<Epoll const * const>(param);
-    Socket const * socket;
-    TimeoutTimer const * timeout_timer;
-    EventRecord * event_record;
-    int nfds;
-    int idx;
-    char buffer[128];
-    int evt_mask;
-    uint64_t timeout_value;
-
-    printf("Entering worker thread...\n");
-
-    for (;;) {
-        nfds = epoll_wait(epoll->getHandle() ,events, MAX_EVENTS, 500);
-        for (idx = 0; idx < nfds; ++idx) {
-            evt_mask = events[idx].events;
-            event_record = reinterpret_cast<EventRecord*>(events[idx].data.ptr);
-            printf("Evt#%d: %x %d\n", idx, evt_mask, event_record->event_type);
-            if (event_record->event_type == EventType::SOCKET) {
-                socket = event_record->obj.socket;
-                printf("Socket-Handle: %d\n", socket->getHandle());
-                if (evt_mask & EPOLLIN) {
-                    read(socket->getHandle(), buffer, 128);
-                    printf("R: %s\n", buffer);
-                } else if (evt_mask & EPOLLHUP) {
-                    printf("HANG-UP\n");
-                    //SocketErrorExit("HANG-UP");
-                } else if (evt_mask & EPOLLERR) {
-                    SocketErrorExit("WorkerThread::epoll_wait()");
-                }
-            } else if (event_record->event_type == EventType::TIMEOUT) {
-                timeout_timer = event_record->obj.timeout_timer;
-                printf("Timeout-Handle: %d\n", timeout_timer->getHandle());
-                read(timeout_timer->getHandle(), &timeout_value, sizeof(uint64_t));
-                printf("Timeout\n");
-            } else {
-                printf("Invalid event type.\n");
-            }
-        }
-    }
-
-    return nullptr;
-}

pyxcp/cxx/linux/epoll.hpp

@@ -1,87 +0,0 @@
-#if !defined(__EPOLL_HPP)
-#define __EPOLL_HPP
-
-#include <memory>
-#include <vector>
-
-#include <unistd.h>
-#include <pthread.h>
-#include <sys/epoll.h>
-
-#include "socket.hpp"
-#include "iasyncioservice.hpp"
-
-void *  WorkerThread(void * param);
-
-enum class EventType {
-    SOCKET,
-    TIMEOUT
-};
-
-struct EventRecord {
-    EventType event_type;
-    union {
-        Socket const * socket;
-        TimeoutTimer const * timeout_timer;
-    } obj;
-};
-
-class Epoll : public IAsyncIoService {
-public:
-    Epoll(size_t numProcessors = 1, size_t multiplier = 1) {
-        int ret;
-
-        m_epoll_fd = ::epoll_create(42);
-        ret = pthread_create(&m_worker_thread, nullptr, &WorkerThread, reinterpret_cast<void*>(this));
-        if (ret != 0) {
-            OsErrorExit("Epoll:Epoll() -- Create worker thread");
-        }
-    }
-
-    ~Epoll() {
-        ::close(m_epoll_fd);
-    }
-
-    void registerSocket(Socket& socket) {
-
-        registerHandle(socket.getHandle(), reinterpret_cast<void const*>(&socket), EventType::SOCKET);
-        registerHandle(socket.getTimeout().getHandle(), reinterpret_cast<void const*>(&socket.getTimeout()), EventType::TIMEOUT);
-        printf("S: %d T: %d\n", socket.getHandle(), socket.getTimeout().getHandle());
-    }
-
-    void postUserMessage(MessageCode messageCode, void * data = nullptr) const {}
-    void postQuitMessage() const {}
-
-    HANDLE getHandle() const {
-        return m_epoll_fd;
-    }
-
-protected:
-
-    void registerHandle(HANDLE handle, void const * data_ptr, EventType event_type) {
-
-        struct epoll_event event;
-        auto event_record = std::make_shared<EventRecord>();
-        m_events.emplace_back(event_record);
-
-        event_record->event_type = event_type;
-        if (event_type == EventType::SOCKET) {
-            event_record->obj.socket = reinterpret_cast<Socket const*>(data_ptr);
-        } else if (event_type == EventType::TIMEOUT) {
-            event_record->obj.timeout_timer = static_cast<TimeoutTimer const*>(data_ptr);
-        }
-        event.data.ptr = event_record.get();
-        event.events = EPOLLIN;
-        if (::epoll_ctl(m_epoll_fd, EPOLL_CTL_ADD, handle, &event) == -1) {
-            OsErrorExit("Epoll::registerHandle()");
-        }
-    }
-
-private:
-    int m_epoll_fd;
-    pthread_t m_worker_thread;
-    std::vector<std::shared_ptr<EventRecord>> m_events;
-};
-
-
-#endif // __EPOLL_HPP

pyxcp/cxx/linux/lit_tester.cpp

@@ -1,19 +0,0 @@
-
-#include <iostream>
-#include <chrono>
-
-#include <cstdint>
-
-using namespace std::literals;
-using namespace std;
-
-
-int main()
-{
-//    cout << static_cast<unsignedI>(23ms) << endl;
-    auto d1 = 250ns;
-
-    std::chrono::nanoseconds d2 = 1us;
-    std::cout << "250ns = " << d1.count() << " nanoseconds\n" << "1us = " << d2.count() << " nanoseconds\n";
-
-}

pyxcp/cxx/linux/socket.hpp

@@ -1,234 +0,0 @@
-#if !defined(__SOCKET_HPP)
-#define __SOCKET_HPP
-
-#include <array>
-#include <ctype.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <signal.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <time.h>
-#include <stdbool.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netdb.h>
-#include <arpa/inet.h>
-#include <sys/wait.h>
-
-#include "isocket.hpp"
-#include "utils.hpp"
-#include "timeout.hpp"
-
-#define SOCKET_ERROR (-1)
-#define INVALID_SOCKET (-1)
-
-using HANDLE = int;
-using SOCKET = int;
-
-class Socket : public ISocket {
-public:
-
-    Socket(int family = PF_INET, int socktype = SOCK_STREAM, int protocol = IPPROTO_TCP) :
-        m_family(family), m_socktype(socktype), m_protocol(protocol), m_connected(false),
-        m_addr(nullptr), m_timeout(150) {
-        m_socket = ::socket(m_family, m_socktype, m_protocol);
-        if (m_socket == INVALID_SOCKET) {
-            SocketErrorExit("Socket::Socket()");
-        }
-        blocking(false);
-        ZeroOut(&m_peerAddress, sizeof(sockaddr_storage));
-    }
-
-    ~Socket() {
-        ::close(m_socket);
-    }
-
-    void blocking(bool enabled) {
-        int flags = fcntl(m_socket, F_GETFL);
-
-        if (flags == -1) {
-            SocketErrorExit("Socket::blocking()");
-        }
-        flags = enabled ? (flags & ~O_NONBLOCK) : (flags | O_NONBLOCK);
-        if (fcntl(m_socket, F_SETFL, flags) == -1) {
-            SocketErrorExit("Socket::blocking()");
-        }
-    }
-
-    void option(int optname, int level, int * value) {
-        socklen_t len;
-
-        len = sizeof(*value);
-        if (*value == 0) {
-            ::getsockopt(m_socket, level, optname, (char*) value, &len);
-        } else {
-            ::setsockopt(m_socket, level, optname, (const char*) value, len);
-        }
-    }
-
-    bool getaddrinfo(int family, int socktype, int protocol, const char * hostname, int port, CAddress & address, int flags = AI_PASSIVE) {
-        int err;
-        addrinfo hints;
-        addrinfo * t_addr;
-        char port_str[16] = {0};
-
-        ZeroOut(&hints, sizeof(hints));
-        hints.ai_family = family;
-        hints.ai_socktype = socktype;
-        hints.ai_protocol = protocol;
-        hints.ai_flags = flags;
-
-        ::sprintf(port_str, "%d", port);
-        err = ::getaddrinfo(hostname, port_str, &hints, &t_addr);
-        if (err != 0) {
-            printf("%s\n", gai_strerror(err));
-            ::freeaddrinfo(t_addr);
-            SocketErrorExit("getaddrinfo()");
-            return false;
-        }
-
-        address.length = t_addr->ai_addrlen;
-        ::memcpy(&address.address, t_addr->ai_addr, sizeof(struct sockaddr));
-
-        ::freeaddrinfo(t_addr);
-        return true;
-    }
-
-    void connect(CAddress & address) {
-        blocking(true);
-        if (::connect(m_socket, &address.address, address.length) == SOCKET_ERROR) {
-            if (errno != EINPROGRESS) {
-                SocketErrorExit("Socket::connect()");
-            }
-        }
-        blocking(false);
-    }
-
-    void bind(CAddress & address) {
-        if (::bind(m_socket, &address.address, address.length) == SOCKET_ERROR) {
-            SocketErrorExit("Socket::bind()");
-        }
-    }
-
-    void listen(int backlog = 5) {
-        if (::listen(m_socket, backlog) == SOCKET_ERROR) {
-            SocketErrorExit("Socket::listen()");
-        }
-    }
-
-    void accept(CAddress & peerAddress) {
-        int sock;
-
-        peerAddress.length = sizeof peerAddress.address;
-        sock = ::accept(m_socket, (sockaddr *)&peerAddress.address, (socklen_t*)&peerAddress.length);
-
-        if (sock  == INVALID_SOCKET) {
-            SocketErrorExit("Socket::accept()");
-        }
-    }
-
-    template <typename T, size_t N>
-    void write(std::array<T, N>& arr, bool alloc = true) {
-        size_t bytesWritten = 0;
-        int addrLen;
-
-        m_timeout.arm();
-
-        if (m_socktype == SOCK_DGRAM) {
-#if 0
-            if (sendto(m_socket, (char const *)arr.data(), arr.size(), 0, (struct sockaddr const *)&XcpTl_Connection.connectionAddress, addrSize) == -1) {
-                SocketErrorExit("Socket::write() -- sendto()");
-            }
-#endif
-        } else if (m_socktype == SOCK_STREAM) {
-            if (send(m_socket, (char const *)arr.data(), arr.size(), 0) == -1) {
-                SocketErrorExit("Socket::write() -- send()");
-            }
-        }
-#if 0
-        //PerIoData * iod = new PerIoData(128);
-        PerIoData * iod;
-
-        if (alloc == true) {
-            iod = m_pool_mgr.get_iod().acquire();
-            //iod = m_iod_pool.acquire();
-        }
-        iod->reset();
-        iod->set_buffer(arr);
-        iod->set_opcode(IoType::IO_WRITE);
-        iod->set_transfer_length(arr.size());
-        if (m_socktype == SOCK_DGRAM) {
-            addrLen = sizeof(SOCKADDR_STORAGE);
-            if (::WSASendTo(m_socket,
-                iod->get_buffer(),
-                1,
-                &bytesWritten,
-                0,
-                (LPSOCKADDR)&m_peerAddress,
-                addrLen,
-                (LPWSAOVERLAPPED)iod,
-                nullptr
-            ) == SOCKET_ERROR) {
-                // WSA_IO_PENDING
-                SocketErrorExit("Socket::send()");
-            }
-        } else if (m_socktype == SOCK_STREAM) {
-            if (::WSASend(
-                m_socket,
-                iod->get_buffer(),
-                1,
-                &bytesWritten,
-                0,
-                (LPWSAOVERLAPPED)iod,
-                nullptr) == SOCKET_ERROR) {
-                    SocketErrorExit("Socket::send()");
-                closesocket(m_socket);
-            }
-        }
-#endif
-        printf("Status: %d bytes_written: %d\n", errno, bytesWritten);
-    }
-#if 0
-    void read(size_t count) {
-    if ( (n = read(sockfd, line, MAXLINE)) < 0) {
-        if (errno == ECONNRESET) {
-            close(sockfd);
-            events[i].data.fd = -1;
-    } else printf("readline error\n");
-                                                                                                                                } else if (n == 0) {
-                                                                                                                                                        close(sockfd);
-                                                                                                                                                                            events[i].data.fd = -1;
-                                                                                                                                                                                            }
-
-    }
-#endif
-
-    void triggerRead(unsigned int len);
-
-    HANDLE getHandle() const {
-        return m_socket;
-    }
-
-    const TimeoutTimer& getTimeout() const {
-        return m_timeout;
-    }
-
-private:
-    int m_family;
-    int m_socktype;
-    int m_protocol;
-    bool m_connected;
-//    PoolManager m_pool_mgr;
-    addrinfo * m_addr;
-    TimeoutTimer m_timeout {150};
-    int m_socket;
-    //CAddress ourAddress;
-    sockaddr_storage m_peerAddress;
-};
-
-#endif  // __SOCKET_HPP

pyxcp/cxx/linux/timeout.hpp

@@ -1,81 +0,0 @@
-
-#if !defined(__TIMEOUT_HPP)
-#define __TIMEOUT_HPP
-
-#include <sys/timerfd.h>
-#include <time.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdint.h>
-
-#include "utils.hpp"
-
-#include <chrono>
-
-using namespace std::literals;
-
-/*
- *
- * Implements a file descriptor based time-out.
- *
- * Resolution is milli-seconds.
- *
- * Could be used together with poll(), epoll(), or select().
- *
- */
-
-class TimeoutTimer {
-public:
-
-    explicit TimeoutTimer(uint64_t value) : m_millis(value), m_timer_fd(-1) {
-        m_timer_fd = ::timerfd_create(CLOCK_MONOTONIC, 0);
-        if (m_timer_fd == -1)
-            OsErrorExit("TimeoutTimer::TimeoutTimer() -- timerfd_create");
-        }
-
-    ~TimeoutTimer() {
-        ::close(m_timer_fd);
-    }
-
-    void arm() {
-        struct itimerspec new_value {0};
-
-        new_value.it_interval = {0};
-        new_value.it_value.tv_sec = m_millis / 1000;
-        new_value.it_value.tv_nsec = (m_millis % 1000) * (1000 * 1000);
-
-        settime(new_value);
-    }
-
-    void disarm() {
-        struct itimerspec new_value {0};
-
-        settime(new_value);
-    }
-
-    int getHandle() const {
-        return m_timer_fd;
-    }
-
-    uint64_t getValue() const {
-        return m_millis;
-    }
-
-    void setValue(uint64_t new_millis) {
-        m_millis = new_millis;
-    }
-
-private:
-
-    void settime(const itimerspec& new_value) {
-        if (::timerfd_settime(m_timer_fd, 0, &new_value, nullptr) == -1) {
-            OsErrorExit("TimeoutTimer::disarm() -- timerfd_settime");
-        }
-    }
-
-    uint64_t m_millis;
-    int m_timer_fd;
-};
-
-#endif // __TIMEOUT_HPP

pyxcp/cxx/memoryblock.hpp

@@ -1,42 +0,0 @@
-#if !defined(__MEMORYBLOCK_HPP)
-#define __MEMORYBLOCK_HPP
-
-#include "iresource.hpp"
-
-/*
- *
- * Fixed size memory block.
- *
- */
-template <typename T, int N> class MemoryBlock : IResource {
-
-public:
-
-    explicit MemoryBlock() : m_memory(nullptr) {
-        m_memory = new T[N];
-        //printf("MemBlock-ctor: %p\n", m_memory);
-    }
-
-    ~MemoryBlock() {
-        //printf("MemoryBlock-dtor: %p\n", m_memory);
-        if (m_memory) {
-            delete[] m_memory;
-        }
-    }
-
-    T * data() {
-        return m_memory;
-    }
-
-    void reset() {
-    #if !defined(NDEBUG)
-
-    #endif
-    }
-
-private:
-    T * m_memory;
-
-};
-
-#endif // __MEMORYBLOCK_HPP

pyxcp/cxx/pool.hpp

@@ -1,81 +0,0 @@
-#if !defined(__POOL_H)
-#define __POOL_H
-
-#include <algorithm>
-#include <list>
-#include <deque>
-#include <mutex>
-#include <thread>
-
-#include "exceptions.hpp"
-
-
-/*
- *
- * Fixed-size generic resource pool.
- *
- */
-
-template <typename Obj> void dump(std::deque<Obj>& list) {
-
-    for (auto elem: list) {
-        printf("%p ", elem);
-    }
-    printf("\n");
-}
-
-template<typename Obj, int N> class Pool {
-public:
-
-    explicit Pool() : m_mtx(), m_high_water_mark(N), m_allocation_count(0) {
-        for (size_t i = 0; i < N; ++i) {
-            m_free_objs.push_back(new Obj());
-        }
-    }
-
-    ~Pool() noexcept {
-        for (auto elem: m_used_objs) {
-            delete elem;
-        }
-        for (auto elem: m_free_objs) {
-            delete elem;
-        }
-    }
-
-    Obj * acquire() {
-        const std::lock_guard<std::mutex> lock(m_mtx);
-        if (m_free_objs.empty()) {
-            throw CapacityExhaustedException();
-        }
-        auto obj = m_free_objs.front();
-        m_free_objs.pop_front();
-        m_used_objs.push_back(obj);
-        //printf("ACQ %p\n",  obj);
-        return obj;
-    }
-
-    void release(Obj * obj)
-    {
-        const std::lock_guard<std::mutex> lock(m_mtx);
-        //printf("REL: %p\n", obj);
-        auto iter = std::find(std::begin(m_used_objs), std::end(m_used_objs), obj);
-        auto found = iter != std::end(m_used_objs);
-        if (found) {
-            obj->reset();
-            m_free_objs.push_front(obj);
-            m_used_objs.erase(iter);
-        } else {
-            throw InvalidObjectException();
-        }
-    }
-
-private:
-
-    std::mutex m_mtx;
-    size_t m_high_water_mark;
-    size_t m_allocation_count;
-    std::deque<Obj*> m_used_objs;
-    std::deque<Obj*> m_free_objs;
-};
-
-#endif // __POOL_H

pyxcp/cxx/poolmgr.cpp

@@ -1,6 +0,0 @@
-
-#include "poolmgr.hpp"
-
-
-
-PoolManager::IodPool_t PoolManager::m_iod_pool; // Initialization of static member.