ellinetircd 1.0.0__tar.gz

ellinetircd-1.0.0/LICENSE

@@ -0,0 +1,8 @@
+Copyright Julien Castiaux 2020
+Copyright ElliNet13 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

ellinetircd-1.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include version.txt
+graft tests

ellinetircd-1.0.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: ellinetircd
+Version: 1.0.0
+Summary: ElliNetIRCd - an asynchronous IRC server
+Home-page: https://github.com/ElliNet13/ElliNetIRCd
+Download-URL: https://pypi.org/project/ellinetircd/
+Author: ElliNet13
+Author-email: your@email.com
+License: MIT
+Classifier: Environment :: No Input/Output (Daemon)
+Classifier: Framework :: AsyncIO
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Communications :: Chat :: Internet Relay Chat
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: trio
+Dynamic: download-url
+Dynamic: license-file
+
+ellinetircd
+=======
+
+A python asynchronous IRC server based on aioirc.
+
+### Installation and Usage
+
+Download and install the latest stable version using pip.
+Windows users might replace `python3` by `py`.
+```bash
+python3 -m pip install ellinetircd
+```
+
+Then run the server:
+```bash
+HOST=0.0.0.0 LOGLEVEL=INFO python3 -m ellinetircd
+```
+If you are using powershell you can use the following command:
+```powershell
+$env:HOST="0.0.0.0"
+$env:LOGLEVEL="INFO"
+python -m ellinetircd
+```
+
+The configuration is done via environment variables, see `--help`:
+
+    optional arguments:
+      -h, --help     show this help message and exit
+      -V, --version  show program's version number and exit
+
+    environment variables:
+      HOST           public domain name (default: julien-UX410UAR)
+      ADDR           ip address to bind (default: 127.0.1.1)
+      PORT           port to bind (default: 6667)
+      PASS           server password (default: )
+      TIMEOUT        kick inactive users after x seconds (default: 60)
+      PING_TIMEOUT   PING inactive users x seconds before timeout (default: 5)
+      LOGLEVEL       logging verbosity (default: WARNING)

ellinetircd-1.0.0/README.md

@@ -0,0 +1,38 @@
+ellinetircd
+=======
+
+A python asynchronous IRC server based on aioirc.
+
+### Installation and Usage
+
+Download and install the latest stable version using pip.
+Windows users might replace `python3` by `py`.
+```bash
+python3 -m pip install ellinetircd
+```
+
+Then run the server:
+```bash
+HOST=0.0.0.0 LOGLEVEL=INFO python3 -m ellinetircd
+```
+If you are using powershell you can use the following command:
+```powershell
+$env:HOST="0.0.0.0"
+$env:LOGLEVEL="INFO"
+python -m ellinetircd
+```
+
+The configuration is done via environment variables, see `--help`:
+
+    optional arguments:
+      -h, --help     show this help message and exit
+      -V, --version  show program's version number and exit
+
+    environment variables:
+      HOST           public domain name (default: julien-UX410UAR)
+      ADDR           ip address to bind (default: 127.0.1.1)
+      PORT           port to bind (default: 6667)
+      PASS           server password (default: )
+      TIMEOUT        kick inactive users after x seconds (default: 60)
+      PING_TIMEOUT   PING inactive users x seconds before timeout (default: 5)
+      LOGLEVEL       logging verbosity (default: WARNING)

ellinetircd-1.0.0/ellinetircd/__init__.py

@@ -0,0 +1,34 @@
+import contextvars
+import logging
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("ellinetircd")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+from ellinetircd.config import config as cfg
+logger = logging.getLogger(__package__)
+IO = logging.INFO - 5
+SECURITY = logging.ERROR + 5
+logging.addLevelName(IO, 'IO')
+logging.addLevelName(SECURITY, 'SECURITY')
+logger.setLevel(cfg.LOGLEVEL)
+servlocal = contextvars.ContextVar('servlocal')
+MAXLINELEN = 512
+
+import ellinetircd.channel
+import ellinetircd.exceptions
+import ellinetircd.server
+import ellinetircd.sdnotify
+import ellinetircd.states
+import ellinetircd.user
+
+
+def update_status() -> None:
+    sl = servlocal.get()
+    ellinetircd.sdnotify.status(
+        f"Listening on {cfg.ADDR} ({cfg.HOST}) port {cfg.PORT}. "
+        f"Currently {len(sl.users)} registered users"
+        f" in {len(sl.channels)} channels."
+    )

ellinetircd-1.0.0/ellinetircd/__main__.py

@@ -0,0 +1,75 @@
+import argparse
+import logging
+import os
+import sys
+import textwrap
+import trio
+from socket import gethostname, gethostbyname
+
+import ellinetircd
+from ellinetircd.config import config as cfg
+from ellinetircd.server import Server
+
+logger = logging.getLogger(__name__)
+
+# Color the [LEVEL] part of messages, need new terminal on Windows
+# https://github.com/odoo/odoo/blob/13.0/odoo/netsvc.py#L57-L100
+class ColoredFormatter(logging.Formatter):
+    colors = {
+        logging.DEBUG: (34, 49),  # blue
+        ellinetircd.IO: (37, 49),  # white
+        logging.INFO: (32, 49),  # green
+        logging.WARNING: (33, 49),  # yellow
+        logging.ERROR: (31, 49),  # red
+        ellinetircd.SECURITY: (31, 49),  # red
+        logging.CRITICAL: (37, 41),  # white fg, red bg
+    }
+    def format(self, record: logging.LogRecord) -> str:
+        fg, bg = type(self).colors.get(record.levelno, (32, 49))
+        record.levelname = f'\033[1;{fg}m\033[1;{bg}m{record.levelname}\033[0m'
+        return super().format(record)
+
+def main() -> None:
+    stderr = logging.StreamHandler()
+    stderr.formatter = (
+        ColoredFormatter('%(asctime)s [%(levelname)s] %(message)s')
+        if hasattr(sys.stderr, 'fileno') and os.isatty(sys.stderr.fileno()) else
+        logging.Formatter('[%(levelname)s] %(message)s')
+    )
+    root_logger = logging.getLogger('')
+    root_logger.handlers.clear()
+    root_logger.addHandler(stderr)
+
+    server = Server(cfg.HOST, cfg.ADDR, cfg.PORT, cfg.PASS)
+    try:
+        trio.run(server.serve)
+    except Exception:
+        logger.critical("Dead", exc_info=True)
+    finally:
+        logging.shutdown()
+
+# Dummy argparse, used only for --help and --version
+parser = argparse.ArgumentParser(
+    prog=ellinetircd.__name__,
+    usage=f"{sys.executable} -m {ellinetircd.__name__}",
+    description="single-server minimalist IRC",
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+    epilog=textwrap.dedent(f"""\
+        environment variables:
+          HOST           public domain name (default: {gethostname()})
+          ADDR           ip address to bind (default: {gethostbyname(cfg.HOST)})
+          PORT           port to bind (default: 6667)
+          PASS           server password (default: )
+          TIMEOUT        kick inactive users after x seconds (default: 60)
+          PING_TIMEOUT   PING inactive users x seconds before timeout (default: 5)
+          LOGLEVEL       logging verbosity (default: WARNING)
+    """)
+)
+parser.add_argument(
+    '-V', '--version',
+    action='version',
+    version=f'{ellinetircd.__name__} {ellinetircd.__version__}',
+)
+parser.parse_args()
+
+main()

ellinetircd-1.0.0/ellinetircd/channel.py

@@ -0,0 +1,85 @@
+import logging
+import trio
+from functools import partial
+from typing import List, Set, Union
+
+import ellinetircd
+
+
+logger = logging.getLogger(__name__)
+
+
+class Channel:
+    """
+    The Channel class represents a chat room.
+
+    Attributes:
+        name: str
+            the channel name.
+        users: Set[User]
+            a set of user who is subscribe to the channel.
+    """
+
+    def __init__(self, name: str) -> None:
+        """
+        Parameters:
+            name: str
+                the channel name.
+        """
+        self._name = name
+        self.users: Set["ellinetircd.user.User"] = set()
+
+    def __str__(self) -> str:
+        """
+        We represents the channel object by his name.
+
+        Return: str
+            the name of the channel.
+        """
+        return self._name
+
+    @property
+    def name(self) -> str:
+        """
+        Getter for private attributes channel name.
+
+        Returns: str 
+            the name of the channel.
+        """
+        return self._name
+
+    def _log_messages(self, messages: List[str]) -> None:
+        """
+        Log all messages sent to a client.
+        
+        Parameters: List[str]
+            A list of messages send to the client.
+        """
+        for message in messages:
+            logger.log(ellinetircd.IO, "send to %s: %s", self, message)
+
+    async def send(
+        self,
+        messages: Union[str, List[str]],
+        skipusers: Set["ellinetircd.user.User"] = set(),
+    ) -> None:
+        """"
+        Send many messages to each user subscribed to this channel.
+        
+        Parameters:
+            messages: Union[str, List[str]]
+                Messages to send to the users.
+            skipusers: Set[User]
+                A set of users to skip sending messages to.
+        """
+        if isinstance(messages, str):
+            messages = [messages]
+
+        async with trio.open_nursery() as self._nursery:
+            self._log_messages(messages)
+            for user in self.users.difference(skipusers):
+                self._nursery.start_soon(partial(
+                    user.send,
+                    messages,
+                    log=logger.isEnabledFor(logging.DEBUG)
+                ))

ellinetircd-1.0.0/ellinetircd/config.py

@@ -0,0 +1,14 @@
+import logging
+import os
+from socket import gethostname, gethostbyname
+from types import SimpleNamespace
+
+
+config = SimpleNamespace()
+config.HOST = os.getenv('HOST', gethostname())
+config.ADDR = os.getenv('ADDR', gethostbyname(config.HOST))
+config.PORT = int(os.getenv('PORT', 6667))
+config.PASS = os.getenv('PASS')
+config.TIMEOUT = int(os.getenv('TIMEOUT', 60))
+config.PING_TIMEOUT = int(os.getenv('PING_TIMEOUT', 5))
+config.LOGLEVEL = os.getenv('LOGLEVEL', 'WARNING')

ellinetircd-1.0.0/ellinetircd/exceptions.py

@@ -0,0 +1,86 @@
+__ALL__ = [
+    'Disconnect', 'IRCException', 'ErrNoSuchChannel', 'ErrNoRecipient',
+    'ErrNoTextToSend', 'ErrUnknownCommand', 'ErrNoNicknameGiven',
+    'ErrErroneusNickname', 'ErrNicknameInUse', 'ErrNotOnChannel',
+    'ErrNoLogin', 'ErrNeedMoreParams', 'ErrAlreadyRegistred',
+]
+
+import ellinetircd
+from typing import Any
+
+class Disconnect(Exception):
+    pass
+
+class IRCException(Exception):
+    """
+    Abstract IRC exception
+
+    They are excepted by dispatch() and forwarded to the user.
+    """
+    def __init__(self, *args: Any) -> None:
+        super().__init__(type(self).format(*args))
+
+    @classmethod
+    def format(cls, *args: Any) -> str:
+        return ":{host} {code} {error}".format(
+            host=ellinetircd.servlocal.get().host,
+            code=cls.code,
+            error=cls.msg.format(*args),
+        )
+
+class ErrUnknownError(IRCException):
+    # <user> <command> :<info>
+    msg = "{} {} :{}"
+    code = 400
+
+class ErrNoSuchNick(IRCException):
+    msg = "{} :No such nick/channel"
+    code = 401
+
+class ErrNoSuchChannel(IRCException):
+    msg = "{} :No such channel"
+    code = 403
+
+class ErrNoRecipient(IRCException):
+    msg = ":No recipient given ({})"
+    code = 411
+
+class ErrNoTextToSend(IRCException):
+    msg = ":No text to send"
+    code = 412
+
+class ErrUnknownCommand(IRCException):
+    msg = "{} :Unknown command"
+    code = 421
+
+class ErrNoNicknameGiven(IRCException):
+    msg = ":No nickname given"
+    code = 431
+
+class ErrErroneusNickname(IRCException):
+    msg = "{} :Erroneous nickname"
+    code = 432
+
+class ErrNicknameInUse(IRCException):
+    msg = "{} :Nickname is already in use"
+    code = 433
+
+class ErrNotOnChannel(IRCException):
+    msg = "{} :You're not on that channel"
+    code = 442
+
+class ErrNoLogin(IRCException):
+    msg = ":User not logged in"
+    code = 444
+
+class ErrNeedMoreParams(IRCException):
+    msg = "{} :Not enough parameters"
+    code = 461
+
+class ErrAlreadyRegistred(IRCException):
+    msg = ":Unauthorized command (already registered)"
+    code = 462
+
+class ErrPasswdMismatch(IRCException):
+    msg = ":Password incorrect"
+    code = 464

ellinetircd-1.0.0/ellinetircd/sdnotify.py

@@ -0,0 +1,32 @@
+import socket
+import os
+
+def notify(payload: bytes) -> None:
+    if _sdsocket:
+        _sdsocket.sendall(payload)
+
+
+def ready() -> None:
+    notify(b"READY=1")
+
+
+def reloading() -> None:
+    notify(b"RELOADING=1")
+
+
+def stopping() -> None:
+    notify(b"STOPPING=1")
+
+
+def status(line: str) -> None:
+    notify(b"STATUS=" + line.encode())
+
+
+# Setup
+_sdsocket = None
+_notify_socket = os.getenv('NOTIFY_SOCKET', '')
+if _notify_socket:
+    if _notify_socket.startswith('@'):
+        _notify_socket = f'\0{_notify_socket[1:]}'
+    _sdsocket = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
+    _sdsocket.connect(_notify_socket)

ellinetircd-1.0.0/ellinetircd/server.py

@@ -0,0 +1,77 @@
+import dataclasses
+import logging
+import signal
+import trio
+from typing import Any, Dict, Optional
+
+import ellinetircd
+from ellinetircd import sdnotify
+from ellinetircd.exceptions import Disconnect
+from ellinetircd.user import User
+
+
+logger = logging.getLogger(__name__)
+
+
+class Server:
+    def __init__(self, host: str, addr: str, port: int, pwd: Optional[str]) -> None:
+        self.host = host
+        self.addr = addr
+        self.port = port
+        self.pwd = pwd
+
+    async def handle(self, stream: trio.abc.Stream) -> None:
+        servlocal = ellinetircd.servlocal.get()
+        async with trio.open_nursery() as nursery:
+            user = User(stream, nursery)
+            logger.info("Connection with %s established.", user)
+            nursery.start_soon(user.ping_forever)
+            try:
+                await user.serve()
+            except Disconnect as exc:
+                logger.warning("Protocol violation while serving %s, %s.", user, repr(exc.__cause__ or exc))
+                await user.terminate(exc.args[0] if exc.args else "Protocol violation")
+            except Exception:
+                logger.exception("Error while serving %s.", user)
+                await user.terminate("Internal host error")
+            else:
+                await user.terminate()
+
+        logger.info("Connection with %s closed.", user)
+
+    def started(self, _listeners: Any) -> None:
+        sdnotify.ready()
+        ellinetircd.update_status()
+
+    async def _onterm(self) -> None:
+        with trio.open_signal_receiver(signal.SIGTERM, signal.SIGINT) as signal_aiter:
+            async for _ in signal_aiter:
+                if self._nursery.cancel_scope.cancel_called:
+                    raise KeyboardInterrupt()
+                sdnotify.stopping()
+                sdnotify.status("Terminating connections...")
+                self._nursery.cancel_scope.cancel()
+
+    async def serve(self) -> None:
+        ellinetircd.servlocal.set(ServLocal(self.host, self.pwd, {}, {}))
+        async with trio.open_nursery() as self._nursery:
+            self._nursery.start_soon(self._onterm)
+            logger.info("Listening on %s port %s.", self.addr, self.port)
+            await trio.serve_tcp(self.handle, self.port, host=self.addr, task_status=self)
+
+
+@dataclasses.dataclass(eq=False)
+class ServLocal:
+    host: str
+    pwd: str  # password, "pass" is a reserved keyword
+    users: Dict[str, User]
+    channels: Dict[str, "ellinetircd.channel.Channel"]
+
+    def __repr__(self) -> str:
+        return (
+            f'{self.__name__}('
+            f'host: {self.host!r}, '
+            f'pass: {"yes" if self.pwd else "no"}, '
+            f'users: {len(self.users)}, '
+            f'channels: {len(self.channels)})'
+        )