jsocket 1.9.3__py3-none-any.whl → 1.9.6__py3-none-any.whl

jsocket/__init__.py

@@ -1,75 +1,76 @@
 """ @package jsocket
-	@brief Main package importing two modules, jsocket_base and tserver into the scope of jsocket.
-	
-	@example example_servers.py
-	
-	@mainpage JSocket - Fast & Scalable JSON Server & Client 
-	@section Installation
-	
-	The jsocket package should always be installed using the stable PyPi releases.
-	Either use "easy_install jsocket" or "pip install jsocket" to get the latest stable version.
-	
-	@section Usage
-	
-	The jsocket package is for use during the development of distributed systems. There are two ways to 
-	use the package. The first and simplest is to create a custom single threaded server by overloading the
-	the jsocket.ThreadedServer class (see example one below).
-	
-	The second, is to use the server factory functionality by overloading the jsocket.ServerFactoryThread
-	class and passing the declaration to the jsocket.ServerFactory(FactoryThread) object. This creates a
-	multithreaded custom JSON server for any number of simultaneous clients (see example two below).
-	
-	@section Examples
-	@b 1: The following snippet simply creates a custom single threaded server by overloading jsocket.ThreadedServer
-	@code
-	class MyServer(jsocket.ThreadedServer):
-		# This is a basic example of a custom ThreadedServer.
-		def __init__(self):
-			super(MyServer, self).__init__()
-			self.timeout = 2.0
-			logger.warning("MyServer class in customServer is for example purposes only.")
-		
-		def _process_message(self, obj):
-			# virtual method
-			if obj != '':
-				if obj['message'] == "new connection":
-					logger.info("new connection.")
-	@endcode
-				
-	@b 2: The following snippet creates a custom factory thread and starts a factory server. The factory server
-	will allocate and run a factory thread for each new client.
-	
-	@code
-	import jsocket
-	
-	class MyFactoryThread(jsocket.ServerFactoryThread):
-		# This is an example factory thread, which the server factory will
-		# instantiate for each new connection.
-		def __init__(self):
-			super(MyFactoryThread, self).__init__()
-			self.timeout = 2.0
-		
-		def _process_message(self, obj):
-			# virtual method - Implementer must define protocol
-			if obj != '':
-				if obj['message'] == "new connection":
-					logger.info("new connection.")
-				else:
-					logger.info(obj)
-		
-	server = jsocket.ServerFactory(MyFactoryThread)
-	server.timeout = 2.0
-	server.start()
-	
-	client = jsocket.JsonClient()
-	client.connect()
-	client.send_obj({"message": "new connection"})
-	
-	client.close()
-	server.stop()
-	server.join()
-	@endcode
-	
+    @brief Main package importing two modules, jsocket_base and tserver into the scope of jsocket.
+
+    @example example_servers.py
+
+    @mainpage JSocket - Fast & Scalable JSON Server & Client 
+    @section Installation
+
+    The jsocket package should always be installed using the stable PyPi releases.
+    Either use "easy_install jsocket" or "pip install jsocket" to get the latest stable version.
+
+    @section Usage
+
+    The jsocket package is for use during the development of distributed systems. There are two ways to 
+    use the package. The first and simplest is to create a custom single threaded server by overloading the
+    the jsocket.ThreadedServer class (see example one below).
+
+    The second, is to use the server factory functionality by overloading the jsocket.ServerFactoryThread
+    class and passing the declaration to the jsocket.ServerFactory(FactoryThread) object. This creates a
+    multithreaded custom JSON server for any number of simultaneous clients (see example two below).
+
+    @section Examples
+    @b 1: The following snippet simply creates a custom single threaded server by overloading jsocket.ThreadedServer
+    @code
+    class MyServer(jsocket.ThreadedServer):
+        # This is a basic example of a custom ThreadedServer.
+        def __init__(self):
+            super(MyServer, self).__init__()
+            self.timeout = 2.0
+            logger.warning("MyServer class in customServer is for example purposes only.")
+
+        def _process_message(self, obj):
+            # virtual method
+            if obj != '':
+                if obj['message'] == "new connection":
+                    logger.info("new connection.")
+    @endcode
+
+    @b 2: The following snippet creates a custom factory thread and starts a factory server. The factory server
+    will allocate and run a factory thread for each new client.
+
+    @code
+    import jsocket
+
+    class MyFactoryThread(jsocket.ServerFactoryThread):
+        # This is an example factory thread, which the server factory will
+        # instantiate for each new connection.
+        def __init__(self):
+            super(MyFactoryThread, self).__init__()
+            self.timeout = 2.0
+
+        def _process_message(self, obj):
+            # virtual method - Implementer must define protocol
+            if obj != '':
+                if obj['message'] == "new connection":
+                    logger.info("new connection.")
+                else:
+                    logger.info(obj)
+
+    server = jsocket.ServerFactory(MyFactoryThread)
+    server.timeout = 2.0
+    server.start()
+
+    client = jsocket.JsonClient()
+    client.connect()
+    client.send_obj({"message": "new connection"})
+
+    client.close()
+    server.stop()
+    server.join()
+    @endcode
+
 """
 from jsocket.jsocket_base import *
 from jsocket.tserver import *
+from ._version import __version__

jsocket/_version.py

@@ -0,0 +1,3 @@
+"""Package version."""
+
+__version__ = "1.9.6"

jsocket/jsocket_base.py

@@ -1,208 +1,230 @@
 """ @namespace jsocket_base
-	Contains JsonSocket, JsonServer and JsonClient implementations (json object message passing server and client).
+    Contains JsonSocket, JsonServer and JsonClient implementations (json object message passing server and client).
 """
-__author__	  = "Christopher Piekarski"
-__email__	   = "chris@cpiekarski.com"
+__author__   = "Christopher Piekarski"
+__email__    = "chris@cpiekarski.com"
 __copyright__= """
-	This file is part of the jsocket package.
-	Copyright (C) 2011 by 
-	Christopher Piekarski <chris@cpiekarski.com>
+    Copyright (C) 2011 by
+    Christopher Piekarski <chris@cpiekarski.com>
 
-	The jsocket_base module is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
 
-	The jsocket package is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with jsocket_base module.  If not, see <http://www.gnu.org/licenses/>."""
-__version__	 = "1.0.2"
+        http://www.apache.org/licenses/LICENSE-2.0
 
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+"""
 import json
 import socket
 import struct
 import logging
 import time
 
+from ._version import __version__
+
 logger = logging.getLogger("jsocket")
 
-class JsonSocket(object):
-	def __init__(self, address='127.0.0.1', port=5489, timeout=2.0):
-		self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-		self.conn = self.socket
-		self._timeout = timeout
-		self._address = address
-		self._port = port
-	
-	def send_obj(self, obj):
-		msg = json.dumps(obj)
-		if self.socket:
-			frmt = "=%ds" % len(msg)
-			packed_msg = struct.pack(frmt, bytes(msg,'ascii'))
-			packed_hdr = struct.pack('!I', len(packed_msg))
-			self._send(packed_hdr)
-			self._send(packed_msg)
-			
-	def _send(self, msg):
-		sent = 0
-		while sent < len(msg):
-			sent += self.conn.send(msg[sent:])
-			
-	def _read(self, size):
-		data = b''
-		while len(data) < size:
-			data_tmp = self.conn.recv(size-len(data))
-			data += data_tmp
-			if data_tmp == b'':
-				raise RuntimeError("socket connection broken")
-		return data
-
-	def _msg_length(self):
-		d = self._read(4)
-		s = struct.unpack('!I', d)
-		return s[0]
-	
-	def read_obj(self):
-		size = self._msg_length()
-		data = self._read(size)
-		frmt = "=%ds" % size
-		msg = struct.unpack(frmt, data)
-		return json.loads(str(msg[0],'ascii'))
-	
-	def close(self):
-		logger.debug("closing all connections")
-		self._close_connection()
-		self._close_socket()
-
-	def _close_socket(self):
-		logger.debug("closing main socket")
-		if self.socket.fileno() != -1:
-			self.socket.shutdown(socket.SHUT_RDWR)
-			self.socket.close()
-		
-	def _close_connection(self):
-		logger.debug("closing the connection socket")
-		if self.conn.fileno() != -1:
-			self.conn.shutdown(socket.SHUT_RDWR)
-			self.conn.close()
-	
-	def _get_timeout(self):
-		return self._timeout
-	
-	def _set_timeout(self, timeout):
-		self._timeout = timeout
-		self.socket.settimeout(timeout)
-		
-	def _get_address(self):
-		return self._address
-	
-	def _set_address(self, address):
-		pass
-	
-	def _get_port(self):
-		return self._port
-	
-	def _set_port(self, port):
-		pass
-			
-	timeout = property(_get_timeout, _set_timeout,doc='Get/set the socket timeout')
-	address = property(_get_address, _set_address,doc='read only property socket address')
-	port = property(_get_port, _set_port,doc='read only property socket port')
-
-	
+
+def _socket_fileno(sock):
+    try:
+        return sock.fileno()
+    except Exception:  # pylint: disable=broad-exception-caught
+        return None
+
+
+class JsonSocket:
+    """Lightweight JSON-over-TCP socket wrapper with length-prefixed framing."""
+
+    def __init__(self, address='127.0.0.1', port=5489, timeout=2.0):
+        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.conn = self.socket
+        self._timeout = timeout
+        self._address = address
+        self._port = port
+        self._last_client_addr = None
+        # Ensure the primary socket respects timeout for accept/connect operations
+        self.socket.settimeout(self._timeout)
+
+    def send_obj(self, obj):
+        """Send a JSON-serializable object over the connection."""
+        msg = json.dumps(obj, ensure_ascii=False)
+        if self.socket:
+            payload = msg.encode('utf-8')
+            frmt = f"={len(payload)}s"
+            packed_msg = struct.pack(frmt, payload)
+            packed_hdr = struct.pack('!I', len(packed_msg))
+            self._send(packed_hdr)
+            self._send(packed_msg)
+
+    def _send(self, msg):
+        """Send all bytes in `msg` to the peer."""
+        sent = 0
+        while sent < len(msg):
+            sent += self.conn.send(msg[sent:])
+
+    def _read(self, size):
+        """Read exactly `size` bytes from the peer or raise on disconnect."""
+        data = b''
+        while len(data) < size:
+            data_tmp = self.conn.recv(size - len(data))
+            data += data_tmp
+            if data_tmp == b'':
+                raise RuntimeError("socket connection broken")
+        return data
+
+    def _msg_length(self):
+        """Read and unpack the 4-byte big-endian length header."""
+        d = self._read(4)
+        s = struct.unpack('!I', d)
+        return s[0]
+
+    def read_obj(self):
+        """Read a full message and decode it as JSON, returning a Python object."""
+        size = self._msg_length()
+        data = self._read(size)
+        frmt = f"={size}s"
+        msg = struct.unpack(frmt, data)
+        return json.loads(msg[0].decode('utf-8'))
+
+    def close(self):
+        """Close active connection and the listening socket if open."""
+        logger.debug(
+            "closing sockets (socket fd=%s, conn fd=%s)",
+            _socket_fileno(self.socket),
+            _socket_fileno(self.conn),
+        )
+        self._close_connection()
+        self._close_socket()
+
+    def _close_socket(self):
+        """Best-effort shutdown and close of the main socket."""
+        logger.debug("closing main socket (fd=%s)", _socket_fileno(self.socket))
+        try:
+            if self.socket and self.socket.fileno() != -1:
+                try:
+                    self.socket.shutdown(socket.SHUT_RDWR)
+                except OSError:
+                    pass
+                try:
+                    self.socket.close()
+                except OSError:
+                    pass
+        except OSError:
+            pass
+
+    def _close_connection(self):
+        """Best-effort shutdown and close of the accepted connection socket."""
+        logger.debug("closing connection socket (fd=%s)", _socket_fileno(self.conn))
+        try:
+            if self.conn and self.conn is not self.socket and self.conn.fileno() != -1:
+                try:
+                    self.conn.shutdown(socket.SHUT_RDWR)
+                except OSError:
+                    pass
+                try:
+                    self.conn.close()
+                except OSError:
+                    pass
+        except OSError:
+            pass
+
+    def _get_timeout(self):
+        """Get the current socket timeout in seconds."""
+        return self._timeout
+
+    def _set_timeout(self, timeout):
+        """Set the socket timeout in seconds and apply to the main socket."""
+        self._timeout = timeout
+        self.socket.settimeout(timeout)
+
+    def _get_address(self):
+        """Return the configured bind address."""
+        return self._address
+
+    def _set_address(self, _address):
+        """No-op: address is read-only after initialization."""
+        return None
+
+    def _get_port(self):
+        """Return the configured bind port."""
+        return self._port
+
+    def _set_port(self, _port):
+        """No-op: port is read-only after initialization."""
+        return None
+
+    timeout = property(_get_timeout, _set_timeout, doc='Get/set the socket timeout')
+    address = property(_get_address, _set_address, doc='read only property socket address')
+    port = property(_get_port, _set_port, doc='read only property socket port')
+
+
 class JsonServer(JsonSocket):
-	def __init__(self, address='127.0.0.1', port=5489):
-		super(JsonServer, self).__init__(address, port)
-		self._bind()
-	
-	def _bind(self):
-		self.socket.bind( (self.address,self.port) )
-
-	def _listen(self):
-		self.socket.listen(1)
-	
-	def _accept(self):
-		return self.socket.accept()
-	
-	def accept_connection(self):
-		self._listen()
-		self.conn, addr = self._accept()
-		self.conn.settimeout(self.timeout)
-		logger.debug("connection accepted, conn socket (%s,%d,%d)" % (addr[0],addr[1],self.conn.gettimeout()))
-	
-	def _is_connected(self):
-		return True if not self.conn else False
-	
-	connected = property(_is_connected, doc="True if server is connected")
-
-	
+    """Server socket that accepts one connection at a time."""
+
+    def __init__(self, address='127.0.0.1', port=5489):
+        super().__init__(address, port)
+        self._bind()
+
+    def _bind(self):
+        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.socket.bind((self.address, self.port))
+
+    def _listen(self):
+        self.socket.listen(5)
+
+    def _accept(self):
+        return self.socket.accept()
+
+    def accept_connection(self):
+        """Listen and accept a single client connection; set timeout accordingly."""
+        self._listen()
+        self.conn, addr = self._accept()
+        self._last_client_addr = addr
+        self.conn.settimeout(self.timeout)
+        logger.debug(
+            "connection accepted, conn socket (%s,%d,%s)", addr[0], addr[1], str(self.conn.gettimeout())
+        )
+
+    def _reset_connection_ref(self):
+        """Reset the server's connection reference to the listening socket."""
+        self.conn = self.socket
+
+    def _is_connected(self):
+        try:
+            return (self.conn is not None) and (self.conn is not self.socket) and (self.conn.fileno() != -1)
+        except (OSError, AttributeError):
+            return False
+
+    connected = property(_is_connected, doc="True if server has an active client connection")
+
+
 class JsonClient(JsonSocket):
-	def __init__(self, address='127.0.0.1', port=5489):
-		super(JsonClient, self).__init__(address, port)
-		
-	def connect(self):
-		for i in range(10):
-			try:
-				self.socket.connect( (self.address, self.port) )
-			except socket.error as msg:
-				logger.error("SockThread Error: %s" % msg)
-				time.sleep(3)
-				continue
-			logger.info("...Socket Connected")
-			return True
-		return False
-
-
-if __name__ == "__main__":
-	""" basic json echo server """
-	import threading
-	logger.setLevel(logging.DEBUG)
-	FORMAT = '[%(asctime)-15s][%(levelname)s][%(module)s][%(funcName)s] %(message)s'
-	logging.basicConfig(format=FORMAT)
-	
-	def server_thread():
-		logger.debug("starting JsonServer")
-		server = JsonServer()
-		server.accept_connection()
-		while 1:
-			try:
-				msg = server.read_obj()
-				logger.info("server received: %s" % msg)
-				server.send_obj(msg)
-			except socket.timeout as e:
-				logger.debug("server socket.timeout: %s" % e)
-				continue
-			except Exception as e:
-				logger.error("server: %s" % e)
-				break
-			
-		server.close()
-			
-	t = threading.Timer(1,server_thread)
-	t.start()
-	
-	time.sleep(2)
-	logger.debug("starting JsonClient")
-	
-	client = JsonClient()
-	client.connect()
-		
-	i = 0
-	while i < 10:
-		client.send_obj({"i": i})
-		try:
-			msg = client.read_obj()
-			logger.info("client received: %s" % msg)
-		except socket.timeout as e:
-			logger.debug("client socket.timeout: %s" % e)
-			continue
-		except Exception as e:
-			logger.error("client: %s" % e)
-			break
-		i = i + 1
-	
-	client.close()
+    """Client socket for connecting to a JsonServer and exchanging JSON messages."""
+
+    def __init__(self, address='127.0.0.1', port=5489):
+        super().__init__(address, port)
+
+    def connect(self):
+        """Attempt to connect to the server up to 10 times with backoff."""
+        for attempt in range(1, 11):
+            try:
+                logger.debug("connect attempt %d to %s:%s", attempt, self.address, self.port)
+                self.socket.connect((self.address, self.port))
+            except socket.error as msg:
+                logger.error("SockThread Error: %s", msg)
+                # Recreate the socket to avoid retrying on a potentially bad fd.
+                self._close_socket()
+                self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                self.socket.settimeout(self._timeout)
+                self.conn = self.socket
+                logger.debug("recreated socket for retry %d to %s:%s", attempt, self.address, self.port)
+                time.sleep(3)
+                continue
+            logger.info("...Socket Connected")
+            return True
+        return False