Distribution EOLE » Commun » python-pyeole

Je ne vois pas bien comment m’en sortir avec le code existant (#5912).

Du coup, je ferais bien une nouvelle API gérant à la fois l’activation/désactivation et le lancement/arrêt des services ;-)

• manage_service(action, name, container=None)
• manage_services(action, names=None, container=None)

Ces deux fonctions gèrent la logique conteneur/groupe de conteneurs et passent le relais à une fonction qui fait le travail _manage_service(action, service, container=None) en dispatchant par action/méthode sur d’autres fonctions privées.

Étant donné que le code actuel de service_out() (source:pyeole/service.py?rev=a4b43345#L697) ne peut pas fonctionner, je me pose la question de l’intérêt de la double gestion.

L’API donne à peu près ça :

_ACTION_DISPATCHER = {'enable': '_enable_service',
                      'disable': '_disable_service',
                      'status': '_status_service',
                      'start': '_start_service',
                      'stop': '_stop_service',
                      'restart': '_restart_service',
                      'reload': '_reload_service'}

def manage_services(action, names=None, container=None):
    """Apply :data:`action` to services.

    If no service :data:`names` is provided, :data:`action` is
    performed for all services.

    if no :data:`container` is provided, services are looked-up in all
    container groups.

    :param action: action to perform
    :type action: `str` in [``enable``, ``disable``, ``status``,
                  ``start``, ``restart``, ``stop``, ``reload``,
                  ``force-reload``]
    :param names: names of services
    :type names: `list` of `str`
    :param container: name of the container where to perform :data:`action`
    :type container: `str`

    """ 
    containers_ctx = []
    if container is not None:
        containers_ctx = [creole_client.get_container_infos(container)]
    else:
        for group_name in creole_client.get_groups():
            containers_ctx.append(creole_client.get_group_infos(group_name))

    for ctx in containers_ctx:
        _manage_service(action, services=names, ctx=ctx)

def manage_service(action, name, container=None):
    """Apply :data:`action` to one service.

    if no :data:`container` is provided, services are looked-up in all
    container groups.

    :param action: action to perform
    :type action: `str` in [``enable``, ``disable``, ``status``,
                  ``start``, ``restart``, ``stop``, ``reload``,
                  ``force-reload``]
    :param name: name of service
    :type name: `str`
    :param container: name of the container where to perform :data:`action`
    :type container: `str`

    """ 
    containers_ctx = []
    if container is not None:
        containers_ctx = [creole_client.get_container_infos(container)]
    else:
        for group_name in creole_client.get_groups():
            containers_ctx.append(creole_client.get_group_infos(group_name))

    for ctx in containers_ctx:
        _manage_service(action, services=[name], ctx=ctx)

def _manage_service(action, services, ctx):
    """Apply :data:`action` to :data:`services` in a container.

    :param action: action to perform
    :type action: `str` in [``enable``, ``disable``, ``status``,
                  ``start``, ``restart``, ``stop``, ``reload``,
                  ``force-reload``]
    :param services: names of service
    :type services: `list` of `str`
    :param ctx: container context
    :type ctx: `dict`

    """ 
    if _ACTION_DISPATCHER.get(action, None) is None:
        raise ValueError('Invalid action {0}'.format(action))

    services_ctx = []
    if services is None:
        services_ctx = ctx['services']
    else:
        for service in ctx['services']:
            if service['name'] in services:
                services_ctx.append(service)

    for service in services_ctx:
        globals().get(_ACTION_DISPATCHER[action])(service, ctx=ctx)

def _enable_service(service, ctx):
    log.debug("Enable service {0}".format(service['name']))
    creole_update_rcd(service, 'set', ctx)

def _disable_service(service, ctx):
    log.debug("Disable service {0}".format(service['name']))
    creole_update_rcd(service, 'remove', ctx)

def _status_service(service, ctx):
    log.debug("Status service {0}".format(service['name']))
    pass

def _start_service(service, ctx):
    log.debug("Start service {0}".format(service['name']))
    pass

def _stop_service(service, ctx):
    log.debug("Stop service {0}".format(service['name']))
    pass

def _restart_service(service, ctx):
    log.debug("Restart service {0}".format(service['name']))
    pass

def _reload_service(service, ctx):
    log.debug("Reload service {0}".format(service['name']))
    pass

Pour tester le code de source:pyeole/service.py?rev=feature/manage-services-per-group vous avez besoin de la version CreoleClient de creole:source:creole/client.py?rev=feature/service-by-group.

Je viens de découper pyeole.service en un paquet:

• Interface publique dans source:pyeole/service/__init__.py?rev=feature/manage-services-per-group
  • manage_services()
  • manage_service()
  • Les exceptions
• Gestion des services System V dans source:pyeole/service/_service.py?rev=feature/manage-services-per-group (à ne pas utiliser directement)
• Gestion des services upstart dans source:pyeole/service/_upstart.py?rev=feature/manage-services-per-group (à ne pas utiliser directement)

TODO¶

• pyeole.service._apache to manage Apache web sites
• pyeole.service._eoleflask to manage eoleflask applications
• pyeole.service._network to manage network which requires quite lot of special things :-/

J’ai modifié la commande creole:source:bin/CreoleService?rev=feature/service-by-group afin d’utiliser la nouvelle API.

Je note en passant que si l’action à appliquée au service était en premier argument on pourrait faire :

root@server:~# CreoleService <action> <service1> <service2> ...<serviceX>

au lieu de :

root@server:~# for service in <service1> <service2> ...<serviceX>; do CreoleService <action> $service; done

Ce qui serait nettement moins coûteux (requête CreoleClient entre autre).

J’ai ajouté un squelette afin d’aider à la gestion d’un nouveau service source:pyeole/service/_method_skelton.py?rev=feature/manage-services-per-group)

Si vous souhaitez écrire la gestion des services Apache, eoleflask et d’autres… ;-)