MakeMake The Dwarf Planet is a feed agregator.

Sortie de Offpunk 3.0

by ploum from Linuxfr.org

Salut Nal,

Après des semaines intensives de travail, j’ai le plaisir de t’annoncer la sortie d’Offpunk 3.0.

https://ploum.net/2026-02-09-offpunk3.html

Offpunk est un navigateur web/gemini/gopher/spartan en ligne de commande et déconnecté (oui, tout est en cache qu’on peut synchroniser régulièrement)

Pour avoir des réponses à toutes tes questions:

https://offpunk.net/
gemini://offpunk.net/

ou bien l’installer et taper "tutorial"

Dans les grosses nouveautés de la 3.0, il faut noter:

  1. Support des traductions. Offpunk est traduit en Espagnol, en Galego et en Néerlandais mais pas encore en français ! Si vous voulez aider, c’est ici:

https://offpunk.net/translation.html

  1. Support de "unmerdify", par @vjousse. Unmerdify est une libraire qui va parser les pages HTML en utilisant les règles FiveFilters afin d’en extraire le contenu intéressant et jeter tout les reste.

Unmerdify: https://codeberg.org/vjousse/unmerdify

Contribuer aux filtres: https://help.fivefilters.org/full-text-rss/site-patterns.html#github-repository

  1. xkcdpunk, un utilitaire en ligne de commande pour afficher directement un comic XKCD dans son terminal.

Et plein d’autres choses

Je te laisse découvrir toutes les autres nouveautés, n’hésite pas à me poser des questions !

Télécharger ce contenu au format EPUB

Commentaires : voir le flux Atom ouvrir dans le navigateur

Lire la suite…

Développeur.se python fullstack (Nantes)

by f.oliveau from AFPy discuss

Nous recherchons un·e développeur·se avec déjà une première expérience professionnelle significative en Python pour poursuivre le développement de nos services. Avoir également de l’expérience avec Vue, Typescript, Docker ou Ansible est un plus.

Type d’emploi : CDI ou CDD, temps plein ou 4/5, poste sur Nantes (présentiel mini 2/3 jours par semaine)
Ce n’est pas un poste de data scientist.

Qui est OctopusMind ?

OctopusMind, spécialiste de l’Open Data économique, développe des services autour de l’analyse des données. Nous éditons principalement une plateforme mondiale de détection d’appels d’offres : www.j360.info
L’entreprise, d’une dizaine de personnes, développe ses propres outils pour analyser quotidiennement une grande masse de données, en alliant intelligence humaine et artificielle www.octopusmind.info
Nous recherchons pour ce poste un collaborateur habitant à proximité de Nantes.

Nous vous proposons

L’équipe IT, sans lead developer, est en lien avec l’équipe R&D ML et l’équipe de veille des marchés. Nous suivons un SCRUM maison, ajusté régulièrement selon nos besoins. Nous discutons ensemble de nos priorités et nous les répartissons à chaque sprint selon les profils et envies de chacun·e.

Vous participerez :

  • Au développement back de j360 et son back-end (Python/Django, PostgreSQL, ElasticSearch).

  • Aux scripts de collecte de données (Python/Scrapy).

  • À la relecture de code et l’accompagnement vos collègues en leur fournissant du mentorat sur les bonnes pratiques, l’architecture, les design patterns, etc.

En fonction de vos centres d’intérêts :

  • Au développement front de l’application j360 (Vue3/Quasar/Typescript).

  • Au déploiement des applications (Docker/Docker-Compose, Ansible) et intégration des services R&D (Gitlab CI).

  • À la réflexion produit, analyse technique et à la définition des priorités de l’entreprise (Trello).

  • À l’ajustement de nos méthodes de travail au sein de l’équipe et de l’entreprise.

Avantages :

  • Horaires flexibles - RTT - Titres-restaurant - Participation au transport - Épargne salariale - Plan d’intéressement et plan épargne entreprise

  • Télétravail/présentiel

  • Statut cadre en fonction du diplôme/l’expérience (Syntec)

Processus de recrutement :

Les candidatures “one clic” ne sont pas regardées. Si vous prenez le temps de faire une candidature personnalisée, nous l’étudierons; sinon ne perdez pas votre temps, envoyez votre candidature à une ESN car on a pas de baby foot.

  • CV + présentation de vous et de ce qui vous intéresse à adresser par mail à job @ octopusmind.info

  • Vous pouvez illustrer vos compétences techniques avec des exemples de projets ou passer notre test technique.

  • Echanges et précisions par mail ou téléphone

  • Entretien dans nos bureaux à Nantes

  • Offre (salaire en fonction de l’expérience/niveau)

SVP pas de démarchage pour de l’outsouring ou cabinet RH, merci

1 message - 1 participant(e)

Lire le sujet en entier

Lire la suite…

Construire un C&C basique en python/FORTH au dessus de MQTT

by Jul from Linuxfr.org

Sommaire

Introduction

Qui n'a pas rêvé de faire sa console de pirates qui contrôle ses agents au doigt et à l'œil traditionnellement sur IRC ?

C'est le principe d'un Control & Command parfois appelé C&C pour les botnets. Mais ici, on en fait un éducationnel.

Il s'agit de piloter des agents à distance en leur envoyant des commandes sur un BUS qui résulte dans des actions prédéfinies comme :
- arrêtes toi,
- reprends,
- dis si tu es présent et en vie …

Ci-suit un petit exemple en python de l'implémentation d'une telle logique en moins de 100 lignes de codes

Ingrédients

Cette recette nécessite : python, et en dépendances : paho-mqtt, confined, ainsi qu'un serveur MQTT (mosquitto avec ses utilitaires en ligne de commande) correctement configurés.

La pièce de résistance

Pour tout process que l'on veut piloter on va écrire du code python comme : 

import paho.mqtt.client as mqtt
from time import time, sleep
from confined import parse, Value, pop
from subprocess import Popen,PIPE
import pathlib
import os
import socket

stack = []
client_id = socket.gethostname()
show_must_go = False

def on_connect(client, userdata, flags, reason_code, properties):
    print(f"Connected with result code {reason_code}")
    client.subscribe(f"BUS/{client_id}")
    client.subscribe(f"BUS")

def on_lun(*a, **kw):
    kw["ctx"]["state"]="RAZ"

def on_set_time_slice(*a, **kw):
    kw["ctx"]["time_slice"]=stack.pop().float


def on_ping(*a, **kw):
    global client_id
    client = kw["ctx"]["client"]
    client.publish("RES", f"'{client_id}':PONG")


def on_sel(stack, **kw):
    global client_id, show_must_go
    if stack.pop().str == client_id:
        show_must_go = True

def on_unsel(stack, **kw):
    global client_id, show_must_go
    if stack.pop().str == client_id:
        show_must_go = False

def on_test(stack, **kw):
    print("Yo")


ctx = dict(
    cap=["www", "forth" ],
    time_slice=10,
    dispatch=dict(
        lun=on_lun,
        ping=on_ping,
        sel=on_sel,
        unsel=on_unsel,
        tsset=on_set_time_slice,
        _TEST=on_test,
    ),
)

def on_message(client, userdata, msg):
    global stack, ctx
    ctx["client"] = client
    client.publish(
        "RES", 
        str(parse(
           ctx,
           msg.payload.decode(),
           data=stack, 
           )
        )
    )


mqttc = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id=client_id)
mqttc.on_connect = on_connect
mqttc.on_message = on_message

mqttc.username = "pub"
mqttc.password= "pub"
mqttc.tls_set(
    keyfile="./cfg/pub.key",
    certfile="./cfg/pub.crt",
    ca_certs="./cfg/RootCA.crt",
    tls_version=2
)
mqttc.connect("badass.home", 8883, 60)
mqttc.loop_start()
os.chdir(os.path.dirname(__file__))

plugins = pathlib.Path("../plugin")

while True:
    start = time()
    if show_must_go:
        for p in plugins.glob("*_enabled"):
            with Popen([ p,  ], stdout=PIPE, stdin=PIPE, stderr=PIPE, bufsize=0,) as writer:
                while res := writer.stdout.read():
                    writer.stdout.flush()
                    for msg in res.split():
                        mqttc.publish(f"DATA/{client_id}", msg.decode())
        mqttc.publish("DATA/", f"{client_id}:core.processing_time:{time()-start}:GAUGE")
        if time() -start < ctx["time_slice"]:
            sleep(ctx["time_slice"] - (time() - start))

Le client est en mode parano : TLS activé avec login/pass enforcé coté serveur par MQTT.

On va définir 2 commandes :

pub.sh

#!/usr/bin/env bash
HERE=$( dirname $0 )
pushd $HERE

mosquitto_pub --cert ../cfg/4711.crt --key ../cfg/4711.key --cafile ../cfg/RootCA.crt -h badass.home -t BUS -u 4711 -P 4711 -m "$1"
popd

qui publie en MQTT sur un canal BUS

et
listen.sh

#!/usr/bin/env bash

HERE=$( dirname $0 )
pushd $HERE
mosquitto_sub -h badass.home -t RES/# &
mosquitto_sub -h badass.home -t DATA/# &
popd

La recette

Pour pinger votre agent il vous suffit de faire

pub.sh PING

ce qui répond

'badass':PONG

Pour tester la fonction de test locale :

pub.sh _TEST

Normalement sur sortie standard du process python vous pouvez lire : 'Yo'.

pub.sh "'badass': SEL"

La sortie de LISTEN devrait montrer des lignes comme suit:

badass:cpu.load:1.39:GAUGE
badass:stat.procs_running:1:GAUGE
badass:stat.procs_blocked:1:GAUGE
badass:stat.intr:235643164:DERIVE
badass:stat.ctxt:474453646:DERIVE
badass:stat.processes:237036:DERIVE
badass:ps.processes:320:GAUGE
badass:ps.uninterruptible:1:GAUGE
badass:ps.runnable:1:GAUGE
badass:ps.sleeping:256:GAUGE
badass:ps.idle:62:GAUGE
badass:ps.stopped:0:GAUGE
badass:ps.paging:0:GAUGE
badass:ps.dead:0:GAUGE
badass:ps.zombie:0:GAUGE
badass:files.opened:17184:GAUGE
badass:core.processing_time:0.039983272552490234:GAUGE

Qui sont le résultat de l'enclenchement de la mesure qui se fait toutes les 10 secondes par défaut

pub.sh "20: TSSET"

Passe les mesures à 20 secondes d'écart.

pub.sh "'badass': UNSEL"

Arrête les mesures.

Diverses Questions Réponses

Un forth dans la boucle était il nécessaire ?

Non.

Mais il se trouve que j'en ai un en stock et que je rêvais de l'utiliser pour faire des tâches innocentes (principalement du templating).

Il est pas utilisé, mais disons que si vous faisiez :

pub.sh "2: 2: ADD"

en sortie vous auriez autant de 4: qu'il y a d'agents connectés sur le BUS.

Vous avez de base une calculette 4 opérations distribuées en prime.

Un vrai command & control préférerait un protocole plus passe partout comme https pour être moins visible

Ça tombe bien paho-mqtt et mosquito permettent de passer en websocket :)

Et si je voulais sécuriser ?

MQTT le permet avec des ACL par sujets.

Où est l'arborescente complète du projet il manque les plugins de mesure ?

Les plugins sont ici

Mais c'est bête en fait…

C'est pas faux, c'est pour ça que je sais pas quoi faire avec ce « projet »

Trop petit pour être un projet, ultra dur à tester, mais assez rigolo pour être utile

Des idées de futurs ?

Un projet « Bus Of Things » (BOT) qui standardiserait les commandes envoyées et leurs API pour faire comme une sorte d'ansible.

Une logique d'IPC/messaging générique pour des systèmes distribués (inclurais la gestion de process & co).

Un FORTH qui verrait toute fonction/agent comme reliée à un BUS MQTT et pour lequel les messages serait du FORTH qui agirait sur la fonction que s'appelerio objective FORTH. (Ça implique de sacrément développé la partie langage).

Pleins d'idées, trop d'idées …

Les sorties actuellement ressemblent au format d'entrée … C'est suspect non ?

Oui, j'ai envie de tester de laisser l'orchestrateur accepter des injections de code depuis les agents. Ex légitime, quand une sonde de mesure est en OVERRUN (trop de temps passé à mesurer comparé à une cadence attendue) qu'elle puisse changer la « clock » avec TSSET de l'orchestrateur.

J'ai envie d'expérimenter des systèmes scheduler less où chaque agent peut devenir le contrôleur et prendre la main et/ou modifier l'orchestrateur qui envoie les commandes.

Télécharger ce contenu au format EPUB

Commentaires : voir le flux Atom ouvrir dans le navigateur

Lire la suite…

Profileur mémoire MALT 1.6.0 et support de Python

by Sébastien Valat,Benoît Sibaud,Pierre Jarillon from Linuxfr.org

MALT c'est quoi ?

L'optimisation est une activité connue de bien des développeurs, fouiller, chercher dans son code, pour, peut être, gagner un peu de performance (beaucoup, parfois). Dans cette tâche ardue, face à des codes grandissants, massifs, utilisant de nombreuses bibliothèques externes, un outil central dans ce travail de fourmi : le profileur.

Le profileur fait partie des outils importants pour le développeur qui se soucie des ressources qu'il utilise. Il lui permet de chercher les points chauds dans son code, comprendre le cout de chaque fonction, chaque ligne implémentée. Bien des outils s'intéressent à une chose : bien utiliser votre processeur.

Mais que se passe-t-il si vous rencontrez des difficultés avec l'utilisation de votre mémoire ? Si vous pensez mal utiliser la fonction malloc() du C ou l'opérateur new du C++ ? Si vous avez oublié qu'une de vos variables globales occupe 10 Go (surtout en Fortran) ?

Publié il y a quelques années MALT (licence CeCILL-C) permet de répondre à la question en cherchant toutes les allocations mémoires faites par votre code. Cet outil avait fait l'objet d'un article sur LinuxFR en 2018 lors de sa mise en open source : Profileurs mémoire MALT et NUMAPROF.

Versions 1.6.0

Avancées

Depuis, cet outil fait son chemin avec l'ajout du support de Rust ainsi que nombreuses corrections et ajouts tels que la possibilité de dumper le profile mémoire juste avant que le système ne soit plein.

malt -o dump:on-sys-full-at=80% -o watch-dog=true ./mon_programme

# également :
#  -o dump:on-app-using-rss=10G
#  -o dump:on-app-using-virt=80%
#  -o dump:on-app-using-req=500M

La possibilité de suivre les appels à mmap, mremap, munmap si vous les appelez directement dans votre code au lieu de laisser malloc faire son travail.

Support de python

MALT a initialement été développé dans le contexte du calcul à haute performance — HPC (High Performance Computing) donc surtout pour le C / C++ / Fortran / Rust.

Dans la communauté scientifique, nous voyons dans les laboratoires de plus en plus fleurir l'usage d'un langage à priori bien éloigné de nos prérogatives de performances : Python.

Dans un cadre de calcul scientifique, il est souvent utilisé plutôt comme un wrapper permettant d'appeler et d'orchestrer des bibliothèques en C /C++ / Fortran, elles, performantes. Quoi que l'usage amène aussi à l'écrire de certaines parties du code en Python grâce à Numpy ou Numba pour accéléré la partie calcule sur des tableaux ou autres frameworks d'exploitation des GPU.

La version 1.6.0 de MALT vient d'ajouter le support (encore quelque peu expérimental) natif de Python permettant d'analyser un code pur python ou mix Python / C / C++…. Il s'agit pour l'instant de la première version avec ce support, il reste donc du travail.

Sont supportés les versions Python supérieures à 3.11 ainsi que les environnements Conda / Anaconda / Venv. À l'heure de rédaction de cet article, cela comprend les versions 3.11 à 3.14.

MALT étant orienté C / C++, il ne supporte que Linux comme système d'exploitation. (NdM: la causalité évoquée ici devrait faire réagir des développeurs d'autres systèmes libres notamment :))

Utilisation sur Python

Si la commande malt fonctionne parfaitement, il est recommandé d'utiliser le wrapper malt-python qui adapte quelques configurations spécifiques à Python non encore automatiques.

malt-python ./script.py

# équivalent à 
malt --profile python-default ./script.py

# liste des profiles
malt --profile help

# Afficher le profile
malt-webview ./malt-script-py-6889.json

Profilage rapide

Notons que l'overhead de MALT est important en Python du fait du large nombre d'allocations générées par ce langage et de la méthode de résolution des piles d'appels pour retrouver les lignes dans votre code. Ces détails d'analyse peuvent être désactivés via :

# Désactivé complète de l'analyse des piles
malt-python -p python-no-stack ./my_script.py

# Analyse des piles par "sampling"
malt-python -p python-sampling ./my_script.py

Nouvelle interface

La version 1.6.0 arrive également avec une nouvelle interface graphique avec un code remis à jour
par rapport à sa version originale vieillissante.

Capture annotation python

Profil statique

Pour ceux qui voudraient échanger les profils avec d'autres sur d'autres OS, il est possible depuis la 1.6.0 de générer une version statique des pages de l'interface (hors annotation des sources et arbre d'appel navigable) via :

# Toues les pages possible en statique
malt-webview -static ./report malt-progr-123456.json

# Seulement la page de résumé.
malt-webview -static-summary ./report malt-progr-123456.json

Installation

MALT n'est pas encore disponible dans les distributions classiques, vous devez donc le compiler et l'installer à la main. Le nombre réduit de dépendances obligatoires en fait un outil relativement facile à installer.

On trouvera la procédure dans la documentation du projet.

Documentation

La documentation a été complètement ré-écrite et disponible sur le site officiel : documentation.

Outils similaires pour Python

Découvrir un outil est aussi l'occasion d'en découvrir d'autres. Restons dans le monde du Python, si MALT ne vous convient pas vous trouverez peut-être votre bonheur avec les outils suivants et complémentaires à MALT et eux totalement dédiés au Python toujours pour la mémoire :

  • Memray (Apache Public License 2)
  • Scalene (Apache Public License 2)

MALT se positionne par rapport aux deux présentés en apportant une analyse fine en annotant tout le source code de l'application. Il offre également une analyse des variables globales et TLS coté C/C++/Fortran/Rust.

Télécharger ce contenu au format EPUB

Commentaires : voir le flux Atom ouvrir dans le navigateur

Lire la suite…