Marotte ⛧ a écrit 8780 commentaires

XML est plus qu’un langage de balisage de texte. Il intègre surtout la notion de DTD (document type definition) qui permet de décrire la structure du document et donc de vérifier la conformité d’un document à un modèle.

C’est très utile pour faire par exemple de la transformation de données (ETL) mais pour le tout venant de la documentation, voire même pour des corpus documentaires plus conséquents, XML me semble vraiment overkill.

C’est comme pour un fichier de configuration, utiliser XML n’apporte rien (à part de la verbosité inutile) la plupart du temps.

Si on prends HTML5, qui est si on veut une « application du XML », c’est pour moi un langage d’export, mais pas le format sous lequel on doit stocker lesdits documents.

https://fr.wikipedia.org/wiki/Loopback

Difficile de faire plus isolé. Il y a d’autre mécanismes pour pouvoir faire communiquer des processus qui s’executent sur la même machine mais utiliser IP et le loopback ça permet que ça fonctionne pareil en local comme au travers d’un réseau. C’est très courant.

Maintenant, firefox 52 beta ajoute l'obligation d'avoir pulseaudio ou aucun son ne sort.

C’est une bien mauvaise nouvelle !

Plus précisément, ALSA est abandonné mais il ne faudra pas forcément passer à Pulseaudio…

Il faut passer à JACK ! Tant qu’à installer un serveur de son autant, en prendre un qui déchire.

https://hg.mozilla.org/integration/mozilla-inbound/rev/4ab76338931e

J'ai lu qu'on pouvait écouter le son de plusieurs utilisateurs en même temps mais par réseau.

Je cherche un moyen qui fonctionne en local, si vous avez une astuce ?

Bah je sais pas mais note que tu peux passer « par le réseau » sur ta boucle locale (adresse 127.0.0.1). Je ne connais pas trop mais à mon avis c’est comme qu’il faut faire pour que le son soit accessible pour plusieurs personne en même temps, bien qu’étant sur la même machine.

Mais du coup, quel intérêt à « utiliser du son avec les deux en même temps » ? Je veux dire, si ça sort au final sur la même carte son (et même deux cartes sons, si elles sont branchées à des haut-parleur dans la même pièce…), tu vas écouter deux flux audio en même temps ?

Bref, je n’ai peut-être pas bien compris ton problème à mon avis.

ça dépends des gens

Il y a moins de chance de faire une fôte de frappe sur ``` ou .... (et ça va plus vite à taper) qu’écrire <code>, je trouve :)

Ensuite, en précisant le langage, pour profiter de la coloration syntaxique, qui est selon moi un must pour de la documentation technique, et bien tu sais en lisant le source que tu as affaire à du code (c’est même plus précis que le mot « code » lui même…)

En asciidoc ça donne :

[source,ruby]
----
require 'sinatra' // <1>

get '/hi' do // <2>
  "Hello World!" // <3>
end
----

et tu peux utiliser le nombre de tiret que tu veux, tu peux en mettre plein pour que ce soit plus lisible en texte brut (ou pouvoir avoir des lignes telles que '----' à l’intérieur du bloc…

et là en markdown pour le coup c’est simplifié au maximum : ```ruby

http://asciidoctor.org/docs/asciidoc-syntax-quick-reference/#source-code

L’exemple m’a bien fait rire :

error: The requested operation returned error: 1954 Forbidden search for defensive operations manual
absolutely fatal: operation initiation lost in the dodecahedron of doom
would you like to die again? y/n

Arf TL;DR, my bad, god save the queen

J’ai souvent entendu parler de AsciiDoctor en cherchant de l’info sur Asciidoc, j’ai cru comprendre qu’il s’agissait d’une sorte de sur-couche à Asciidoc. Je me suis orienté vers le premier plutôt que le deuxième en me disant qu’il valait mieux assimiler la base avant d’aborder un outil plus évolué. Je m’étais effectivement fait la réflexion qu’il faudrait sûrement que je m’oriente vers AsciiDoctor in fine, ton commentaire semble confirmer cette impression.

Cela dit Asciidoc répond à mes besoins pour l’instant mais je vais quand même suivre d’un peu plus près Asciidoctor, pour voir ce qu’il peut éventuellement m’apporter. C’est sûr que s’il intègre la génération du PDF, pour son adoption par le plus grand nombre c’est un atout.

Personne ne parle de Asciidoc ?

Je trouve le langage (la version texte donc) un peu moins naturelle que le markdown original pour les trucs de base mais au niveau des formats de sortie ça fait entre autre du HTML5 (c’est ce que j’utilise), ou du DocBook justement…

Donc oui, il te faut un autre outil pour générer le PDF mais c’est pas la mort à ajouter à ton workflow.

Pour le HTML5 il y a la possibilité d’intégrer les images directement (encodées en base64 dans la page), pour diffuser un document "normal" c’est parfait. Une autre chose que j’apprécie c’est qu’il y a une syntaxe qui permet de faire des tableaux aussi lisibles dans le source que dans le rendu, ou bien tu peux mettre directement du CSV (vive le contenu dynamique).

Quelle galère d’utiliser un traitement de texte WYSIWYG quand tu as appris à utiliser Asciidoc, à chaque fois faut vraiment que je me force…

Il n'y a pas de piège dans le poste.

Ah ok merci. C’est bien de le préciser :)

Je ne gère pas l'aspect salaire (j'anticipe les commentaires).

Je ne comprends pas… Tu es chargé du recrutement ou tu ne l’es pas ?

le boot sur SD, tu as raison de laisser tomber, ça à l'air bien bien bien complexe

Ce n’est pas si complexe que ça. Si tu as une image bootable pour une clé USB elle ira très bien sur une carte SD. Ça va surtout se jouer au niveau du BIOS (EFI whatever…) donc du matériel. Cela dit que je pense que tous les PC récents bootent sans problème sur le lecteur SD.

Enfin oui, ce qui est complexe c’est de maintenir deux GRUB, dont l’un devra être « installé manuellement » (ie: pas par l’installeur de la distribution lors de l’installation…), après… ça permet de comprendre un peu mieux comment fonctionne GRUB.

sans avoir de réel atout dans ta configuration.

Oui, je vois toujours pas pourquoi il a cette idée :)

Ubuntu car la plus connue, celle avec laquelle tu auras le plus de documentations sur les internets.

Oui. La documentation en français d’Ubuntu est bien faite. Elle s’applique souvent à Debian (forcément) et à d’autres distributions (pour ce qui est des généralités)

Et pour tester différentes distributions, les machines virtuelles ça fait gagner du temps, c’est sûr !

Par rapport au possibilité que je voulais mettre en place, deux possibilité sont "commandable" par la présence ou l'absence de la carte SD.

C’est possible de faire ainsi mais c’est plutôt compliqué. Je vois toujours pas l’intérêt :)

Il faut que GRUB soit installé et sur le disque, ET sur la carte. Ton BIOS configuré pour booter : 1 la carte, 2 le disque dur interne. Le GRUB de la carte configuré pour booter Linux et celui du disque pour booter Windows (ou l’inverse). Ça devrait le faire, en théorie.

Encore une fois je ne vois pas l’intérêt (pour le dire plus prosaïquement : pourquoi tu veux te faire chier :) Si c’est un problème de vie privée tu ferais mieux de chiffrer ton /home, ça te demandera un mot de passe supplémentaire à entrer au démarrage, et quelqu’un qui démarrerait un autre système pour aller lire le disque ne pourra pas le faire…

Retirer de l'OS de windows ce qui permet de le lancer

Alors là non. Pas du tout. (une étape de moins \o/). En fait GRUB se contente de passer la main au chargeur de démarrage de Windows (Windows aussi peut le faire, mais à peu près personne ne doit faire ça…)

je dois passer par lui pour l'installation de Linux

Non.

ou il s'agit d'un CD ou d'une clé bootable que je dois faire (comme pour windows).

Clé bootable !

Bon, en vrai il y a moyen « d’installer Linux à partir de Windows » mais c’est plutôt… exotique… donc oublie ;)

Comme a écrit NeoX (et moi aussi dans mon précédent message), l’important c’est que tu laisses bien un espace libre (ie: non partitionné) quand tu installes Windows. L’installeur de Linux te partitionnera cet espace libre comme il faut, tout seul comme un grand.

Oulala…

SD comme interrupteur physique pour sélectionner quel OS boot.

C’est possible. Il faut installer GRUB sur la carte.

ce serait finalement contraignant sur la limite à deux images bootables maximum

Ce serait contraignant, c’est sûr… Si tu fais ça, garde un autre média pour booter au cas où tu perdes la carte SD :)

Par contre je ne vois pas de quoi tu veux parler avec cette limite de deux images ?

De ce que j’avais compris tu comptais utiliser la carte pour démarrer un système se trouvant lui même sur le disque dur, pas installer directement un OS sur la carte…

mon lecteur de carte est inutilisable pour quoi que ce soit d'autre.

Ah oui, si tu installes carrément l’OS sur la clé… c’est qu’en plus ça va ramer… le débit de lecture et d’écriture est pas le même entre un disque sur SATA et un disque sur USB (le lecteur de carte c’est de l’USB)

À condition d’installer Windows avant Linux (en prenant soin de laisser de l’espace libre sur le disque lors de l’installation de Windows, pour pas avoir à "re-sizer" une partition lors de l’installation de Linux…) le système (GRUB en l’occurrence) te permettra de choisir entre Windows et Linux.

GRUB est parfois configuré avec les options :

GRUB_DEFAULT=saved
GRUB_SAVEDEFAULT=true
ce qui fait que l’OS qui démarre par défaut (si aucun choix après N secondes) c’est le dernier OS démarré. Ça se modifie bien sûr.

Il faut installer Windows en premier car, ensuite, l’installation de Linux va détecter le Windows et ajouter une entrée au menu de GRUB pour démarrer ce système. Alors que si tu fais l’inverse, Windows ne va pas être aussi « gentil », il va remplacer purement et simplement GRUB par son propre chargeur de démarrage, sans créer d’entrée pour Linux ! Il faut ensuite redémarrer le Linux en utilisant un système live pour réinstaller GRUB… Pourtant, techniquement, rien n’empêcherait Windows de faire pareil… (ajouter une entrée de menu dans son chargeur de démarrage pour passer la main au chargeur de démarrage de l’autre OS…)

Je ne voudrais pouvoir lancer windows que si la carte SD est insérée.

Pourquoi ?

Bon alors pour mon exemple ça ne sert à rien d’avoir des sockets non-bloquantes puisse qu’il y en a qu’une mais dans le cas où on devrait en manipuler plusieurs on peut faire ainsi :

#!/usr/bin/env python3

import sys
import subprocess
import socket
import signal
import select
import os

pidFilename = '/tmp/'+sys.argv[0]+'.pid'

def graceful_exit(signum, frame):

    print('I terminate, my PID is '+str(os.getpid())+' and I received signal '+str(signum)+'', file=sys.stderr, flush=True)
    sys.exit(0)

try:

    if sys.argv[1] == 'start':

        sleeper = subprocess.Popen([sys.argv[0], 'run'], stdin=subprocess.PIPE, shell=False)
        pidfile = open(pidFilename,'w')
        _pid = str(sleeper.pid)
        pidfile.write(_pid)
        pidfile.close()

    elif sys.argv[1] == 'run':

        signal.signal(signal.SIGTERM, graceful_exit)
        signal.signal(signal.SIGINT, graceful_exit)

        server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server.bind(('127.0.0.1', 1234))
        server.setblocking(0)
        server.listen(3)


        while True:

            _sockets_ready = select.select([server],[],[])
            client, addr = _sockets_ready[0][0].accept()

            message = client.recv(65535).decode('UTF-8')

            if message:

                print('I’m alive, my PID is '+str(os.getpid())+' and I’ve been told to say : « '+message+' »', file=sys.stderr, flush=True)


    elif sys.argv[1] == 'stop':        

        try:

            pidfile = open(pidFilename,'r')
            os.kill(int(pidfile.read()), signal.SIGTERM)
            pidfile.close()
            os.unlink(pidFilename)

        except (FileNotFoundError, ProcessLookupError):

            pass

    elif sys.argv[1] == 'say' and len(sys.argv) > 1:

        try:

            client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            client.connect(('127.0.0.1', 1234))
            client.send(bytes(sys.argv[2],'utf8'))

        except ConnectionRefusedError as e:

            print(str(e), file=sys.stderr)

except IndexError as e:

    print(str(e), file=sys.stderr)

C’est le select qui prend en objet les trois listes de sockets (potential_readers, potential_writers, potential_errs) et retourne ces trois listes avec seulement les sockets qui sont prêtes :

_sockets_ready = select.select([server],[],[])
client, addr = _sockets_ready[0][0].accept()
message = client.recv(65535).decode('UTF-8')

Ici le accept() n’aura pas lieu tant qu’il n’y a rien à lire sur la socket 'server', « bloquant » ainsi la boucle while, qui n’a effectivement aucune raison de tourner s’il n’y a rien à lire…

https://docs.python.org/3/howto/sockets.html#non-blocking-sockets

J’espère ne pas avoir raconté trop de connerie et qu’on me corrigera le cas échéant.

En utilisant une socket de type AF_INET c’est un peu différent.

#!/usr/bin/env python3

import sys
import subprocess
import socket
import signal
import os

pidFilename = '/tmp/'+sys.argv[0]+'.pid'

def graceful_exit(signum, frame):

    print('I terminate, my PID is '+str(os.getpid())+' and I received signal '+str(signum)+'', file=sys.stderr, flush=True)
    sys.exit(0)

try:

    if sys.argv[1] == 'start':

        sleeper = subprocess.Popen([sys.argv[0], 'run'], stdin=subprocess.PIPE, shell=False)
        pidfile = open(pidFilename,'w')
        _pid = str(sleeper.pid)
        pidfile.write(_pid)
        pidfile.close()

    elif sys.argv[1] == 'run':

        signal.signal(signal.SIGTERM, graceful_exit)
        signal.signal(signal.SIGINT, graceful_exit)

        server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server.bind(('127.0.0.1', 1234))
        server.listen(3)


        while True:


            client, addr = server.accept()
            message = client.recv(65535).decode('UTF-8')

            if message:

                print('I’m alive, my PID is '+str(os.getpid())+' and I’ve been told to say : « '+message+' »', file=sys.stderr, flush=True)


    elif sys.argv[1] == 'stop':        

        try:

            pidfile = open(pidFilename,'r')
            os.kill(int(pidfile.read()), signal.SIGTERM)
            pidfile.close()
            os.unlink(pidFilename)

        except (FileNotFoundError, ProcessLookupError):

            pass

    elif sys.argv[1] == 'say' and len(sys.argv) > 1:

        client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        client.connect(('127.0.0.1', 1234))
        client.send(bytes(sys.argv[2],'utf8'))


except IndexError as e:

    print(str(e), file=sys.stderr)

Merci pour ta réponse. Je peux continuer à ouvrir mon fifo dans la boucle si je le mets en bloquant et que je le ferme une fois que j’ai lu mes 65535 caractères :

while True:

    _fifo = os.open(fifoFilename, os.O_RDONLY)
    _message = os.read(_fifo, 65535).decode('UTF-8')

    if _message:

        print('I’m alive, my PID is '+str(os.getpid())+' and I’ve been told to say : « '+_message+' »', file=sys.stderr, flush=True)

    os.close(_fifo)

Là ça fonctionne comme je veux.

Mais du coup je suis parti sur l’utilisation d’une socket…

L’avantage d’une socket, si j’ai bien compris, c’est que je pourrais remplacer facilement, de manière transparente, ma socket UNIX par une socket INET, pour faire communiquer mes deux processus s’ils ne tournaient pas sur la même machine…

Après quelques recherches il me semble que les sockets puissent également être une solution à mon problème.

J’arrive à ça, en essayant de faire exactement l’équivalent du premier script mais en utilisant socket :

#!/usr/bin/env python3

import sys
import subprocess
import socket
import signal
import os

pidFilename = '/tmp/'+sys.argv[0]+'.pid'
socketFilename = '/tmp/'+sys.argv[0]+'.socket'

def graceful_exit(signum, frame):

    print('I terminate, my PID is '+str(os.getpid())+' and I received signal '+str(signum)+'', file=sys.stderr, flush=True)
    sys.exit(0)

try:

    if sys.argv[1] == 'start':

        sleeper = subprocess.Popen([sys.argv[0], 'run'], stdin=subprocess.PIPE, shell=False)
        pidfile = open(pidFilename,'w')
        _pid = str(sleeper.pid)
        pidfile.write(_pid)
        pidfile.close()

    elif sys.argv[1] == 'run':

        signal.signal(signal.SIGTERM, graceful_exit)
        signal.signal(signal.SIGINT, graceful_exit)

        if os.path.exists(socketFilename):

            os.remove(socketFilename)

        server = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
        server.bind(socketFilename)

        while True:

            _message = server.recv(65535).decode('UTF-8')

            if _message:

                print('I’m alive, my PID is '+str(os.getpid())+' and I’ve been told to say : « '+_message+' »', file=sys.stderr, flush=True)

    elif sys.argv[1] == 'stop':        

        try:

            pidfile = open(pidFilename,'r')
            os.kill(int(pidfile.read()), signal.SIGTERM)
            pidfile.close()
            os.unlink(pidFilename)

        except (FileNotFoundError, ProcessLookupError):

            pass

    elif sys.argv[1] == 'say' and len(sys.argv) > 1:

        if os.path.exists(socketFilename):

            client = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
            client.connect(socketFilename)
            client.send(bytes(sys.argv[2],'utf8'))
            client.close()

except IndexError as e:

    print(str(e), file=sys.stderr)

J’ai du mal à appréhender les pour et les contre de chaque méthode.

En tous cas avec socket je n’ai pas besoin de faire ce truc crade avec sleep()… ça répond tout de suite, et ça n’interfère pas avec le stdin de mon terminal…

sleeper = subprocess.Popen([sys.argv[0], 'run'], stdin=subprocess.PIPE, shell=False)

Il ne faut pas préfixer avec './' !

D’un autre côté c’est justement ce qu’il dénonce, l’omniprésence des géants comme Adobe qui verrouillent la technologie.

S’il avait pu faire cette « campagne numérique » qu’avec du libre et des services « équitables et ouverts » on lui aurait dit : « Bah tu vois bien Jean-Luc ! Tu vois des problèmes où il n’y en a pas ! » :)

OK Je comprends un peu mieux.

~$ krunner
Gtk-Message: Failed to load module "gail"
Gtk-Message: Failed to load module "atk-bridge"
Invalid Context= "Mimetypes" line for icon theme: "/usr/share/icons/Faba/symbolic/mimetypes/"
Icon theme "elementary" not found.
QDBusConnection: name 'org.kde.kglobalaccel' had owner '' but we thought it was ':1.119'
detected kglobalaccel restarting, re-registering all shortcut keys

En cherchant (vite fait) sur Google à partir de ton message d’erreur je tombe sur :

https://forum.manjaro.org/t/kcalc-dead/1204

Un problème de thème non installé ?

Cherche aussi avec Failed to load module "gail" et Failed to load module "atk-bridge"

Il manque peut-être des « bouts de KDE »… Peut-être un service de KDE qui ne tourne pas et dont krunner a besoin…

Je t’avoue que je sèche, je ne connais pas bien KDE. Bon courage quand même.

Il y a des chances. L’installation va être sûrement un peu conséquente si tu n’utilises aucun logiciel KDE pour le moment. Il va falloir pas mal de bouts de KDE. Ce n’est pas un problème à moins que tu sois ricrac sur l’espace disque. Personnellement j’utilise quelques application de KDE sous Xfce sans trop problème. Elles n’ont juste pas forcément le même look et la même ergonomie, puissent qu’elles sont à la base faites pour s’intégrer avec un environnement de bureau en particulier mais c’est tout.

Pour en revenir à ta question. krunner (que je ne connais pas) semble être un lanceur, pourtant il y a l’équivalent sous Xfce ? Tu peux mettre un lanceur sur le bureau ou dans un panel ?

Et baloo semble être un framework d’indexation destiné à être utilisé par d’autres applications… ? C’est pour krunner ?

Si c’est pour simplement indexer (mais tu connais p-e déjà) c’est updatedb et locate. La première commande indexe, tu la fais tourner régulièrement, à la fréquence désirée, et la seconde te permet de retrouver un fichier très rapidement.

$ locate issue.net
/etc/issue.net
Les options de locate sont de plus haut niveau que celles de find. Il y en a donc moins, la courbe d’apprentissage est plus rapide. Sans compter que find cherche « en direct » et n’indexe rien…

Les diverses GUI d’indexation se base sur ces commandes ou sur les mêmes bibliothèques qu’elles.

locate lui ne dépend que du minimum, ici :

$ ldd /usr/bin/locate
linux-vdso.so.1 (0x00007ffc04319000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007ff4f602f000)
/lib64/ld-linux-x86-64.so.2 (0x00005586d17c1000)


Bon, même moi j’ai compris le principe :)

donc tu n'iras pas "plus vite", tu emets/recois potentiellement plus de paquets puisque tu encapsule tes requetes HTTP/TCP dans une enveloppe UDP

Le truc c’est qu’il assemble tous les paquets (en l’occurrence pour du web : tous les paquets nécessaires pour afficher la page) avant d’envoyer le tout, via le VPN, à son utilisateur.

Du coup, du point de vu de l’utilisateur « ça va plus vite © », c’est Freedom-ip qui se bouffe les latences mais qui a par ailleurs une meilleure connexion à Internet qu’une box ADSL dans la cambrousse…

Le temps « freedom-ip récupère la page sur internet (TCP) + l’envoi à son abonné (UDP) » est plus court que « l’abonné récupère directement sa page en TCP depuis Internet »

Cela dit je me pose quand même une question, un paquet UDP pouvant ne pas arriver à destination, est-ce que cette méthode n’est pas parfois contre-productive (ie: la page va au final se charger moins vite) dans certains cas ?

Arf… Dans ce cas oui mais on a plus exactement affaire à un simple VPN, si je ne dis pas de bêtise.

À moins que ce soit la norme pour un VPN d’avoir un tel cache ?

Je n’arrive pas à joindre ton site, le proxy du boulot me bloque pour « proxy avoidance » :) J’irai voir ce soir…

Ai-je parlé de temps de réponse quelque part ? Non.

Ai-je parlé de navigation plus rapide ? Oui.

Par contre cela ne pourra pas accélérer les téléchargements, on est d'accord ;)

J’ai un peu de mal à voir comment tu peux avoir une « navigation plus rapide » si ni le débit ni le temps de réponse ne sont concernés…

Je ne dis pas que tu as tort, je n’y connais moi-même pas grand-chose en réseau, je me (donc te) pose une question c’est tout.

Hypothèse : la route n’est pas la même ?

Tu as une source pour étayer cette information ?

Non parce que comme les précédents participants j’ai écarquillé les yeux en lisant ça :)

Je ne vois vraiment pas comment le temps de réponse (ie: le ping) pourrait être plus court en passant par un hôte supplémentaire…

un compresseur dont j'évalue mal la fonction

Pour faire simple, un compresseur va augmenter le volume des sons faibles et réduire le volume des sons forts…

Un exemple, en haut le signal d’origine (une intro guitare-basse-batterie-voix), en bas le signal (très fortement) compressé :

Un usage assez pratique de la compression dans VLC c’est quand tu regardes un film et que tu veux entendre quand ça chuchote sans pour autant saigner des tympans quand il y a une explosion ou que ça crie :)

Je sais qu’on utilise souvent le compresseur en bout de chaîne (ie: sur le master) mais je ne sais pas du tout ce qu’il en est de son utilisation directement sur un instrument.