Marotte ⛧ a écrit 8739 commentaires

evidemment cela suppose que les diverses machines soient synchronisés pour que leur calcule de epoc soit le meme au meme moment.

Et tu lui proposes d’installer plutôt ntpd ou plutôt chronyd sur sa caméra ? ;)

suffit de leur donner un acces restreint, avec 3 boutons et 2 formulaires

Oui et c’est prévu par GLPI, il y a des formulaires spécialement conçus à destination des utilisateurs finaux, pour saisir un incident par exemple.

ils ne l'utiliseront pas me disant que c'est trop compliqué pour eux…

Pure résistance au changement…

Honnêtement, en quoi est-ce plus difficile de cliquer sur des boutons et remplir des champs de formulaire que de remplir un tableau Excel ?

Tes collaborateurs trouvent « trop compliqué » Facebook, Twitter ou le site de leur banque ou de n’importe quelle e-boutique ?

Savoir s’adapter à l’utilisation de n’importe quelle interface oueb c’est autant un savoir-faire de base que l’était l’utilisation d’Excel il y a dix ans vingt ans.

Et pour la collaboration, ça va se passer comment avec ton fichier Excel ?

Une autre application, « lourde », ça va nécessiter également un temps d’adaptation pour les utilisateurs et un backend si tu veux travailler en mode collaboratif…

C’est sûr que mettre en place GLPI va te demander plus de travail au départ (et encore…) mais à moyen terme tu y gagneras, largement… toi et tes utilisateurs…

Est-ce que steghide est capable de tenter de détecter les messages éventuellement cachés (par lui-même) dans des fichiers ?

Ouai alors, « d’après Wikipédia » on l’occurrence ça me semble pas être une source forcément fiable et neutre…

Les trois références (9,10 et 11) sont des liens vers : TF1, Libération, Le Monde, liens tous cassés…

Peut-être que la banque a préféré « déboucler » parce qu’il y avait un risque que ce soit découvert par les autorités de régulation, donc on se remet en règle au bon moment, en faisant porter le chapeau à un employé, choisi plus ou moins au pif.

Dans ce cas là aussi le PDG dirait aujourd’hui exactement la même chose…

La fable d'un employé qui aurait « obéi aux ordres » est une falsification.

Il ne prétend pas avoir obéis aux ordres, juste qu’on le laissait faire sciemment. Je ne connais pas la vérité mais c’est une hypothèse possible. Et dans ce cas il est con, parce qu’il savait très bien qu’on se défausserait sur lui…

De toute façon il est coupable d’avoir fait ce qu’il a fait, il dit juste qu’il refuse de porter le chapeau pour tous les autres…

N’importe quel chef qui « demande » (implicitement toujours…) à un employé d’enfreindre la loi, ou qui « ferme les yeux », quand le pot-aux-roses est découvert il va nier être instigateur, et essayer de démontrer par A+B que son employé a tout fait dans son dos…

Bien sûr il doit y avoir des exceptions mais en général ça se passe comme ça. Il en va de la vie de l’entreprise !

Quelle est ta langue maternelle ? J’ai vraiment du mal à comprendre ce que tu écris…

Le lien que j’ai donné concerne une installation classique sur le disque dur. C’est définitif.

C’est mon code. Il ne faisait pas ce que je croyais qu’il faisait, comme me l’a fait remarquer benja ;)

Enfin c’est bon, j’ai compris maintenant, j’ai pu mettre en application sur le code que je voulais faire à la base (en utilisant Queue et Process directement…). J’en ai fini avec les nourrissons :)

en deduire l'algo

L’algo, il commence par « je fais une liste dont tous les éléments sont le même pointeur » (et moi je croyais faire : « je fais une liste de différents pointeurs ») donc je pense qu’il pue…

L’erreur (assez débile il faut le dire) que j’ai fait c’est de pas penser à ça :

>>> [randint(0,9)] * 9
[1, 1, 1, 1, 1, 1, 1, 1, 1]

>>> [randint(0,9)] * 9
[6, 6, 6, 6, 6, 6, 6, 6, 6]

je me suis attendu à avoir des éléments différents :/ mais ça ne marche pas comme ça, voilà.

Cependant, les nouvelles dispositions législatives qui obligent une entreprise à fournir un contrat de mutuelle santé à ses employés.

Elles obligent les entreprises à fournir une assurance complémentaire santé. Ça peut être une mutuelle ou une société d’assurance privée.

Ce qui change c’est le statut juridique. Le fait d’avoir des sociétaires vs des actionnaires.

Mais des mutuelles peuvent créer des entités juridiques non mutualistes, pour X raisons, généralement elles ont des status « dans l’esprit » mutualiste (en particulier : pas de dividendes), donc ça devient en effet assez flou…

En effet, jusque-là, les compagnies d'assurance et les mutuelles équilibraient leurs comptes entre toutes les branches, certaines étant déficitaires, d'autres pas. Ainsi, les larges bénéfices de la mutuelle santé permettaient jusqu'alors de couvrir les pertes des branches auto et habitation.

Donc si les marges de la branche santé fondent, les assurances/mutuelles étant là pour gagner de l'argent elles devront le récupérer ailleurs, et l'équilibrage des comptes devra immanquablement se faire par une hausse des contrats auto et habitation.

Il y a des tas de mutuelles qui ne font (ne faisaient…) que de la complémentaire santé. Maintenant elles se regroupent… à la base c’était beaucoup d’entreprises régionales, voire très locales… Elles se diversifient, et avant l’auto-habitation, il y a des marchés plus liés à la complémentaire santé, comme la prévoyance, avant de se lancer sur l’automobile ou le multi-risque (surtout que ces marchés là sont déjà quasi saturés…)

En France il y a encore, entre autre, une grosse mutuelle qui s’appelle la MGEN…

L’origine de la mutualité en France remonte à une époque où des paysans se sont aperçus qu’il valait mieux faire un pot commun pour payer éventuellement des travailleurs pour cultiver le champ du voisin qui serait tombé malade, si à la fin on veut qu’il y ait de la bouffe pour tout le monde…

Ce concept n’a pas du apparaître que chez les paysans… C’est un système économique non capitaliste. Les assurés s’assurant eux-mêmes. Aucune entité ne fait son beurre au passage.

J’en profite pour une autre question, qui n’a pas de rapport avec le sujet de départ…

Dans le script ci-dessus, on peut gagner deux lignes en ne déclarant pas des variables (val2 et process) qui ne sont pas utilisées :

def plop(q, i):

    val = randint(0,5)
    sleep(val)
    q.put((i, val, ''.join(sample(string.ascii_lowercase,randint(3,7)))))

items = range(0, 20)
queue = Queue()

for index in items:

    Process(target=plop, args=(queue, index)).start()

for index in items:

    print(queue.qsize(), "\t", "\t".join(map(str, list(queue.get()))), flush=True)

La question que je me pose est la suivante : « Est-ce que cela change quelque chose au final ? »

Est-ce que ça change par exemple l’utilisation mémoire ? Dois-je me soucier de ce détail avec Python ou bien puis-je écrire comme cela me semble le plus lisible, l’interpréteur fera le nécessaire ?

http://docs.slackware.com/fr:slackware:install

Mais du coup je ne comprends pas pourquoi la méthode 2. va plus vite que la méthode 1. (sauf si le temps de sommeil est le même pour tous les nourrissons, là les deux méthodes vont à la même vitesse (?!))

En fait je crois que j’ai compris…

Là où avec la méthode 1. j’attends que tout le dortoir ait fini, avec la méthode 2. je peux optimiser l’utilisation de mon unique dortoir car je peux faire dormir un nourrisson dès qu’une place se libère, sans devoir attendre que tout le dortoir ait fini…

C’est bien ça ?

Encore merci benja !

Est-ce qu’il est correct de dire qu’en faisant [Pool(N)] * M je fais en fait M références au même objet ?

Quoi qu’il en soit voici la solution en utilisant plusieurs dortoirs. Maintenant les nourrissons peuvent tous commencer leur sieste en même temps et le temps total est égal au temps de la plus longue sieste.

Il fallait faire comme ça pour avoir plusieurs pools:

barracks = []

for i in range(0, int(nurserySize/dormitorySize) + 1):

    barracks.append(Pool(dormitorySize))

Le script en entier (j’ai viré la méthode 1.) :

#!/usr/bin/env python3
"""Make all the toddlers in the nursery have their nap."""

from multiprocessing import Pool
from random import randint, sample
from time import sleep, time
import string
from pprint import pprint

"""What a toddler does when he’s having his nap."""

def nap(toddler):

    time = randint(0,4)
    print(toddler+' Zzz…', end=' ', flush=True)
    sleep(time)
    return(toddler, time)

"""Populate the nursery with toddlers."""

nurserySize   = 11
toddlers      = []

while (len(toddlers) < nurserySize):

    # Every toddler has a name
    toddlers.append(''.join(sample(string.ascii_lowercase,randint(3,7))).capitalize())

"""For all toddlers, make them nap grouped in available dormitories.
The nap is finished for all the toddlers in a dormitory when the last one wakes up."""

dormitorySize = 4

"""Nap all the toddlers at once."""

start = time()
barracks = []

for i in range(0, int(nurserySize/dormitorySize) + 1):

    barracks.append(Pool(dormitorySize))

sleepAmount = 0
dormitories = []
j = 0

# The callback function will be called when the pool has finished.
def fillDormitory(toddlers):

    dormitories.append(toddlers)

print(str(len(toddlers))+' toddlers going to sleep '+str(dormitorySize)+' by '+str(dormitorySize)+' in '+str(len(barracks))+' dormitories.')

for i in range(0, nurserySize, dormitorySize):

    barracks[j].map_async(nap, toddlers[i:i+dormitorySize], callback=fillDormitory)
    j += 1

for b in barracks:

    b.close()
    b.join()

# Count total sleep amount.
for dormitory in dormitories:

    for toddler in dormitory:

        sleepAmount += toddler[1]

print(dormitories)

_time = time() - start
_ratio = sleepAmount/_time

print("\n",' → Tooks '+str(_time)+' seconds for '+str(sleepAmount)+' of sleep. ('+str(_ratio)+')',"\n")

EDIT: J’ai le sentiment que je devrais pouvoir me passer d’utiliser un indice explicite (j), ça ne doit pas être très pythonesque comme manière de faire :/

Ah oui, bien vu ! Mais du coup je ne comprends pas pourquoi la méthode 2. va plus vite que la méthode 1. (sauf si le temps de sommeil est le même pour tous les nourrissons, là les deux méthodes vont à la même vitesse (?!))

Évidemment pour faire ce que je veux je pourrais créé un seul pool… mais j’aimerais bien comprendre ce qu’il y a de différent entre 1. et 2.

Sinon j’ai compris comment utiliser l’objet Queue, qui me permet de lancer plusieurs processus en parallèle et de récupérer leurs résultats au fur et à mesure :

#!/usr/bin/env python3

from multiprocessing import Process, Queue
from random import randint, sample
from time import sleep, time
import string
from pprint import pprint
from ctypes import c_wchar_p

def plop(q, i):

    val1 = randint(0,5)
    val2 = ''.join(sample(string.ascii_lowercase,randint(3,7)))
    sleep(val1)
    q.put((i, val1, val2))

items = range(0, 20)
queue = Queue()

for index in items:

    process = Process(target=plop, args=(queue, index))
    process.start()

for index in items:

    print(queue.qsize(), "\t", "\t".join(map(str, list(queue.get()))), flush=True)

Voici la sortie :

stef@medusa:~/Code/Test$ ./p2.py 
4    7  0   qfbliw
3    0  0   hno
2    13 0   pwd
1    12 0   zbo
0    3  1   dxrch
0    8  1   caig
0    11 1   prwcf
0    10 1   ftjbel
0    15 1   vprcg
0    1  2   crkpqzo
1    6  2   qntlr
0    9  2   lruh
0    4  3   tdbyip
0    2  3   inwleyo
0    14 3   pulrgd
0    19 3   ikuh
0    5  4   rkt
0    16 5   wnzx
1    17 5   atlnx
0    18 5   yiejnox

Le première colonne c’est la taille de la file (Queue), deuxième colonne l’index de l’item (qui correspond à l’ordre de lancement du process), en troisième colonne le temps pris par le process (temps de sleep()) et en quatrième colonne la valeur aléatoire générée par chaque process.

On peut voir que la taille de la file est importante au début… Voilà comment je le comprends : quand on fait le get() dans la deuxième boucle, on commence par le premier item, donc pendant qu’on attend ce premier process les suivants ont possiblement déjà terminé, venant s’enfiler dans queue.

On a les résultats « dans l’ordre logique », c’est à dire qu’on a les process qui prennent le plus de temps en dernier.

Avec cette dernière méthode le temps total ne dépasse pas le temps pris par le process qui dure le plus longtemps.

Par ailleurs j’ai également réussi à utiliser l’objet Manager, qui permet aussi de partager des variables, mais bon… un concept à la fois…

J’ai l’impression que pour un besoin donné il n’y a pas une seule bonne méthode et qu’en fait on a plutôt le choix, entre utiliser Pool, Queue, Manager, Process ou autre… j’ai encore du mal à bien voir quels sont les avantages et inconvénients de chacun.
```

L'application que j'aimerais serait beaucoup plus proche de Excel que de GLPI.

Après j'aimerais l'avoir sous format web avec authentification et gestion des droits (lecture, écriture) si possible.

C’est proprement paradoxal comme expression de besoin.

GLPI est un excellent produit. Qu’entends-tu par « proche d’Excel » ?

Deux fois que je lis ça en parcourant le fil…

1. Android (sans tréma)
2. Quel peut bien être le putain de rapport entre Android et la famille d’OS xBSD ?!

C'est excellent, a chaque nouvel onglet d'ouvert avec de l'audio, il ouvre deux nouveaux canaux que je peux rediriger ou bon me semble

Est-ce que surtout les sorties sont connectées automatiquement à la sortir principale ? Parce que si ce n’est pas le cas, pour un système grand public, devoir « tirer des câbles » pour avoir du son ça va pas le faire. Même si on peut bien sûr ne le faire qu’une fois et sauvegarder sa "patchbay" pour Madame Michu ça va être compliqué

Surtout si c’est pour chaque nouvel onglet de navigateur… J’avoue ne pas avoir utilisé JACK depuis un bon moment, il y a peut-être une option « connecter chaque nouvelle source sur master automatiquement »

des témoignages d'utilisateurs GNU/Linux sur le bureau qui auraient attrapé un logiciel malveillant.

Moi une fois, il y a longtemps, avec Wine. En le faisant un peu exprès, je savais que le binaire que je lançais avait de fortes chances d’être vérolé :)

Puis parfois j’ai des crises de paranoïa. Je me dit que mon desktop est rooté de chez rooté, que malgré mes connaissances en informatique c’est tellement bien fait que je ne peux pas le voir. Que ça doit être un coup de hackers « éthiques », ou du moins qui préfèrent profiter secrètement de ma machine plutôt que me nuire personnellement (en effaçant des fichiers ou autre), donc j’ai au moins ça pour moi.

En fait je me repose sur Debian. On a déjà vu une faille béante, involontairement introduite, être trouvée un sacré bout de temps après son introduction (un patch malchanceux sur OpenSSL…), donc si un organisme type CIA ou mafia russe à la ferme volonté de mettre une backdoor dans Debian il se pourrait bien que ça ne fasse pas de vague tout de suite…

J’ai le souvenir d’une époque lointaine où l’équipe de irssi (un client IRC très bonne facture) avait plombé le fichier de configuration de compilation en y ajoutant l’installation d’un rootkit… Les (ou la ?) personnes s’étaient défendus en expliquant que c’était pour prouver à la face du monde que : « pas tant de monde lit les sources, même un fichier de configuration, m’voyez… ». Tout le monde n’avait pas trouvé ça très sympathique :/

Les brocolis, coquilles d’escargot et autres flocons de neige vaudront peu de points, par contre les licornes et têtes de gens célèbres donneront des bonus monstrueux ?

Est-ce qu’on a pas tendance au contraire à voir toujours la même chose en parcourant une fractale ?

D’ailleurs pour la fractale de Mandelbrot ça a déjà été commenté :)

https://fr.wikipedia.org/wiki/Ensemble_de_Mandelbrot#Un_zoom_comment.C3.A9

En zoomant d’avantage on va retomber sur les mêmes choses…

Bon, je joue en premier (parce que) :

C’est un kiwi obèse vu du dessus.

J’aime bien. C’est de qui, tu le sais ?

J’ai eu ma petite période minetest, c’est marrant mais ça m’a lassé…

Pour minecraft je ne sais pas mais pour minetest c’est un cube d’environ 60 km de côté en considérant que le voxel (ie: le cube le plus petit) fait 1 mètre cube.

http://wiki.minetest.net/FAQ/fr#Quelle_est_la_taille_de_la_carte_.3F

Donc non, pas la taille de Neptune mais la taille d’une grande grande agglomération…

Sur deux serveurs que j’avais testé, en mode « création », un gros et un petit… on peut dire qu’il y a de la place, malgré que chaque utilisateur puisse réserver une ou plusieurs zones…

En retournant voir il y a peu j’ai pu observer que mes constructions étaient toujours là et que des gens s’en occupaient, malgré que j’ai fait le boulet sur un des serveurs, à construire collé à la création de quelqu’un d’autre…

Cool ! Merci d’avoir pris le temps de tester.

on a toujours le choix

Dans le cas où tu voudrais monter une VM qui servira de serveur de temps à tout un tas d’autres VM existantes, qui utilisent ntp par défaut, c’est appréciable de ne pas avoir à modifier toutes tes VM (en y installant chrony)… même si tu utilises puppet ou autre…

Par contre je pense effectivement que la piste des guest additions est la bonne.

Une rapide recherche : http://superuser.com/questions/688127/how-to-correctly-sync-time-in-linux-running-as-virtual-guest-after-host-resumes

Ce que la doc semble confirmer : https://www.virtualbox.org/manual/ch04.html#idm1948

Time synchronization

With the Guest Additions installed, VirtualBox can ensure that the guest's system time is better synchronized with that of the host.

For various reasons, the time in the guest might run at a slightly different rate than the time on the host. The host could be receiving updates via NTP and its own time might not run linearly. A VM could also be paused, which stops the flow of time in the guest for a shorter or longer period of time. When the wall clock time between the guest and host only differs slightly, the time synchronization service attempts to gradually and smoothly adjust the guest time in small increments to either "catch up" or "lose" time. When the difference is too great (e.g., a VM paused for hours or restored from saved state), the guest time is changed immediately, without a gradual adjustment.

Lien vers la doc et explication déjà donnée par d’autre, je me rends compte…

Notons que les fonctionnalités apportées par les guest additions ne sont pas libres.

Incapable d'ouvrir des CSV qui font plus de 30Mo.

Et si jamais un jour tu as un CSV trop gros pour LO, pense à Gnumeric ;)

Pas tout à fait ce que tu cherches mais ça t’aidera peut-être :

stef@medusa:~$ cat t1
8 9 6
-2 3 5
9 4 2
stef@medusa:~$ cat t2
1 8 9
5 -6 3
7 7 8

stef@medusa:~$ paste -d' ' t1 t2
8 9 6 1 8 9
-2 3 5 5 -6 3
9 4 2 7 7 8

stef@medusa:~$

Donc si tu peux découper ton fichier de départ tu devrais pouvoir ensuite le « recoller » ainsi…

Non mais fait chier putain merde à la fin ! Ya aucun problème de respect ici alors mets la en veilleuse bordel !