Using systemd with softioc

[XavSPM]

Hello everyone,

I managed to get softioc running without using procServ through systemd.

Here's my example code:

# Importing the basic components of the framework.
from softioc import softioc, builder, asyncio_dispatcher
import asyncio
import signal

async def main():

    loop = asyncio.get_running_loop()
    stop_signal = asyncio.Event()
    # Creating an asyncio dispatcher, the event loop is now running
    dispatcher = asyncio_dispatcher.AsyncioDispatcher(loop=loop)

    # Setting the prefix for the records
    builder.SetDeviceName("MY-DEVICE-PREFIX")

    # Creating some records
    ai = builder.aIn('AI', initial_value=5)

    # Standard code to start the IOC
    builder.LoadDatabase()
    softioc.iocInit(dispatcher)

    def on_exit():
        print("Executing cleanup function...")
        ## def cleanup ...
        print("Cleanup function completed.")
        stop_signal.set()
    
    # Handling signals for shutdown
    for sig in ('SIGINT', 'SIGTERM'):
        loop.add_signal_handler(getattr(signal, sig), on_exit)

    # Starting necessary processes after iocInit
    async def update():
        while True:
            ai.set(ai.get() + 1)
            print(ai.get())
            await asyncio.sleep(1)

    dispatcher(update)

    await stop_signal.wait()

    # Closing the IOC
    softioc.exit()

if __name__ == "__main__":

    # Starting the main function
    asyncio.run(main())

And the associated service file:

[Unit]
Description=IOC Blower Service
After=network.target

[Service]
User=root
Group=root
WorkingDirectory=/opt
ExecStart=/opt/softioc/bin/python -u /opt/example.py
Environment="PATH=/opt/softioc/bin"
Restart=always

[Install]
WantedBy=multi-user.target

To correctly have the information in systemd, you need to use the -u option of python or have the environment variable PYTHONUNBUFFERED=TRUE.

Here's what it looks like with systemd:

(softioc) xgoiziou@81l:~/Programs/Python$ sudo systemctl start exampleIOC.service 
(softioc) xgoiziou@81l:~/Programs/Python$ sudo systemctl status exampleIOC.service 
● exampleIOC.service - IOC Blower Service
     Loaded: loaded (/etc/systemd/system/exampleIOC.service; enabled; preset: disabled)
    Drop-In: /usr/lib/systemd/system/service.d
             └─10-timeout-abort.conf
     Active: active (running) since Fri 2024-02-23 14:52:16 CET; 1s ago
   Main PID: 235240 (python)
      Tasks: 43 (limit: 18704)
     Memory: 839.8M
        CPU: 2.811s
     CGroup: /system.slice/exampleIOC.service
             └─235240 /opt/softioc/bin/python -u /opt/example.py

Feb 23 14:52:16 aeroport81l systemd[1]: Started exampleIOC.service - IOC Blower Service.
Feb 23 14:52:16 aeroport81l python[235240]: INFO: PVXS QSRV2 is loaded and ENABLED.
Feb 23 14:52:16 aeroport81l python[235240]: Starting iocInit
Feb 23 14:52:16 aeroport81l python[235240]: ############################################################################
Feb 23 14:52:16 aeroport81l python[235240]: ## EPICS 7.0.7.0
Feb 23 14:52:16 aeroport81l python[235240]: ## Rev. 7.0.7.99.0.2
Feb 23 14:52:16 aeroport81l python[235240]: ## Rev. Date 7.0.7.99.0.2
Feb 23 14:52:16 aeroport81l python[235240]: ############################################################################
Feb 23 14:52:17 aeroport81l python[235240]: iocRun: All initialization complete
Feb 23 14:52:17 aeroport81l python[235240]: 6.0

[XavSPM]

Hello,

I have continued my testing and I would like to propose the addition of a new feature for softioc.

The idea is to have a function that is the opposite of interactive_ioc. A function that we could use with systemd.

I have named it no_interactive_ioc. I tested it with Python 3 and it seems to work correctly.

What do you think?

def interactive_ioc(context = {}, call_exit = True):
    '''Fires up the interactive IOC prompt with the given context.

    Args:
        context: A dictionary of values that will be made available to the
            interactive Python shell together with a number of EPICS test
            functions
        call_exit: If `True`, the IOC will be terminated by calling epicsExit
            which means that `interactive_ioc` will not return
    '''
    # Add all our commands to the given context.
    exports = dict((key, globals()[key]) for key in command_names)
    import code

    try:
        code.interact(local = dict(exports, **context), exitmsg = '')
    except SystemExit as e:
        if call_exit:
            safeEpicsExit(e.code)
        raise

    if call_exit:
        safeEpicsExit(0)

def no_interactive_ioc():
    '''Starts the IOC without an interactive shell.'''

    def on_exit():
        imports.epicsExit(0)

    for sig in ('SIGINT', 'SIGTERM'):
        device.dispatcher.loop.add_signal_handler(getattr(signal, sig), on_exit)
    
    import time
    
    while not device.dispatcher.loop.is_closed():
        time.sleep(0.1)

[AlexanderWells-diamond]

I don't think your suggested implementation works as you expect; time.sleep will cause ALL asyncio processing to halt, at least for anything inside the same event loop. You could use await asyncio.sleep to more properly do this, but that's also inefficient.

This solution also only works for an AsyncioDispatcher, but pythonSoftIOC also supports CothreadDispatcher, which is what is created by default if no AsyncioDispatcher is declared (to maintain backwards compatibility).

A more proper solution is to use some form of Event or Signal mechanism. Cothread already has the WaitForQuit function, but for asyncio we would probably want to replicate its functionality by creating an asyncio.Event(), which the no_interactive_ioc function would wait for. Then we should add a handler for KeyboardInterrupt that sets the event, thus triggering the main coroutine to finish, and bringing the whole program to a close.

As an asides, there may be a cleaner way to wait forever by using asyncio.all_tasks(), but that's Python3.7+ and we still currently support 3.6.

[XavSPM]

Hello @AlexanderWells-diamond ,

Thanks for your comment.

I had forgotten that softioc should also be able to work with Cothread in addition to asyncio. After several attempts, I came to this proposal. I don't know if it's the best solution, but after a few quick tests, it seems to work. I'm not an experienced developer, so it may not be correct.

def not_interactive_ioc():

    '''Launches IOC in non-interactive mode for background use'''

    if device.dispatcher:
        
        if hasattr(device.dispatcher, 'loop'):
            # If loop present in device.dispatcher then use asyncrio

            import asyncio
            import threading
            import signal
        
            loop = device.dispatcher.loop
            stop_event = threading.Event()

            async def stop_loop():
                imports.epicsExit(0)
                stop_event.set()  # Signal end of loop

            def signal_exit():
                asyncio.run_coroutine_threadsafe(stop_loop(), loop)

            # Configure signal handlers to call signal_exit
            for sig in ('SIGINT', 'SIGTERM'):
                loop.add_signal_handler(getattr(signal, sig), signal_exit)

            # Wait for end of loop
            stop_event.wait()

        else:
            # If loop is not present in device.dispatcher then cotherd is used

            import cothread
            cothread.WaitForQuit()
            imports.epicsExit(0)
    else:
        print("No dispatcher found")

[AlexanderWells-diamond]

I think a better approach would be to shift this logic into the two dispatchers. Implement a method in both dispatchers named e.g. wait_for_quit, then this non_interactive_ioc just calls device.dispatcher.wait_for_quit. It should also neaten up the inner imports.

Also two minor points:

• There is an asyncio.Event, which is preferrable to use instead of threading.Event.
• I prefer non_interactive_ioc as a function name

[XavSPM]

@AlexanderWells-diamond

I have made the modifications you advised.
I created a wait_for_quit function in asyncio_dispatcher.py and in cothread_dispatcher.py, and I modified the non_interactive_ioc function.

However, I was unable to use asyncio.Event instead of threading.Event because the non_interactive_ioc function is not async.

You can find all my modifications on my repository: https://github.com/XavSPM/pythonSoftIOC/tree/master

[AlexanderWells-diamond]

This has been resolved in PR #156