tag:linuxfr.org,2005:/users/laurentuLinuxFr.org : les contenus de passke2021-06-04T18:31:43+02:00/favicon.pngtag:linuxfr.org,2005:Diary/397682021-05-14T20:11:49+02:002021-05-15T09:16:03+02:00UML est vivantLicence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<h2 class="sommaire">Sommaire</h2>
<ul class="toc">
<li><a href="#toc-cr%C3%A9ation-du-rootfs-avec-buildroot">Création du rootfs avec buildroot</a></li>
<li><a href="#toc-user-mode-linux">User Mode Linux</a></li>
<li><a href="#toc-compilation-dun-noyau-linux-en-mode-user">Compilation d'un noyau Linux en mode user</a></li>
</ul>
<p>Salut Nal,</p>
<p>Il y a longtemps, bien longtemps, les solutions de virtualisation libres sous <em>Linux</em> n'étaient pas bien nombreuses. <br>
Pas de <em>kvm</em>, <em>docker</em>, <em>lxc</em> ou <em>podman</em> et <em>qemu</em> en était à ses débuts.</p>
<p>Il existait des solutions légères comme <a href="http://linux-vserver.org/"><em>linux-vservers</em></a> et <a href="https://openvz.org/"><em>openvz</em></a> mais qui nécessitaient un patch du noyau <em>Linux</em> (pour la petite histoire, il s'agissait de solutions qui aujourd'hui entreraient dans la catégorie conteneurs).</p>
<p>Si tu avais de la chance, ta distribution fournissait des noyaux patchés (c'était le cas de la Debian par exemple), mais sinon tu avais droit à une recompilation du noyau.</p>
<p>C'est là que "user mode linux" entrait en jeu, car il te permettait de tester ton noyau fraîchement compilé sans avoir à l'installer sur une machine physique au risque de la voir se planter au démarrage.</p>
<p>"User Mode Linux" ou plus simplement <em>UML</em> c'était à l'époque un noyau <em>Linux</em> patché qui pouvait être lancé comme un exécutable standard dans un système existant. <br>
On lui fournissait une image de système de fichier pour qu'il puisse démarrer un système (plus ou moins) complet, dans l'espace utilisateur, et ce sans privilèges particuliers.</p>
<p>D'abord conçu pour tester les noyaux, il était aussi possible de l'utiliser comme solution de virtualisation.</p>
<p>En terme de performance, il était bien en-dessous des solutions type conteneurs comme <em>openvz</em>, mais meilleur que des solutions de virtualisation pure telle que <em>qemu</em> ou <em>bochs</em>.</p>
<p>Je me suis récemment lancé dans la construction d'un système minimaliste avec <a href="https://buildroot.org/"><em>buildroot</em></a> et je me suis demandé comment tester ce système au fur et à mesure de sa progression.</p>
<p>J'aurai bien évidemment pu utiliser <em>kvm</em>, mais en cherchant un peu j'ai vu que <em>UML</em> était toujours bien vivant, et qu'en plus la Debian fournissait un noyau précompilé.<br>
En plus <em>buildroot</em> semblait capable de générer un système de fichier tel que <em>UML</em> devrait pouvoir le gérer.</p>
<p>Alignement de planètes, il fallait que j'essaie.</p>
<h2 id="toc-création-du-rootfs-avec-buildroot">Création du rootfs avec buildroot</h2>
<p>Le but est d'avoir un système Linux minimaliste en utilisant notamment busybox.<br>
<em>buildroot</em> permet de générer un tel système non seulement pour l'architecture sur laquelle il lancé, mais également pour d'autres architectures, pour les <em>raspberry PI</em> par exemple.</p>
<p>Il automatise la mécanique de compilation croisée nécessaire à la création d'un tel système tout en intégrant la possibilité d'installer toute un série de logiciels.</p>
<p>On commence par télécharger et extraire la version stable de <em>buildroot</em> (la 2021-02-2 au moment ou j'écris ceci).</p>
<pre><code class="bash">wget https://buildroot.org/downloads/buildroot-2021.02.2.tar.gz
tar xzf buildroot-2021.02.2.tar.gz
<span class="nb">cd</span> buildroot-2021.02.2/</code></pre>
<p>Pour fonctionner, il est indispensable d'installer un certain nombre de dépendances:</p>
<pre><code class="bash">sudo apt install build-essential libncurses-dev unzip rsync bc</code></pre>
<p>La première étape consiste à configurer la cible que l'on désire générer.<br>
Pour cela <em>buildroot</em> propose un menu très détaillé lorsque l'on passe la commande <code>make menuconfig</code>.</p>
<p>Pour un premier essai, j'ai configuré les éléments suivants:</p>
<ul>
<li>Target options -> Target Architecture (x86_64)</li>
<li>Filesystem images -> [*] ext2/3/4 root filesystem -> ext2/3/4 variant (ext4)</li>
</ul>
<p>Il est maintenant possible de générer l'image du système avec <em>make</em>, mais attention cela va prendre un peu de temps et de disque.<br>
Si tu as plusieurs coeurs (de processeurs) disponibles, tu peux utiliser l'option <code>-j<n></code> pour lancer <strong>n</strong> constructions parallèles histoire de réduire le temps de compilation.</p>
<pre><code class="bash">make -j2</code></pre>
<p>A la fin du processus l'image générée est <em>output/images/rootfs.ext4</em>.</p>
<h2 id="toc-user-mode-linux">User Mode Linux</h2>
<p>Le <a href="http://user-mode-linux.sourceforge.net/">site officiel</a> peut facilement laisser penser que le projet est moribond. <br>
Il faut fouiller un peu plus pour voir que depuis un bon moment <em>UML</em> est intégré au noyau <em>Linux</em> standard.</p>
<p>On trouve dans la <a href="https://www.kernel.org/doc/html/v5.12/virt/uml/user_mode_linux_howto_v2.html">documentation</a> des noyaux récents une section dédiée à <em>UML</em> bien plus à jour et utile.</p>
<p>La version <em>Buster</em> de Debian fournit un noyau <em>UML</em> pré-compilé et correspondant au noyau de la distribution. <br>
Pour l'installer il suffit d'un <code>apt install user-mode-linux</code>.</p>
<p>Le paquet fourni donc l'exécutable <em>/usr/bin/linux</em> ainsi qu'une série de modules pour ce noyau dans <em>/usr/lib/uml/modules</em>.</p>
<p>Pour lancer notre système il nous suffit de passer la commande suivante:</p>
<pre><code class="bash">linux <span class="nv">mem</span><span class="o">=</span>256M <span class="nv">ubd0</span><span class="o">=</span>output/images/rootfs.ext4 <span class="nv">umid</span><span class="o">=</span><span class="nb">test</span>
Core dump limits :
soft - <span class="m">0</span>
hard - NONE
Checking that ptrace can change system call numbers...OK
Checking syscall emulation patch <span class="k">for</span> ptrace...OK
Checking advanced syscall emulation patch <span class="k">for</span> ptrace...OK
...
Run /sbin/init as init process
random: fast init <span class="k">done</span>
EXT4-fs <span class="o">(</span>ubda<span class="o">)</span>: re-mounted. Opts: <span class="o">(</span>null<span class="o">)</span>
Starting syslogd: OK
Starting klogd: OK
Running sysctl: OK
Initializing random number generator: OK
Saving random seed: random: dd: uninitialized urandom <span class="nb">read</span> <span class="o">(</span><span class="m">512</span> bytes <span class="nb">read</span><span class="o">)</span>
OK
Starting network: OK
Welcome to Buildroot
buildroot login: root
<span class="c1"># </span></code></pre>
<p>Voilà, tu viens de lancer un système Linux/busybox en tant qu'utilisateur non privilégié et tu peux t'amuser en tant que <em>root</em> dans ce système.</p>
<p>Si ça ne fonctionne pas tu auras l'occasion pour une fois de faire un:</p>
<pre><code class="bash">killall linux</code></pre>
<p>Un point intéressant est que tu peux facilement avoir accès au système de fichier de l'hôte grâce à <em>hostfs</em>.<br>
Par exemple pour monter dans ton <em>UML</em> le répertoire utilisateur de l'hôte:</p>
<pre><code class="bash">mount -t hostfs -o /home/passke hostfs /mnt
mount
/dev/root on / <span class="nb">type</span> ext4 <span class="o">(</span>rw,relatime<span class="o">)</span>
devtmpfs on /dev <span class="nb">type</span> devtmpfs <span class="o">(</span>rw,relatime,mode<span class="o">=</span><span class="m">755</span><span class="o">)</span>
proc on /proc <span class="nb">type</span> proc <span class="o">(</span>rw,relatime<span class="o">)</span>
devpts on /dev/pts <span class="nb">type</span> devpts <span class="o">(</span>rw,relatime,gid<span class="o">=</span><span class="m">5</span>,mode<span class="o">=</span><span class="m">620</span>,ptmxmode<span class="o">=</span><span class="m">666</span><span class="o">)</span>
tmpfs on /dev/shm <span class="nb">type</span> tmpfs <span class="o">(</span>rw,relatime,mode<span class="o">=</span><span class="m">777</span><span class="o">)</span>
tmpfs on /tmp <span class="nb">type</span> tmpfs <span class="o">(</span>rw,relatime<span class="o">)</span>
tmpfs on /run <span class="nb">type</span> tmpfs <span class="o">(</span>rw,nosuid,nodev,relatime,mode<span class="o">=</span><span class="m">755</span><span class="o">)</span>
sysfs on /sys <span class="nb">type</span> sysfs <span class="o">(</span>rw,relatime<span class="o">)</span>
hostfs on /mnt <span class="nb">type</span> hostfs <span class="o">(</span>rw,relatime,/home/passke<span class="o">)</span></code></pre>
<p>Le noyau de ton <em>UML</em> ne peut pour l'instant pas charger de modules, le répertoire <em>/lib/modules</em> étant vide.<br>
Mais comme cité plus haut, la Debian fournit les modules nécessaires sur l'hôte dans <em>/usr/lib/uml/modules</em> et il suffit donc de le monter au bon endroit:</p>
<pre><code class="bash">mkdir /lib/modules
mount -t hostfs -o /usr/lib/uml/modules/ hostfs /lib/modules
modprobe loop
loop: module loaded</code></pre>
<h2 id="toc-compilation-dun-noyau-linux-en-mode-user">Compilation d'un noyau Linux en mode user</h2>
<p>Pour l'instant on a utilisé le paquet fourni par la distribution, mais on peut également compiler un noyau récent en mode user assez facilement.</p>
<p>La première étape consiste assez classiquement à télécharger et extraire une version du noyau à partir de <em>kernel.org</em>.</p>
<pre><code class="bash">wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.12.4.tar.xz
tar xJf linux-5.12.4.tar.xz
<span class="nb">cd</span> linux-5.12.4/</code></pre>
<p>Puis on installe quelques dépendances:</p>
<pre><code class="bash">sudo apt install flex bison</code></pre>
<p>D'habitude pour configurer un noyau on utilise le fichier de configuration fourni par la distribution (dans <em>/boot</em> sur Debian).</p>
<p>Pour <em>UML</em>, c'est un peu différent, on commence par générer une nouvelle configuration en précisant qu'il s'agit d'une architecture <em>um</em> (=user mode).<br>
Puis le reste du processus est identique à la compilation d'un noyau classique, excepté qu'il faut systématiquement préciser l'architecture <em>um</em>.</p>
<pre><code class="bash">make defconfig <span class="nv">ARCH</span><span class="o">=</span>um
make menuconfig <span class="nv">ARCH</span><span class="o">=</span>um
make <span class="nv">ARCH</span><span class="o">=</span>um</code></pre>
<p>Le processus devrait avoir généré un fichier exécutable <em>linux</em> à la racine des sources, et on peut donc maintenant lancer notre <em>UML</em> avec un noyau plus récent:</p>
<pre><code class="bash">./linux <span class="nv">mem</span><span class="o">=</span>256M <span class="nv">ubd0</span><span class="o">=</span>../buildroot-2021.02.2/output/images/rootfs.ext4 <span class="nv">umid</span><span class="o">=</span><span class="nb">test</span>
Initializing random number generator: OK
Saving random seed: random: dd: uninitialized urandom <span class="nb">read</span> <span class="o">(</span><span class="m">512</span> bytes <span class="nb">read</span><span class="o">)</span>
OK
Starting network: OK
Welcome to Buildroot
buildroot login: root
<span class="c1"># uname -a</span>
Linux buildroot <span class="m">5</span>.12.4 <span class="c1">#1 Fri May 14 15:13:12 CEST 2021 x86_64 GNU/Linux</span></code></pre>
<p>Pour l'instant par de modules du noyau disponbiles, on va arranger ça vite fait (sur l'hôte):</p>
<pre><code class="bash"><span class="nb">export</span> <span class="nv">INSTALL_MOD_PATH</span><span class="o">=</span>../modules
make modules_install <span class="nv">ARCH</span><span class="o">=</span>um</code></pre>
<p>On peut maintenant les utiliser dans l'<em>UML</em>:</p>
<pre><code class="bash">mount -t hostfs -o /home/passke/modules/lib/modules hostfs /lib/modules
modprobe loop
loop: module loaded</code></pre>
<p>Je vais m'arrêter là, mais il y a encore plein de choses à expérimenter, le réseau par exemple.<br>
De ce côté, même si la configuration reste un peu complexe, elle a quand même bien évolué.</p>
<p><em>UML</em> peut être intéressant par exemple pour faire de la virtualisation sur des machines ne disposant pas du support <em>kvm</em>, ou alors pour expérimenter des fonctionnalités offertes par les noyaux récents, <a href="https://ebpf.io/">eBPF</a> par exemple ou alors construire des images sans avoir besoin des droits <em>root</em> sur le système hôte. </p>
<div><a href="https://linuxfr.org/users/laurentu/journaux/uml-est-vivant.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/124278/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/laurentu/journaux/uml-est-vivant#comments">ouvrir dans le navigateur</a>
</p>
passkehttps://linuxfr.org/nodes/124278/comments.atomtag:linuxfr.org,2005:Diary/397022021-04-07T21:49:41+02:002021-04-07T21:49:41+02:00BAN de ADDOKLicence CC By‑SA http://creativecommons.org/licenses/by-sa/4.0/deed.fr<p>La <a href="https://www.data.gouv.fr/fr/datasets/base-adresse-nationale/">BAN</a> (Base Adresse Nationale) est un jeu de données publié en Open Data et issu d'une collaboration entre plusieurs acteurs (communes, IGN, La Poste, OpenStreetMap,…).</p>
<p>La BAN contient 25 millions d'adresses françaises géocodées ainsi que d'autres informations (population des communes par exemple).</p>
<p>Elle est notamment utilisée pour fournir l'API publique <a href="https://geo.api.gouv.fr/adresse">Adresse</a>.</p>
<p><a href="https://github.com/addok/addok">ADDOK</a> est un moteur de géocodage open source développé par l'<a href="https://www.etalab.gouv.fr/">Etalab</a>. C'est ce moteur qui fourni l'API Adresse citée précédemment.</p>
<p>Ces deux éléments étant disponibles librement, il est donc possible de monter son propore service de géocodage reposant sur des données fiables.</p>
<p>Le projet ADDOK fourni une <a href="https://addok.readthedocs.io/en/latest/install/">documentation</a> plutôt bien réalisée sur l'installation du logiciel et son alimentation par la BAN, mais elle date un petit peu. Je vous propose ici une version simplifiée et un peu plus à jour pour une Debian Buster.</p>
<p>Dans un premier temps on commence par installer un certain nombre de pré-requis.</p>
<pre><code class="bash">sudo apt install redis-server python3.7 python3.7-dev python-pip python3.7-venv</code></pre>
<p>Le reste de l'installation et de la configuration peut se faire en tant qu'utilisateur standard.</p>
<p>On commence par créer un <em>venv</em> dédié.</p>
<pre><code class="bash"><span class="nb">cd</span> <span class="nv">$HOME</span>
python3.7 -m venv addok
<span class="nb">source</span> addok/bin/activate</code></pre>
<p>Une fois dans le <em>venv</em> on installe Addok.</p>
<pre><code class="bash">pip install wheel
pip install addok
pip install addok-fr
pip install addok-france</code></pre>
<p>Le logiciel étant installé, il faut maintenant créer un fichier de configuration.<br>
Un exemple est fourni <em>addok/lib/python3.7/site-packages/addok/config/default.py</em> et pourrait être utilisé directement.<br>
Il faut cependant le modifier quelque peu pour profiter des plugins <em>addok-fr</em> et <em>addok-france</em>.</p>
<p>On crée donc le fichier addok/addok.conf dont le contenu un peu long est à la fin de l'article.</p>
<p>Il reste maintenant à obtenir les données à injecter dans le géocodeur.<br>
Ce dernier utilise une base Redis et en injectant la totalité de la BAN, il faudrait plusieurs Go de RAM.<br>
Heureusement, il est possible de télécharger des <a href="https://adresse.data.gouv.fr/data/ban/adresses/latest/addok/">extraits de la BAN</a> par département.</p>
<p>Par exemple pour le Bas-Rhin:</p>
<pre><code>wget https://adresse.data.gouv.fr/data/ban/adresses/latest/addok/adresses-addok-67.ndjson.gz
gunzip adresses-addok-67.ndjson.gz
</code></pre>
<p>Il suffit maintenant d'injecter les données récupérées:</p>
<pre><code>addok batch adresses-addok-67.ndjson
addok ngrams
</code></pre>
<p>Un premier test simple consiste à ouvrir un <em>shell</em> addok et à géocoder une adresse:</p>
<pre><code>addok --config addok/addok.conf shell
Addok 1.0.2
Loaded local config from addok/addok.conf
Loaded plugins:
addok.shell==1.0.2, addok.http.base==1.0.2, addok.batch==1.0.2, addok.pairs==1.0.2, addok.fuzzy==1.0.2, addok.autocomplete==1.0.2, france==1.1.0, fr==1.0.1
Welcome to the Addok shell o/
Type HELP or ? to list commands.
Type QUIT or ctrl-C or ctrl-D to quit.
> Strasbourg
Strasbourg (J6Ol | 0.9610972727272726)
Route de la Wantzenau 67000 Strasbourg (k5Pr | 0.7135927272727272)
Avenue de Colmar 67100 Strasbourg (xkZE | 0.7129881818181817)
Route de Schirmeck 67200 Strasbourg (76wG | 0.7129481818181818)
Route des Romains 67200 Strasbourg (P19l | 0.7128863636363635)
Route d’Oberhausbergen 67200 Strasbourg (667Q | 0.7127390909090908)
Route de Mittelhausbergen 67200 Strasbourg (NxnK | 0.7122436363636363)
Route du Polygone 67100 Strasbourg (qjrR | 0.7112654545454544)
Rue de la Ganzau 67100 Strasbourg (oYRk | 0.7110227272727272)
Rue Boecklin 67000 Strasbourg (y83E | 0.7103163636363635)
71.6 ms — 1 run(s) — 10 results
--------------------------------------------------------------------------------
</code></pre>
<p>Si cette étape fonctionne on peut lancer le serveur intégré:</p>
<pre><code>addok --config addok/addok.conf serve
Addok 1.0.2
Loaded local config from addok/addok.conf
Loaded plugins:
addok.shell==1.0.2, addok.http.base==1.0.2, addok.batch==1.0.2, addok.pairs==1.0.2, addok.fuzzy==1.0.2, addok.autocomplete==1.0.2, france==1.1.0, fr==1.0.1
Serving HTTP on 127.0.0.1:7878…
</code></pre>
<p>Et enfin utiliser l'API pour géocoder l'adresse:</p>
<pre><code>curl "http://localhost:7878/search/?q=Strasbourg"
{"type": "FeatureCollection", "version": "draft", "features": [{"type": "Feature", "geometry": {"type": "Point", "coordinates": [7.761454, 48.579831]}, "properties": {"label": "Strasbourg", "score": 0.9610972727272726, "id": "67482", "type": "municipality", "name": "Strasbourg", "postcode": "67200", "citycode": "67482", "x": 1051008.43, "y": 6841654.82, "population": 279284, "city": "Strasbourg", "context": "67, Bas-Rhin, Grand Est", "importance": 0.57207}}, {"type": "Feature", "geometry": {"type": "Point", "coordinates": [7.787474, 48.616029]}, "properties": {"label": "Route de la Wantzenau 67000 Strasbourg", "score": 0.7135927272727272, "id": "67482_7080", "name": "Route de la Wantzenau", "postcode": "67000", "citycode": "67482", "x": 1052680.41, "y": 6845787.55, "city": "Strasbourg", "context": "67, Bas-Rhin, Grand Est", "type": "street", "importance": 0.84952}}, {"type": "Feature", "geometry": {"type": "Point", "coordinates": [7.749156, 48.558389]}, "properties": {"label": "Avenue de Colmar 67100 Strasbourg", "score": 0.7129881818181817, "id": "67482_1430", "name": "Avenue de Colmar", "postcode": "67100", "citycode": "67482", "x": 1050246.21, "y": 6839220.87, "city": "Strasbourg", "context": "67, Bas-Rhin, Grand Est", "type": "street", "importance": 0.84287}}, {"type": "Feature", "geometry": {"type": "Point", "coordinates": [7.709492, 48.567865]}, "properties": {"label": "Route de Schirmeck 67200 Strasbourg", "score": 0.7129481818181818, "id": "67482_6290", "name": "Route de Schirmeck", "postcode": "67200", "citycode": "67482", "x": 1047261.71, "y": 6840097.22, "city": "Strasbourg", "context": "67, Bas-Rhin, Grand Est", "type": "street", "importance": 0.84243}}, {"type": "Feature", "geometry": {"type": "Point", "coordinates": [7.707628, 48.578578]}, "properties": {"label": "Route des Romains 67200 Strasbourg", "score": 0.7128863636363635, "id": "67482_5690", "name": "Route des Romains", "postcode": "67200", "citycode": "67482", "x": 1047053.47, "y": 6841277.85, "city": "Strasbourg", "context": "67, Bas-Rhin, Grand Est", "type": "street", "importance": 0.84175}}], "attribution": "BANO", "licence": "ODbL", "query": "Strasbourg", "limit": 5}
</code></pre>
<p>L'ensemble de l'API est documenté sur le site <a href="https://geo.api.gouv.fr/adresse">geo.api.gouv.fr</a>.</p>
<p><em>addok/addok.conf</em></p>
<pre><code>import os
from pathlib import Path
REDIS = {
'host': os.environ.get('REDIS_HOST') or 'localhost',
'port': os.environ.get('REDIS_PORT') or 6379,
'unix_socket_path': os.environ.get('REDIS_SOCKET'),
'indexes': {
'db': os.environ.get('REDIS_DB_INDEXES') or 0,
},
'documents': {
'db': os.environ.get('REDIS_DB_DOCUMENTS') or 1,
}
}
# Min/max number of results to be retrieved from db and scored.
BUCKET_MIN = 10
BUCKET_MAX = 100
# Above this treshold, terms are considered commons.
COMMON_THRESHOLD = 10000
# Above this treshold, we avoid intersecting sets.
INTERSECT_LIMIT = 100000
# Min score considered matching the query.
MATCH_THRESHOLD = 0.9
# Do not consider result if final score is below this threshold.
MIN_SCORE = 0.1
QUERY_MAX_LENGTH = 200
GEOHASH_PRECISION = 7
MIN_EDGE_NGRAMS = 3
MAX_EDGE_NGRAMS = 20
SYNONYMS_PATH = None
# Pipeline stream to be used.
PROCESSORS_PYPATHS = [ # Rename in TOKEN_PROCESSORS / STRING_PROCESSORS?
'addok.helpers.text.tokenize',
'addok.helpers.text.normalize',
'addok_france.glue_ordinal', #ajout addok_france
'addok_france.fold_ordinal', #ajout addok_france
'addok_france.flag_housenumber', #ajout addok_france
'addok.helpers.text.flag_housenumber',
'addok.helpers.text.synonymize',
'addok_fr.phonemicize', #ajout addok_france
]
QUERY_PROCESSORS_PYPATHS = [
'addok.helpers.text.check_query_length',
'addok_france.extract_address', #Ajout addok_france
'addok_france.clean_query', #Ajout addok_france
'addok_france.remove_leading_zeros', #Ajout addok_france
]
# Remove SEARCH_PREFIXES.
SEARCH_PREPROCESSORS_PYPATHS = [
'addok.helpers.search.tokenize',
'addok.helpers.search.search_tokens',
'addok.helpers.search.select_tokens',
'addok.helpers.search.set_should_match_threshold',
]
BATCH_PROCESSORS_PYPATHS = [
'addok.batch.to_json',
'addok.helpers.index.prepare_housenumbers',
'addok.ds.store_documents',
'addok.helpers.index.index_documents',
]
BATCH_FILE_LOADER_PYPATH = 'addok.helpers.load_file'
BATCH_CHUNK_SIZE = 1000
# During imports, workers are consuming RAM;
# let one process free for Redis by default.
BATCH_WORKERS = max(os.cpu_count() - 1, 1)
RESULTS_COLLECTORS_PYPATHS = [
'addok.helpers.collectors.no_tokens_but_housenumbers_and_geohash',
'addok.helpers.collectors.no_available_tokens_abort',
'addok.helpers.collectors.only_commons',
'addok.helpers.collectors.bucket_with_meaningful',
'addok.helpers.collectors.reduce_with_other_commons',
'addok.helpers.collectors.ensure_geohash_results_are_included_if_center_is_given', # noqa
'addok.helpers.collectors.extend_results_reducing_tokens',
'addok.helpers.collectors.extend_results_extrapoling_relations',
]
SEARCH_RESULT_PROCESSORS_PYPATHS = [
'addok.helpers.results.match_housenumber',
'addok_france.make_labels', #Ajout addok_france
'addok.helpers.results.make_labels',
'addok.helpers.results.score_by_importance',
'addok.helpers.results.score_by_autocomplete_distance',
'addok.helpers.results.score_by_ngram_distance',
'addok.helpers.results.score_by_geo_distance',
]
REVERSE_RESULT_PROCESSORS_PYPATHS = [
'addok.helpers.results.load_closer',
'addok.helpers.results.make_labels',
'addok.helpers.results.score_by_geo_distance',
]
RESULTS_FORMATTERS_PYPATHS = [
'addok.helpers.formatters.geojson',
]
INDEXERS_PYPATHS = [
'addok.helpers.index.HousenumbersIndexer',
'addok.helpers.index.FieldsIndexer',
# Pairs indexer must be after `FieldsIndexer`.
'addok.pairs.PairsIndexer',
# Edge ngram indexer must be after `FieldsIndexer`.
'addok.autocomplete.EdgeNgramIndexer',
'addok.helpers.index.FiltersIndexer',
'addok.helpers.index.GeohashIndexer',
]
# Any object like instance having `loads` and `dumps` methods.
DOCUMENT_SERIALIZER_PYPATH = 'addok.helpers.serializers.ZlibSerializer'
DOCUMENT_STORE_PYPATH = 'addok.ds.RedisStore'
# Fields to be indexed
# If you want a housenumbers field but need to name it differently, just add
# type="housenumbers" to your field.
FIELDS = [
{'key': 'name', 'boost': 4, 'null': False},
{'key': 'street'},
{'key': 'postcode',
'boost': lambda doc: 1.2 if doc.get('type') == 'municipality' else 1},
{'key': 'city'},
{'key': 'housenumbers'},
{'key': 'context'},
]
# Sometimes you only want to add some fields keeping the default ones.
EXTRA_FIELDS = []
# Weight of a document own importance:
IMPORTANCE_WEIGHT = 0.1
# Default score for the relation token => document
DEFAULT_BOOST = 1.0
# Data attribution
# Can also be an object {source: attribution}
ATTRIBUTION = "BANO"
# Data licence
# Can also be an object {source: licence}
LICENCE = "ODbL"
# Available filters (remember that every filter means bigger index)
FILTERS = ["type", "postcode"]
LOG_DIR = os.environ.get("ADDOK_LOG_DIR", Path(__file__).parent.parent.parent)
LOG_QUERIES = False
LOG_NOT_FOUND = False
INDEX_EDGE_NGRAMS = True
</code></pre>
<div><a href="https://linuxfr.org/users/laurentu/journaux/ban-de-addok.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/123880/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/users/laurentu/journaux/ban-de-addok#comments">ouvrir dans le navigateur</a>
</p>
passkehttps://linuxfr.org/nodes/123880/comments.atom