Skip to content

python

wxPython (3.0.2.0) on OS X El Capitan (10.11)

Since OS X 10.11 (El Capitan), the lastest version of the available wxPython dmg (3.0.2.0) have an unsupported pkg structure. You can see an open bug at http://trac.wxwidgets.org/ticket/17203

Thanks to memoselyk@stackoverflow we can convert manually the package structure to be able to install it : http://stackoverflow.com/questions/34402303/install-wxpython-in-osx-10-11/34622956#34622956 ; you can find an updated version of the method below :

Installing wxPython-3.0.2.0 on OS X El Capitan :

# base workdir
mkdir ~/wxpython_elcapitan
cd ~/wxpython_elcapitan

# download the wxPython dmg
curl -L "http://downloads.sourceforge.net/project/wxpython/wxPython/3.0.2.0/wxPython3.0-osx-3.0.2.0-cocoa-py2.7.dmg?r=http%3A%2F%2Fwww.wxpython.org%2Fdownload.php&ts=1453708927&use_mirror=netix" -o wxPython3.0-osx-3.0.2.0-cocoa-py2.7.dmg

# mount the dmg
hdiutil attach wxPython3.0-osx-3.0.2.0-cocoa-py2.7.dmg

# copy the dmg package to the local disk
mkdir ~/wxpython_elcapitan/repack_wxpython
cd ~/wxpython_elcapitan/repack_wxpython
cp -r /Volumes/wxPython3.0-osx-3.0.2.0-cocoa-py2.7/wxPython3.0-osx-cocoa-py2.7.pkg .

# unmount the dmg
dmgdisk="$(hdiutil info | grep '/Volumes/wxPython3.0-osx-3.0.2.0-cocoa-py2.7' | awk '{ print $1; }')"
hdiutil detach ${dmgdisk}

# prepare the new package contents
mkdir ~/wxpython_elcapitan/repack_wxpython/pkg_root
cd ~/wxpython_elcapitan/repack_wxpython/pkg_root
pax -f ../wxPython3.0-osx-cocoa-py2.7.pkg/Contents/Resources/wxPython3.0-osx-cocoa-py2.7.pax.gz -z -r
cd ~/wxpython_elcapitan/repack_wxpython

# prepare the new package scripts
mkdir ~/wxpython_elcapitan/repack_wxpython/scripts
cp wxPython3.0-osx-cocoa-py2.7.pkg/Contents/Resources/preflight scripts/preinstall
cp wxPython3.0-osx-cocoa-py2.7.pkg/Contents/Resources/postflight scripts/postinstall

# delete the old package
rm -rf ~/wxpython_elcapitan/repack_wxpython/wxPython3.0-osx-cocoa-py2.7.pkg

# build the new one :
pkgbuild --root ./pkg_root --scripts ./scripts --identifier com.wxwidgets.wxpython wxPython3.0-osx-cocoa-py2.7.pkg

# put the package on Desktop, and clean workdir
mv ~/wxpython_elcapitan/repack_wxpython/wxPython3.0-osx-cocoa-py2.7.pkg ~/Desktop/
cd ~
rm -rf ~/wxpython_elcapitan

# install it ! it will ask for your password (to become superuser/root)
sudo installer -pkg ~/Desktop/wxPython3.0-osx-cocoa-py2.7.pkg -target /

# EOF

wxPython is now available on your OS X El Capitan :

$ python -c “import wx ; print wx.version()”
3.0.2.0 osx-cocoa (classic)

Using wxPython in a VirtualEnv :

OS X is now restricting screen access to a trusted list of Frameworks and binaries, and a standard VirtualEnv is not enought :

This program needs access to the screen.
Please run with a Framework build of python, and only when you are
logged in on the main display of your Mac.

Thanks to the wxPython wiki, we can find some ways to solve that :
See : http://wiki.wxpython.org/wxPythonVirtualenvOnMac

Below, a quick solution, assuming that you don’t want system packages in your virtual env :

mkdir ~/dev
cd ~/dev
virtualenv --python=python2.7 --distribute --no-site-packages --unzip-setuptools myvirtualenv
source ~/dev/myvirtualenv/bin/activate
ln -s /Library/Python/2.7/site-packages/wxredirect.pth ~/dev/myvirtualenv/lib/python2.7/site-packages/wxredirect.pth

And now you must use the system python interpreter, instead the one in your virtual env, you should use a script, a wrapper, or modify activate script, but the minimum is :

PYTHONHOME="/Users/davixx/dev/myvirtualenv/" /usr/bin/python -c "import wx ; app = wx.App()"

Have a nice day with Mercy – MUSE

mydumper-0.6 views dump and restore

Hi readers, i hope you are listening to the MUSE Drones Album,

The mydumper-0.6.2 (the current stable version) is not dumping views… Thankfully, the 0.9 branch (not stable at now) will… (MyDumper – Add support for all schema objects)

The question is, how to safely backup theses views (without using a beta version of mydumper) ?

I search into the myloader.c source code how the regular tables have theirs schema restored, and luckily, in the following function :

void restore_data(MYSQL *conn, char *database, char *table, const char *filename, gboolean is_schema);

we can see that the content of the schema dump file is ready and executed without special verification :

// [...]
if (!is_schema)
    mysql_query(conn, "START TRANSACTION");

while (eof == FALSE) {
    if (read_data(infile, is_compressed, data, &eof)) {
        // Search for ; in last 5 chars of line
        if (g_strrstr(&data->str[data->len >= 5 ? data->len - 5 : 0], ";\n")) {
            if (mysql_real_query(conn, data->str, data->len)) {
                g_critical("Error restoring %s.%s from file %s: %s", db ? db : database, table, filename, mysql_error(conn));
                errors++;
                return;
            }
            query_counter++;
            if (!is_schema &&(query_counter == commit_count)) {
                query_counter= 0;
                if (mysql_query(conn, "COMMIT")) {
                    g_critical("Error committing data for %s.%s: %s", db ? db : database, table, mysql_error(conn));
                    errors++;
                    return;
                }
                mysql_query(conn, "START TRANSACTION");
            }

            g_string_set_size(data, 0);
        }
    } else {
        g_critical("error reading file %s (%d)", filename, errno);
        errors++;
        return;
    }
}
if (!is_schema && mysql_query(conn, "COMMIT")) {
    g_critical("Error committing data for %s.%s from file %s: %s", db ? db : database, table, filename, mysql_error(conn));
    errors++;
}
// [...]

That mean we can generate – by any way we want – a fake schema-dump file, but with a query creating a view.

For that,  i first thought of patching mydumper.c ; but as mydumper-0.9 (not stable at now) already support this feature, i will prefer another solution.

I’ve made a modest python script which list view and generate files named database.view_name-schema.sql into the mydumper dump dir. With that, myloader will consider thoses files as regular table schema create statements.

Please note that i force a DROP VIEW IF EXISTS into the dump file…

#!/usr/bin/python2.7 -u

import MySQLdb
import os

# settings
MARIADB_USER = 'a_readonly_user'
MARIADB_PASS = 'a_good_password_MU5E_D3AD_IN7ID3_%!@'
MARIADB_HOST = '127.0.0.1'
MARIADB_PORT = 3306
MARIADB_SCKT = ''  # empty for TCP , or path if socket (host must be localhost)
MYDUMPER_DUMP_DIR = '/tmp'  # the path of the dump already done by mydumper

# connection to the MariaDB server
mariadb_connection = MySQLdb.connect(
    host=MARIADB_HOST,
    user=MARIADB_USER,
    passwd=MARIADB_PASS,
    port=MARIADB_PORT,
    unix_socket=MARIADB_SCKT,
    db='information_schema',
)

# creating cursors
views_list_cursor = mariadb_connection.cursor()
show_create_view_cursor = mariadb_connection.cursor()

# ask MariaDB for the views list
views_list_cursor.execute("SELECT `table_schema`, `table_name` FROM `tables` WHERE `table_type` = 'VIEW'")

for database, view in views_list_cursor:
    # and handle each results
    show_create_view_cursor.execute("SHOW CREATE VIEW `{}`.`{}`".format(database, view))
    view, create_view_stmt, character_set_client, collation_connection = show_create_view_cursor.fetchone()
    dump_file = os.path.join(MYDUMPER_DUMP_DIR, '{}.{}-schema.sql'.format(database, view))
    assert not os.path.exists(dump_file)
    with open(dump_file, 'w') as f:
        fwrite('DROP VIEW IF EXISTS `{}`.`{}`;'.format(database, view))
        fwrite('\n\n')
        f.write(create_view_stmt)
        f.write(';')

# release cursors and close the MariaDB connection
views_list_cursor.close()
show_create_view_cursor.close()
mariadb_connection.close()

Feel free to make it PEP8, or with better error handling. Actually, the return code will be 0 only if everything seems good.

i2cd : Python + Twisted + smbus

Discuter en python avec des périphériques i2c c’est déjà assez facile grace à smbus… Jusque là aucun problème, sauf quand j’ai commencé à faire des communications concurrentes. En théorie, le bus va échanger “n’importe quoi” pendant la concurrence, et donc les échanges en cours risquent d’être perturbés/invalides.

C’est effectivement le cas, mais évidement les primitives que j’avais développés détectaient l’erreur i/o renvoyée par smbus, et retentais un certains nombre de fois les mêmes opérations. Seulement, il se trouve que certains périphériques i2c (comme ceux reposant sur certains MSP430) gèrent mal le fait d’avoir vu un début de communication i2c, sans une fin de communication valide. Et du coup, certains “plantent”, n’acceptent plus de communications i2c et nécessitent un redémarrage.

J’ai alors décidé de mettre en place un modeste daemon i2cd qui aurait pour rôle de centraliser les échanges i2c, et d’apporter une interface socket TCP simple, via twisted pour permettre aux différents applicatifs de communiquer avec.

L’avantage premier de twisted est d’être un event-driven networking engine, c’est à dire qu’il va déclencher l’appel de certaines de vos méthodes en fonction d’un évènement réseau (connexion établie, données reçues, …) ; n’étant pas un professionnel de twisted, j’ai d’ailleurs découvert que par défaut, il ne fait pas d’appels concurrents à Protocol.dataReceived (évitant d’avoir à utiliser threading.Lock)

Je précise aussi que je le client va échanger avec i2cd un message constitué de plusieurs bytes, et que i2cd ne devra pas mélanger les messages lorsque il les enverra sur le bus i2c.

Le but de ce post est un PoC serveur + client, ne recherchez donc pas la compatibilité python-3, le respect de la PEP8, ou autre (mais n’hésitez pas à la proposer)…

Le client (directement avec les sockets python natives) :

#!/usr/bin/python2.7

__author__ = 'davixx'
I2CD_HOST = '127.0.0.1'
I2CD_PORT = 422

# -------------------------------------------------------------------------------------------------------------------- #

import socket
import sys
import re
import time

# -------------------------------------------------------------------------------------------------------------------- #

I2CD_WELCOME_BANNER_RE = re.compile('^200\sWELCOME\s\-\sYOU\sARE\s\d+\sIN$')
I2CD_ANSWER_RE = re.compile('^(?P<code>\d{3})\s(?P<str>.+)$')
I2CD_READED_STR_RE = re.compile('^READED\s(?P<byte>\d+)$')

# -------------------------------------------------------------------------------------------------------------------- #

def remote_msg(addr, msg, read=False):

    res = False

    try:
        # connect
        socket_client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        socket_client.connect((I2CD_HOST, I2CD_PORT))

        # banner
        socket_client.send('I2CD CLIENT\n')
        data = socket_client.recv(64).strip()
        if I2CD_WELCOME_BANNER_RE.match(data) is None:
            raise NameError('Invalid Welcome banner')

        # MSG
        data = ('READ' if read else 'SEND') + ' ' + hex(addr)
        for e in msg:
            data += ' ' + str(e)
        socket_client.send(data + '\n')
        data = socket_client.recv(64)
        data = I2CD_ANSWER_RE.match(data)
        if data is None:
            raise NameError('Invalid answer')
        if data.group('code') == '200':
            res = True
        elif data.group('code') == '201':
            data = I2CD_READED_STR_RE.match(data.group('str'))
            if data is None:
                raise NameError('Invalid answer')
            res = data.group('byte')
            res = int(res)

        # disconnect
        socket_client.send('QUIT\n')
        socket_client.close()

    except:
        pass

    return res

# -------------------------------------------------------------------------------------------------------------------- #

if __name__ == '__main__':

    # tcp client
    try:
        print remote_msg(addr=0x44, msg=[229, 1, 131, 1, 106])
        while True:
            r = remote_msg(addr=0x44, msg=[228, 17, 7, 152], read=True)
            print r
            time.sleep(1)
            if r == 0:
                pass
                # break
    except KeyboardInterrupt:
        sys.exit(0)

Le serveur (avec twisted) :

#!/usr/bin/python2.7 -u
__author__ = 'davixx'

# -------------------------------------------------------------------------------------------------------------------- #

from twisted.internet import protocol, reactor, endpoints
import time
import smbus
import sys

# -------------------------------------------------------------------------------------------------------------------- #

class I2CdProtocol(protocol.Protocol):

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#

    def __init__(self, factory):
        self.factory = factory
        self.ready = False  # default status : the client is not ready to ask everything else than "Welcome"

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#

    def connectionMade(self):
        self.factory.numProtocols += 1

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#

    def connectionLost(self, reason):
        self.ready = False
        self.factory.numProtocols -= 1

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#

    def ready_or_reject(self):

        # ready, this function return here
        if self.ready:
            return True

        # not ready... be verbose to the client, and lose connection
        self.transport.write('500 PLEASE WELCOME FIRST\n')
        self.transport.loseConnection()
        return False

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#

    @staticmethod
    def parse_addr_and_msg(data):
        try:
            # data split
            data = data.split(' ')

            # extract addr
            addr = data.pop(0).strip()
            assert addr.startswith('0x')
            addr = addr[2:]
            addr = int(addr, 16)
            assert 0 < addr < 128

            # extract message
            msg = list()
            for e in data:
                e = e.strip()
                e = int(e)
                assert 0 <= e <= 255
                msg.append(e)
            assert 0 < len(msg) < 64

        except:
            return None

        else:
            return I2cMessage(addr=addr, msg=msg)

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#

    def dataReceived(self, data):

        # init
        data = data.strip()

        # must be ready, unless for welcome message
        if data != 'I2CD CLIENT':
            # should be ready
            if not self.ready_or_reject():
                return

        # Welcome message needed first
        if data == 'I2CD CLIENT':
            self.transport.write('200 WELCOME - YOU ARE ' + str(self.factory.numProtocols) + ' IN\n')
            self.ready = True

        # QUIT
        elif data == 'QUIT':
            self.ready = False
            self.transport.write('200 BYE BYE - REMAINING CLIENTS COUNT ' + str(self.factory.numProtocols - 1) + '\n')
            self.transport.loseConnection()

        # SEND 0x44 229 1 131 1 106
        elif data.startswith('SEND '):
            i2c_message = self.parse_addr_and_msg(data[5:])
            if i2c_message is None or not isinstance(i2c_message, I2cMessage):
                self.transport.write('500 INVALID COMMAND STRUCT\n')
            else:
                sended = i2c_message.send()
                self.transport.write(('200 SENDED' if sended else '400 FAILED') + '\n')

        # READ 0x44 228 17 7 152
        elif data.startswith('READ '):
            i2c_message = self.parse_addr_and_msg(data[5:])
            if i2c_message is None or not isinstance(i2c_message, I2cMessage):
                self.transport.write('500 INVALID COMMAND STRUCT\n')
            else:
                sended = i2c_message.send()
                if not sended:
                    self.transport.write('400 FAILED\n')
                res = i2c_message.read()
                self.transport.write('201 READED ' + str(res) + '\n')

        # unknown command...
        else:
            self.transport.write('500 UNKNOWN COMMAND\n')
            self.transport.loseConnection()

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#

# -------------------------------------------------------------------------------------------------------------------- #

class I2CdFactory(protocol.Factory):

    def __init__(self):
        if hasattr(protocol.Factory, '__init__'):
            protocol.Factory.__init__(self)
        self.numProtocols = 0

    def buildProtocol(self, addr):
        return I2CdProtocol(factory=self)

# -------------------------------------------------------------------------------------------------------------------- #

class I2cMessage(object):

    def __init__(self, addr, msg):
        self.bus = smbus.SMBus(1)
        self.max_try = 3
        self.addr = addr
        self.msg = msg

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#

    def log(self, msg, **kwargs):  # TODO
        print msg

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#

    def _bus_write_byte(self, byte, max_try=3):

        # check type : int or hex
        if not isinstance(byte, int):
            raise NameError('byte must be an instance of int')

        # verbose
        line = ' > @' + str(hex(self.addr)) + ' : ' + str(byte).rjust(3, ' ') + ' (' + bin(byte).rjust(10, ' ') + ') '
        self.log(line, is_low_level=True)

        tried = 0

        while True:
            try:
                time.sleep(0.01)
                self.bus.write_byte(self.addr, byte)
                return
            except:
                if tried < max_try:
                    tried += 1
                    continue
                raise

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#

    def _bus_read(self, max_try=3):

        # verbose
        line = ' < @' + str(hex(self.addr)) + 'READ BYTE'.ljust(16, ' ')

        tried = 0

        while True:
            try:
                time.sleep(0.01)
                r = self.bus.read_byte(self.addr)
                line += ' => ' + str(r)
                self.log(line, is_low_level=True)
                return r
            except:
                if tried < max_try:
                    tried += 1
                    continue
                line += ' => NULL'
                self.log(line, is_low_level=True)
                self.log('!!!! ' + 'self.bus.read_byte(addr)' + 'failed, tried:' + str(max_try), is_low_level=True)
                raise

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#

    def send(self):

        tried = 0
        while True:
            try:
                for a_byte in self.msg:
                    self._bus_write_byte(a_byte)
                return True
            except Exception as err:
                if tried < self.max_try:
                    tried += 1
                    time.sleep(0.05)
                    continue
                self.log(' !! smbus failed to addr: ' + str(self.addr) + ' on dataset : ' + str(self.msg) + ' err: ' + str(err))
                return False

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#

    def read(self):
        try:
            return self._bus_read()
        except:
            return None

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#

    def __repr__(self):
        return str(hex(self.addr)) + ' => ' + str(self.msg)

    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -#

# -------------------------------------------------------------------------------------------------------------------- #

if __name__ == '__main__':

    # init twisted tcp server
    try:
        endpoints.serverFromString(reactor, 'tcp:422').listen(I2CdFactory())
        reactor.run()
    except KeyboardInterrupt:
        sys.exit(0)

# -------------------------------------------------------------------------------------------------------------------- #

Python-3.4 sur ma Gentoo habituée à Python-2.7

A la découverte de Python-3.4.0 sur une de mes install Gentoo :) A ce jour (17/05/2014) Python-3.4 est encore masqué sous Gentoo, je vais l’installer sans modifier (volontairement) le package.keywords :

ACCEPT_KEYWORDS="~amd64" emerge -av =python-3.4*

[ebuild  NS    ] dev-lang/python-3.4.0:3.4 [2.7.5-r3:2.7, 3.3.3:3.3] USE="gdbm ipv6 ncurses readline sqlite ssl threads xml -build -examples -hardened -tk -wininst" 13,768 kB
GNU/Linux Magazine 171 (Mai 2014)
GNU/Linux Magazine 171 (Mai 2014)

J’utilisais jusque là python-2.7 uniquement, entendant ici ou là (notamment avec les développeurs Ansible) que Python >= 3.0 s’apparentait plutôt à un nouveau language qu’à une évolution de ce dernier.

C’est en lisant GNU/Linux Magazine 171 (Mai 2014) que je me retrouve tenté d’essayer la version 3.4  – entre-autres pour le module asyncio…

J’en profite par ailleurs pour parler de ce “Dr KissCool” visiblement adepte du troll et accompagné d’un humour de second et troisième degré. Je n’aime pas ce rédacteur, je ne remet pas en cause ses éventuels talents dans le domaine, mais je ne prends presque aucun plaisir à lire son blah blah trop souvent éloigné à mon goût de l’information technique recherchée dans ce genre de Mag.

Mes contenus sur ce blog sont probablement moins pertinents avec plus de fautes d’orthographes et grammaticales, mais personne ne paye pour les lires

Je n’oublie pas ensuite d’aller modifier le PYTHON_TARGETS dans make.conf que Gentoo consultera pour déterminer les version de python concernées par l’installation de nouveaux modules  :

PYTHON_TARGETS="python2_7 python3_3 python3_4"

Il faudrait ensuite théoriquement demander à Gentoo la recompilation de tous les modules python pour prendre en compte cette nouvelle branche :

 * You have just upgraded from an older version of Python.
 *
 * Please adjust PYTHON_TARGETS (if so desired), and run emerge with the --newuse or --changed-use option to rebuild packages installing python modules.

Tiens donc, jusque là, Gentoo préconisait l’utilisation de l’outil python-updater pour ça ; mais effectivement le résultat n’a pas l’air d’être pertinent :

# python-updater -- --pretend --tree --verbose
 * Starting Python Updater...
 * Main active version of Python:    2.7
 * Active version of Python 2:       2.7
 * Active version of Python 3:       3.3
 * Globally supported Python ABIs in installed repositories:
 *   gentoo:                         2.4 2.5 2.6 2.7 3.1 3.2 3.3 2.5-jython 2.7-jython 2.7-pypy-1.7 2.7-pypy-1.8 2.7-pypy-1.9 2.7-pypy-2.0
 *   sdfoverlay:                     2.4 2.5 2.6 2.7 3.1 3.2 3.3 2.5-jython 2.7-jython 2.7-pypy-1.7 2.7-pypy-1.8 2.7-pypy-1.9 2.7-pypy-2.0
 *   Adding to list: sys-libs/cracklib:0
 * emerge -Dv1 --keep-going sys-libs/cracklib:0 --pretend --tree --verbose

These are the packages that would be merged, in reverse order:

Calculating dependencies... done!
[ebuild     U  ] sys-libs/cracklib-2.9.1 [2.8.19] USE="nls zlib -python -static-libs {-test%} (-build%)" PYTHON_TARGETS="python2_7%* (-python2_6)" 621 kB

Total: 1 package (1 upgrade), Size of downloads: 621 kB

par ailleurs, on constate que python-3.4 ne semble pas être listé dans les “Globally supported ABIs” ; cela à t’il donc un intérêt de recompiler les modules avec emerge ? essayons avec dev-python/django pour commencer :

emerge -av dev-python/django

[ebuild     U  ] dev-python/django-1.4.11 [1.4.8] USE="vhosts -mysql -postgres -sqlite {-test} (-doc%)" PYTHON_TARGETS="python2_7 (-python2_6%)" 7,571 kB
# equery files dev-python/django | grep 2.7 | tail -n 1
/usr/lib64/python2.7/site-packages/django/views/static.pyo
#
# equery files dev-python/django | grep 3.4 | tail -n 1
# 

à priori non, alors je m’arrête là et j’utilise python3.4 pour mes tests sans me soucier (et sans que cela ne perturbe) mes install stable via portage de python2.7 et python3.4 … Désolé si ce post est… inutile…

# python3.4
Python 3.4.0 (default, May 17 2014, 11:59:14)
[GCC 4.7.3] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 

ansible – sysctl module

The first version of my sysctl module for ansible have been merged to the devel tree of the mainstream ansible projet (on github) by mpdehaan.

You can now use easily this sysctl module :

  • by using git pull, if you have installed ansible by a simple git clone
  • by downloading manually sysctl in the library subdirectory of your playbooks :
cd /path/to/my/playbooks
[ -d "library" ] || mkdir -v library
wget https://raw.github.com/ansible/ansible/devel/library/sysctl -O library/sysctl
Ansible Servers Orchestration
Ansible is the easiest way to deploy, manage, and orchestrate computer systems you’ve ever seen. You can get started in minutes

After that, you can now use the sysctl module in your playbooks (extracted from the embedded documentation) :

  • Set vm.swappiness to 5 in /etc/sysctl.conf
    (first, check if /proc/sys/vm/swappiness file exist and is writteable, and after change, call sysctl -p and verify if /proc/sys/vm/swappiness file content is now 5) :
sysctl: name=vm.swappiness value=5 state=present
  • Remove kernel.panic entry from /etc/sysctl.conf
sysctl: name=kernel.panic state=absent sysctl_file=/etc/sysctl.conf
  • Set kernel.panic to 3 in /tmp/test_sysctl.conf, check if the sysctl key seems writable, but do not reload sysctl, and do not check kernel value after (not needed, because it is not the real /etc/sysctl.conf updated) :
sysctl: name=kernel.panic value=3 sysctl_file=/tmp/test_sysctl.conf check=before reload=no

Découverte d’ansible – Orchestration de serveurs

Bonjour !

Je viens de découvrir ansible, et j’ai décidé de tenter de l’utiliser, pendant quelques mois, pour mes besoins personnels et pour certains clients.

Pourquoi ansible au lieu de Opscode Chef  ou Puppet ou CFEngine pour gérer le parc de configuration, le déploiement de logiciels, et autres ?

Sincèrement je n’ai pas de raisons majeures à ce stade, je fais les choses au feeling, je n’ai pas assez d’expérience dans les alternatives citées pour les juger.

Ansible Servers Orchestration powerfull tools
Ansible Servers Orchestration powerfull tools

Par contre, voici les premiers plus qui m’ont attirés et qui m’ont menés là : (sans pour autant sous-entendre que les alternatives ne peuvent pas, dans certains cas, en faire autant)

  • une architecture reposant sur ssh, l’installation d’aucun agent sur chacun des nodes n’est nécessaire.
  • une architecture modulaire, dans laquelle un script bash, python, php, ou encore un binaire peuvent être utilisés de manière transparente.
  • un mode had-hoc, avec lequel je peux – par exemple – déployer en une seule ligne de commande, propager un nouveau réglage pour la conntrack sur un pool de 45 serveurs.
  • un mode playbook, avec lequel je modélise des configurations idempotentes partielles et/ou totales de serveurs que je peux ensuite appliquer sans avoir la nécessité d’être un développeur, le playbook ressemble plus à une documentation rédigé au format yaml plutôt qu’un script en ruby.
  • pas d’abstraction sur le système d’exploitation des nodes et de son gestionnaire de paquets ; et cela volontairement ; pourquoi ? la pluralité des OS fait que certaines distributions Linux par exemple, ont des particularités qui sont valorisables. Reposer sur un outil qui ne retiendrait que le plus petit dénominateur de chaque distribution serait une sorte de gaspillage.

Et donc ?

Le projet ansible est récent (environ 1 an) initié – entre autres – par Michael DeHaan (un développeur ayant un historique dans les outils d’orchestration/industrialisation)

Ansible est disponible sur GitHub, je l’ai forké pour pouvoir contribuer en développant le module sysctl en un premier temps, et pour le module emerge (gestionnaire de paquet de Gentoo) en un second temps.