60

L'accès à notre ordinateur (et pas seulement à Internet) doit être limité pour les comptes de mes enfants (7, 8) jusqu'à ce qu'ils soient assez vieux pour gérer cela par eux-mêmes. Jusque-là, nous devons pouvoir définir les éléments suivants:

les heures de la journée où l'informatique est en bon état (p. ex. 17 h à 21 h)
les jours de la semaine où l'informatique n'est pas correcte (par exemple, du lundi au vendredi)
le temps alloué par jour (par exemple 2 heures)

En 11.10, toutes les tâches suivantes qui faisaient le travail ne fonctionnent plus:

Timekpr : pour> 11.10 pas plus disponible à travers le ppa.
Timeoutd : alternative à la ligne de commande, mais retirée du référentiel à partir de 11.10 .
Nounou Gnome : Il a l'air génial mais se bloque à plusieurs reprises pour forcer le redémarrage du serveur X. Nous ne pouvons donc pas utiliser ou recommander ce programme pour le moment.

Y a-t-il d'autres alternatives?

software-recommendation bash parental-controls Takkat
la source

Hmmm ... s'il n'y a rien qui fasse ça, il serait probablement facile de le pirater avec des scripts shell / des tâches cron.

Nathan Osman

11

EEK. Je ne peux pas laisser mes parents voir celui-ci. MAIS, je le contournerais parce que j'ai un accès root impressionnant. : P

jrg

L'intérêt est de "toujours en développement", mais je ne pense pas que cela mérite une nouvelle question.

RobotHumans

Hormis le développeur timekpr qui a promis de ne pas avoir le temps de poursuivre le développement, il n’existe pas d’application de ce type. Mais de par ma propre expérience, je sais maintenant que nous pouvons nous en sortir (mais même mieux?), Mais il faut ensuite des enfants intelligents et des parents intelligents .

Takkat

@jrg ou juste un live USB;)

Wilhelm Erasmus

1

Verrouiller la minuterie de l'écran

Créez votre propre minuterie de verrouillage d'écran au lieu d'applications tierces

Bien qu'il existe des applications tierces pour ce faire, vous pouvez créer les vôtres. Résumé des étapes:

Utiliser geditpour créer un scriptlock-screen-timer
Copiez et collez le code à partir de cette fenêtre pour lock-screen-timer
Marquer lock-screen-timercomme exécutable
Essaye-le!
Configurer Nautilus pour exécuter des scripts bash
Créer un lien de raccourci sur le bureau
Surveiller le temps restant

Utiliser `gedit`pour créer un script`lock-screen-timer`

Ouvrez l' Terminalaide de Ctrl+ Alt+ Tet tapez:

gedit lock-screen-timer

Copiez et collez le code de la fenêtre ci-dessous pour `lock-screen-timer`

Revenez à cet écran et copiez le code suivant en le mettant en surbrillance et en appuyant sur Ctrl+ C:

#!/bin/bash

# NAME: lock-screen-timer
# PATH: $HOME/bin
# DESC: Lock screen in x minutes
# CALL: Place on Desktop or call from Terminal with "lock-screen-timer 99"
# DATE: Created Nov 19, 2016. Last revision Mar 22, 2018.
# UPDT: Updated to support WSL (Windows Subsystem for Linux)
#       Remove hotplugtv. Replace ogg with paplay.

# NOTE: Time defaults to 30 minutes.
#       If previous version is sleeping it is killed.
#       Zenity is used to pop up entry box to get number of minutes.
#       If zenity is closed with X or Cancel, no screen lock timer is launched.
#       Pending lock warning displayed on-screen at set intervals.
#       Write time remaining to ~/.lock-screen-timer-remaining

MINUTES="$1" # Optional parameter 1 when invoked from terminal.

# if no parameters set default MINUTES to 30
if [ $# == 0 ]; then
    MINUTES=30
fi

DEFAULT="$MINUTES" # When looping, minutes count down to zero. Save deafult for subsequent timers.

# Check if lock screen timer already running
pID=$(pgrep -f "${0##*/}") # All PIDs matching lock-screen-timer name
PREVIOUS=$(echo "$pID" | grep -v ^"$$") # Strip out this running copy ($$$)
if [ "$PREVIOUS" != "" ]; then
    kill "$PREVIOUS"
    rm ~/.lock-screen-timer-remaining
    zenity --info --title="Lock screen timer already running" --text="Previous lock screen timer has been terminated."
fi

# Running under WSL (Windows Subsystem for Linux)?
if cat /proc/version | grep Microsoft; then
    WSL_running=true
else
    WSL_running=false
fi


while true ; do # loop until cancel

    # Get number of minutes until lock from user
    MINUTES=$(zenity --entry --title="Lock screen timer" --text="Set number of minutes until lock" --entry-text="$DEFAULT")

    RESULT=$? # Zenity return code
    if [ $RESULT != 0 ]; then
        break ; # break out of timer lock screen loop and end this script.
    fi

    DEFAULT="$MINUTES" # Save deafult for subsequent timers.
    if [[ $MINUTES == 0 ]] || [[ $MINUTES == "" ]]; then
        break ; # zero minutes considered cancel.
    fi

    # Loop for X minutes, testing each minute for alert message.
    (( ++MINUTES )) 
    while (( --MINUTES > 0 )); do
        case $MINUTES in 1|2|3|5|10|15|30|45|60|120|480|960|1920)
            notify-send --urgency=critical --icon=/usr/share/icons/gnome/256x256/status/appointment-soon.png "Locking screen in ""$MINUTES"" minute(s)." ;
            if [[ $WSL_running == true ]]; then  
                powershell.exe -c '(New-Object Media.SoundPlayer "C:\Windows\Media\notify.wav").PlaySync();'
            else
               paplay /usr/share/sounds/freedesktop/stereo/complete.oga ;
            fi
           ;;
        esac;

        # Record number of minutes remaining to file other processes can read.
        echo "$MINUTES Minutes" > ~/.lock-screen-timer-remaining

        sleep 60

    done

    rm ~/.lock-screen-timer-remaining # Remove work file others can see our progress with

    if [[ $WSL_running == true ]]; then  
        # Call lock screen for Windows 10
        rundll32.exe user32.dll,LockWorkStation
    else
        # Call screen saver lock for Ubuntu versions > 14.04.
        dbus-send --type=method_call --dest=org.gnome.ScreenSaver /org/gnome/ScreenSaver org.gnome.ScreenSaver.Lock
    fi

done # End of while loop getting minutes to next lock screen

exit 0 # Closed dialog box or "Cancel" selected.

Revenez ensuite à la geditfenêtre vide et collez le code avec Ctrl+ V. Enregistrez le fichier et quittez l'éditeur pour revenir à l'invite de commande.

Marquer `lock-screen-timer`comme exécutable

Maintenant, nous devons rendre le script exécutable en tapant:

chmod +x lock-screen-timer

Essaye-le!

Avant d'appeler le script depuis l'interface graphique, nous l'appellerons depuis le terminal afin de voir si des messages d'erreur sont affichés:

~/lock-screen-timer

Vous êtes invité à entrer le nombre de minutes:

Définissez le nombre de minutes souhaité et cliquez sur OK pour démarrer le chronomètre. Lorsqu'il reste 15, 10, 5, 3, 2 et 1 minute, un son système est entendu et une bulle apparaît indiquant que l'écran sera verrouillé. Une fois l'écran verrouillé, vous devez entrer votre mot de passe pour le déverrouiller.

Configurer Nautilus pour exécuter des scripts bash

Nautilus définit ce qui se produit lorsque l'on double-clique sur un script exécutable lorsqu'il s'agit de la fenêtre d'affichage des fichiers ou d'un lien sur le bureau. Le comportement normal consiste à éditer le script avec gedit. Nous voulons changer ce comportement pour qu'il soit exécuté.

Démarrez Nautilus et accédez au répertoire contenant lock-screen-timer. Cliquez dessus une fois pour le mettre en évidence. Passez la souris sur la barre de menu supérieure jusqu'à ce que le menu "Fichier Éditer ..." apparaisse, utilisez:

Cliquez Editsur le menu déroulant
PropertiesOption de clic
Cliquez sur l' Behavioronglet
Observez les boutons d’option radio sous Executable Text Files
Vérifiez le bouton radio Run executable text files when they are opened

Créer un lien de raccourci sur le bureau

De la section précédente a lock-screen-timertoujours le focus. Sinon, naviguez jusqu'au script et cliquez une fois dessus pour le mettre en évidence. Alors utilisez:

Faites un clic droit sur le fichier et les options du menu contextuel apparaissent.
Dans le menu, sélectionnez Make Link.
Une nouvelle icône apparaît appelée Link to lock-screen-timer.
Faites un clic gauche sur la nouvelle icône et faites-la glisser de Nautilus sur votre bureau.

Maintenant, vous pouvez double-cliquer sur le lien de raccourci sur le bureau et le script est exécuté. Une boîte de dialogue apparaît pour obtenir le nombre de minutes. Deux boutons sont présentés Cancelet OK. Si vous cliquez sur Xpour fermer la fenêtre, le choix est identique Cancel.

Une fois que le chronomètre est en marche et que vous double-cliquez dessus, la première copie en cours est "tuée". Vous pouvez maintenant commencer un nouveau compte à rebours pour le verrouillage du scren ou cliquer Cancelpour ne pas compter.

Temps d'affichage restant dans la zone de notification / système

Pendant le fonctionnement de l’écran de verrouillage, il enregistre le nombre de minutes restantes dans le fichier ~/.lock-screen-timer-remaining. Vous pouvez consulter ce fichier à l'aide de la watchcommande ou l'afficher dans la barre d'état de la barre d'état système / application d'Ubuntu, comme indiqué en haut de cette réponse. Pour afficher le temps restant dans la zone de notification, suivez les instructions de ce Q & A: ( BASH peut-il afficher le tableau de bord en tant qu'indicateur d'application? ).

WinEunuuchs2Unix
la source

38

Ubuntu <= 11.10 L'utilisateur suit ce guide pour l'utilisateur Ubuntu> = 11.10, lisez la notice de la page du bas:

Oui, tous ces programmes sont obsolètes et toutes vos questions sont répondues ici et regardez bien avec votre contrôle parent .....

Lorsque nous parlons de forcer un utilisateur à se déconnecter, nous parlons en réalité de mettre en place des restrictions temporelles sur le compte pour l'accès au système ou les services. Le moyen le plus simple que j'ai trouvé d'implémenter des restrictions de temps consiste à utiliser un module de plug-in appelé Linux-PAM .

Le module d’authentification enfichable (PAM) est un mécanisme d’authentification des utilisateurs. Plus précisément, nous allons utiliser le pam_timemodule pour contrôler l'accès chronométré des utilisateurs aux services.

À l'aide du pam_timemodule, nous pouvons définir des restrictions d'accès à un système et / ou à des applications spécifiques à différents moments de la journée, ainsi que certains jours ou sur différentes lignes de terminaux. En fonction de la configuration, vous pouvez utiliser ce module pour refuser l'accès à des utilisateurs individuels en fonction de leur nom, de l'heure, du jour de la semaine, du service pour lequel ils demandent et du terminal à partir duquel ils effectuent la demande. .

Lors de l'utilisation pam_time, vous devez mettre fin à la syntaxe de chaque ligne (ou règle) du /etc/security/time.conffichier avec une nouvelle ligne. Vous pouvez commenter chaque ligne avec le signe dièse [#], et le système ignorera ce texte jusqu'à la nouvelle ligne.

Voici la syntaxe d'une règle:

services; ttys; utilisateurs; temps

The first field —  services — is a logic list of PAM service names.
The second field — tty — is a logic list of terminal names.
The third field — users — is a logic list of users or a netgroup of users.
The fourth field — times — indicates the applicable times.

Voici un exemple d'un ensemble de règles typique:

login ; * ; !bobby ; MoTuWeThFr0800-2000
login ; * ; !root ; !Al0000-2400
http ; * ; !bobby ; MoTuWeThFr0800-2000
http ; * ; !root; !Al0000-2400

Ces règles empêchent l'utilisateur bobby de se connecter entre 8 h et 20 h, ainsi que l'accès à Internet pendant ces heures. Root pourrait se connecter à tout moment et naviguer sur Internet à tout moment.

Remarque: Le système enregistre les erreurs avec ces règles en tant que syslog (3).

Avec Ubuntu Linux, il est possible d’attribuer à votre ordinateur des restrictions temporelles afin d’empêcher la connexion d’un ou de plusieurs utilisateurs à votre système. Avec les restrictions de temps, vous pouvez, par exemple, limiter l'accès de vos enfants à l'ordinateur (une sorte de contrôle parental, en bref) , ou même protéger la connexion à votre serveur pendant certaines heures.

Configuration manuelle

Comprends ce que tu vas faire

Tout au long de ce didacticiel, nous utiliserons PAM (modules d’authentification enfichables, modules d’authentification enfichables en anglais). Il vous permet de contrôler l'authentification des utilisateurs lorsqu'ils se connectent. Ensuite, nous utiliserons les fichiers de configuration de la sécurité pour définir les heures de connexion autorisées. Ces manipulations peuvent être effectuées sur n'importe quelle version d'Ubuntu et ne nécessitent qu'un simple éditeur de texte (vim, emacs, nano, gedit, kate, pour n'en nommer que quelques-unes). Activer les heures de restriction via le module PAM

Tout d’abord, allez à /etc/pam.d/, où sont tous les services configurables:

$ Ls /etc/pam.d/
atd common-account common-session gdm login ppp sudo
chfn common-auth cron gdm-autologin Other samba
chsh common-cupsys gnome-screensaver password passwd su

Si nous voulons bloquer la connexion à l'ordinateur, nous devrons changer le service gdm. Editez le fichier de manière gdm et ajoutez cette ligne de code (à la fin du fichier):

account required pam_time.so

GDM est la distribution d'écran de connexion Ubuntu, Edubuntu et Xubuntu. Pour Kubuntu, qui utilise KDE, le service kdm est appelé, ce sera le fichier qu'il ouvrira. Et vous avez terminé de configurer le PAM! Cela permettra le contrôle des heures sur ce service.

Si vous avez un serveur, vous n'avez probablement pas d'interface graphique. Dans ce cas, GDM / KDM n'est pas installé et la connexion ne sera pas bloquée. Pour empêcher la connexion à TTY, vous devez modifier le nom de connexion du même fichier et ajouter la même ligne de code que celle précédemment acceptée. Cette action s’applique également aux personnes ayant installé une interface graphique et souhaitant bloquer l’accès à l’écran de connexion et aux terminaux.

Configurer les heures d'accès

Maintenant que le service PAM a été activé, il ne reste plus qu'à configurer les temps d'accès. Ouvrez le /etc/security. Plusieurs fichiers de configuration sont disponibles:

$ Ls /etc/security/
access.conf namespace.conf pam_env.conf
group.conf namespace.init time.conf
limits.conf opasswd time.conf.bak

Editez le fichier time.conf. Quelques explications et exemples (anglais) présentant le. Pour définir les planifications d'accès, copiez et collez la ligne de code suivante (à la fin du fichier, comme toujours):

*;*;user;scheduler

Au lieu du champ utilisateur, entrez le compte de connexion que vous souhaitez bloquer.

Si vous souhaitez bloquer plusieurs utilisateurs, entrez leurs identifiants dans une rangée, séparés par le symbole | opérateur. Par exemple, si je veux geler les comptes de Patrick, John et Emily:

*;*;Patrick|jean|emilie;scheduler

Par contre, si vous souhaitez bloquer l’accès au système pour tous les utilisateurs sauf un en particulier, utilisez le! devant la personne concernée. Par exemple, si je veux que l'accès à l'ordinateur soit refusé à tous les utilisateurs, à l'exception de Nicolas et Xavier:

Nicolas *;*;!|xavier;scheduler

Passons maintenant aux zones de terrain. Dans ce champ que la sélection des jours et des heures sera autorisée connexion possible. Vous devez d’abord spécifier le jour de la semaine en utilisant les abréviations suivantes:

Mo : Monday     Fr : Friday     Wd : Sa/Su
Tu : Tuesday    Sa : Saturday   wk : Mo/Tu/We/Th/Fr
We : Wenesday   Su : Sunday
Th : Thursday   Al : All Days

Attention à ne pas confondre les abréviations Wk et Wd sont trompeuses! particulièrement mal identifié sur Internet: vous pouvez facilement trouver des informations contradictoires!

Ensuite, nous spécifions les délais. Ceux-ci devraient être formatés 24H, composé de 4 chiffres. Par exemple, pour limiter 15h17 à 18h34, nous écrivons: 1517-1834. Pour permettre à Marie de ne se connecter que le mardi, de 15h17 à 18h34, on obtient le résultat:

*;*;marie;Tu1517-1834

Les connexions en dehors de ces heures seront interdites. Quant aux utilisateurs, il est possible d'utiliser les opérateurs | et! pour indiquer plusieurs fois (les! indiquent ensuite que toutes les heures de connexion sont autorisées, à l'exception de celles à afficher).

Les deux étoiles (caractères génériques) au début de la ligne de code sont, respectivement, et les champs de services tty. Puisque vous souhaitez bloquer tous les accès au système, il est inutile de spécifier quel service ou quel terminal vous souhaitez bloquer. Toutefois, si vous souhaitez empêcher l'utilisation d'un service particulier, spécifiez-le simplement à l'aide de l'exemple suivant:

login;tty1|tty4|tty5;marie;!Wd0000-2400

Ainsi, l'utilisateur marié ne peut pas se connecter à un téléscripteur, 4 et 5 pendant le week-end.

Quelques exemples de calendrier de restrictions

mathilde est autorisée à se connecter tous les jours de 13h20 à 15h20 et de 16h00 à 20h30:

*;*;mathilde;Al1320-1520|Al1600-2030

Stone, Frank et Florian sont autorisés à se connecter de 14h00 à 18h45 en semaine et de 14h00 à 22h15 le week-end:

*;*;Stone|franck|florian;Wk1400-1845|Wd1400-2215

Olive n'est jamais autorisé à se connecter. Jessica peut se connecter le mercredi de 13h00 à 16h00:

*;*;olivier;!Al0000-2400
*;*;jessica;We1300-1600

2 lignes différentes, pour deux heures différentes pour chaque utilisateur Expiration d'une session

Lorsqu'une session expire (la durée dépasse le moment où l'utilisateur est déjà connecté), le PAM peut atteindre l'utilisateur. Bien que mathilde se connecte pendant les heures autorisées, il est parfaitement libre de les dépasser! Pour cela, nous allons utiliser un nouveau programme: "cron". Cette application exécute des commandes à intervalles de temps. Dans notre cas, nous utiliserons la commande "Skill-KILL-u" pour déconnecter l'utilisateur à l'expiration de la session. La manipulation est très simple. Éditez simplement le fichier ´ / etc / crontab´. Ajoutez ensuite la ligne de code suivante:

Minute Hour Day * * (s) root skill -KILL -u User

Comme auparavant, remplacez les horaires et champs souhaités pour le champ Minute. Indiquez ensuite le ou les jour (s) jour (s) jour (s) interdit (s), ou tapez simplement un astérisque (*) pour indiquer tous les jours de la semaine. Enfin, modifiez le champ utilisé par le compte de connexion pour le bloquer, et le tour est joué!

Les jours ne se remarquent pas de la même façon avec les cronemplois! Voici la liste des abréviations à utiliser avec ce programme:

mon : monday    fri : friday
tue : tuesday   sat : saturday
wed : wednesady sun : sunday
thu : thursday   *  : all hours

Quelques exemples d' cronemplois (avec des exemples de fois dans la section précédente)

Jessica peut se connecter le mercredi de 13h à 16h

-> Déconnexion: mardi à 16h00.

00 16 * root * wed skill -KILL -u jessica

mathilde est autorisée à se connecter tous les jours de 13h20 à 15h20 et de 16h00 à 20h30.

-> Déconnexion: tous les jours, de 20h30 à 15h20, heure de l'Est.

20 15 * * * root skill -KILL -u mathilde
30 20 * * * root skill -KILL -u mathilde

Stone, Frank et Florian sont autorisés à se connecter de 14h00 à 18h45 en semaine et de 14h00 à 22h15 le week-end.

-> Déconnexion (1): lundi, mardi, mercredi, jeudi et vendredi à 18h45. -> Disconnect (2): samedi et dimanche à 22h15.

45 18    * * mon,tue,wed,thu,fri   root    skill -KILL -u stone && skill -KILL -u franck && skill -KILL -u florian
15 22    * * sat,sun               root    skill -KILL -u stone && skill -KILL -u franck && skill -KILL -u florian

La commande skill-KILL-u déconnecte l'utilisateur de l'interface graphique, ainsi que le TTY. Il est parfaitement utilisable par les administrateurs de serveur. Cependant, cette commande est immédiate et la déconnexion sera faite sans préavis. Il serait donc préférable d’empêcher l’installation de ce périphérique utilisateurs de l’ordinateur ou du réseau en question!

Il est possible d'empêcher les utilisateurs avec une wallcommande lancée cronquelques minutes avant la fin de la période , qui sera affichée dans les terminaux de tous les utilisateurs.

40 18 * * Mon,Tue,wed,thu,fri root echo "end of session in 5 minutes" | wall

Pour empêcher les utilisateurs de GUI peut être utilisé à la place de la commande wall notify-sendest dans le package libnotify-bin

40 18 * * Mon,Tue,wed,thu,fri stone DISPLAY=:0 notify-send "end of session in 5 minutes"

Ubuntu 11.10 Utilisateur

J'ai vu autour de l'utilisateur avoir des problèmes avec Pam et j'ai vu beaucoup de bugs à ce sujet alors pourquoi est la raison ??? est si simple Ubuntu 11.10 ne supporte plus GDM plus le nouveau gestionnaire d’affichage est lightGDM le problème est le suivant où stocker cette directive account required pam_time.soje pense est /etc/pam.d/lightdmou /etc/pam.d/lightdm-autologinbogue comment ???

vous pouvez donc vérifier ces 2 fichiers journaux LightGdm:

/var/log/lightdm/lightdm.log
/var/log/lightdm/x-0.log

ou exécutez LightGdm en mode débogage:

LightDM - debug

ou signaler un bug:

ubuntu-bug lightdm

Je signale que le bogue est ici, alors croisez votre doigt et attendez ....

hhlp
la source

3

C'est - wow - super - je suis impressionné! Esp. J'apprécie beaucoup la notification parce que nous ne voulons pas que nos enfants soient expulsés sans préavis. Ce serait trop diabolique même pour un papa diabolique comme moi;)

Takkat

Malheureusement, cela ne semble pas fonctionner avec lightdm ( bugs.launchpad.net/lightdm/+bug/880313 ).

Takkat

wow, c'est super et longue explication ..

Mahmudin Ashar

Le cas pour openSUSE 11.4 est exactement comme Ubuntu 11.10.

Gupta

11

TimeKpr

Je suppose qu'il a tout ce dont vous avez besoin. Limite le temps d'accès par jour et par utilisateur, interface utilisateur facile pour la configuration, possibilité de contourner pendant un jour, ajoute du "temps de récompense", notification du temps restant pour les utilisateurs, etc.

La page du projet est ici . Ils ont aussi un PPA pour ubuntu que vous pouvez ajouter à vos sources Software: deb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu lucid main. Et installer via Software Center ou via CLI: sudo apt-get install timekpr.

Decio Lira
la source

TimeKpr peut-il fixer des limites de temps pour des applications individuelles (telles que des jeux?)

Anderson Green

8

Timekpr

peut être utilisé dans 11.10 exécutant LightDM pour configurer des restrictions pour les utilisateurs en ajoutant la ligne suivante à /etc/pam.d/lightdm

account required pam_time.so

^{Nous devrons peut-être supprimer libpam-smbpass pour permettre le changement d'utilisateur jusqu'à ce que le bogue n ° 835310 soit corrigé.}

Toutes les restrictions définies dans la fenêtre de l'application fonctionnent comme définies dans l'interface graphique de timekpr.

Pour afficher l'icône timekpr-client dans Unity, nous devons ajouter la liste blanche 'timekpr' dans les paramètres du panneau Unity. Nous devons également ajouter des éléments Unityà la ligne suivante /etc/xdg/autostart/timekpr-client.desktop:

OnlyShowIn=GNOME;XFCE;KDE;Unity;

Pour démarrer le compte à rebours du temps imparti, il peut être nécessaire de démarrer le démon timekpr avec

/etc/init.d/timekpr start

pour 14.04:

Une version plus récente / fork de timekpr a été publiée pour Ubuntu 14.04 par Eduards Bezverhijs dans le sien ppa:mjasnik/ppa.

Takkat
la source

Excellent, mais je pense que c'est une solution temporaire ... parce que vous utilisez timepkr et samba en même temps pour le partage avec d'autres ordinateurs (voir ce que ClaudeD (claude-d) a écrit) à propos de l'erreur possible ...

hhlp

7

La déconnexion automatique est extrêmement frustrante si vous êtes au milieu de quelque chose. C'est violent, c'est brutal, c'est tout simplement grossier. Et peu importe votre âge. C'est une chose lorsque vous êtes simplement accro à l'informatique et c'est très différent lorsque vous faites le suivi du temps et que vous êtes expulsé 5 secondes avant que vous ayez réussi à cliquer sur ce bouton d'envoi ou à enregistrer votre document. Je vous suggère d’envisager d’utiliser un rappel automatique au lieu d’un kicker automatique. Cela apprendra à vos enfants à se respecter et s’autorisera à utiliser l'ordinateur volontairement.

Il y a même une alternative plus légère. Commencez par suivre le temps passé par chaque enfant à utiliser l'ordinateur et rendez les données rassemblées disponibles pour tous afin qu'il puisse les voir. Cette chose incroyablement simple à elle seule (appliquée à la bande passante Internet utilisée) m'a sauvé la vie quand j'étais administrateur réseau dans un bureau rempli d'adultes. Les statistiques publiques sur l’utilisation de la bande passante pour chaque ordinateur (juste la quantité d’octets, pas les informations de désanonymisation telles que les listes de sites visités, etc.) ont transformé la situation de "moi - le mauvais administrateur glouton contre eux - les pauvres utilisateurs de bureau maltraités" en "homme, vous avez téléchargé 5 fois plus que moi, c'est mauvais! " "désolé, j'ai effectivement téléchargé, j'ai regardé beaucoup de youtube pendant les pauses déjeuner, je ne le ferai plus à ce rythme" - j'ai tout simplement été exclu du scénario de la confrontation.

vh1
la source

6

J'ai eu ce problème aussi. J'ai donc écrit le script kidtimer, qui vous permet de définir les temps d'utilisation et les totaux. Le projet peut être trouvé sur Github à l’emplacement suivant:

https://github.com/grover66/kidtimer

Voici comment l'installer et l'utiliser:

Copiez et collez le code dans un fichier appelé kidtimer.install.

#!/bin/bash
# Restrict kids computer access to specific hours and total time.
# By: Michael Groves - grover66_at_gmail_dot_com

#variables
basedir="/usr/local/kidtimer"
configdir="/etc/kidtimer"
Cdate=`/bin/date | awk '{ print $2" "$3 }'`
TUI=0
HOUR=`/bin/date +%H`
DOW=`/bin/date +%u`
WEEKEND="no"
[ "$DOW" == "6" ] && WEEKEND="yes"
[ "$DOW" == "7" ] && WEEKEND="yes"

#arguments
[ $# -eq 0 ] && TUI=1
[ $# -eq 1 ] && COMMAND=$1
[ $# -eq 2 ] && COMMAND=$1 && KID=$2
[ $# -eq 3 ] && COMMAND=$1 && KID=$2 && Time=$3

################# Subroutines ##################
################################################

go_check_install () {
if [ ! -e $basedir ]; then
    go_initialize
fi
}


go_initialize () {
/bin/mkdir -p $basedir/time
/bin/mkdir -p $basedir/schedule
/bin/cp $0 /usr/local/bin/kidtimer && chmod +x /usr/local/bin/kidtimer
echo "0 * * * *     root    /usr/local/bin/kidtimer hourly" > /etc/cron.d/kidtimer
echo "0 0 * * *     root    /usr/local/bin/kidtimer daily" >> /etc/cron.d/kidtimer
echo "* * * * *     root    /usr/local/bin/kidtimer check" >> /etc/cron.d/kidtimer
echo "@reboot       root    /usr/local/bin/kidtimer daily" >> /etc/cron.d/kidtimer
echo "@reboot       root    /usr/local/bin/kidtimer hourly" >> /etc/cron.d/kidtimer
/bin/mkdir $configdir
/usr/bin/touch $configdir/kid.list
go_create_message_files
echo "Kidtimer is now installed. Run /usr/local/bin/kidtimer to configure."
}


go_create_message_files () {
cat << EOF > $basedir/send5.sh
#!/bin/bash
Name=\$1
/bin/su -s /bin/bash -c 'DISPLAY=:0 /usr/bin/notify-send -i \
    /usr/share/pixmaps/gnome-set-time.png "ALERT" \
    "You will be logged out in 5 minutes."' \$Name
EOF
chmod +x $basedir/send5.sh
cat << EOF > $basedir/send4.sh
#!/bin/bash
Name=\$1
/bin/su -s /bin/bash -c 'DISPLAY=:0 /usr/bin/notify-send -i \
        /usr/share/pixmaps/gnome-set-time.png "ALERT" \
        "You will be logged out in 4 minutes."' \$Name
EOF
chmod +x $basedir/send4.sh
cat << EOF > $basedir/send3.sh
#!/bin/bash
Name=\$1
/bin/su -s /bin/bash -c 'DISPLAY=:0 /usr/bin/notify-send -i \
        /usr/share/pixmaps/gnome-set-time.png "ALERT" \
        "You will be logged out in 3 minutes."' \$Name
EOF
chmod +x $basedir/send3.sh
cat << EOF > $basedir/send2.sh
#!/bin/bash
Name=$1
/bin/su -s /bin/bash -c 'DISPLAY=:0 /usr/bin/notify-send -i \
        /usr/share/pixmaps/gnome-set-time.png "ALERT" \
        "You will be logged out in 2 minutes."' \$Name
EOF
chmod +x $basedir/send2.sh
cat << EOF > $basedir/send1.sh
#!/bin/bash
Name=\$1
/bin/su -s /bin/bash -c 'DISPLAY=:0 /usr/bin/notify-send -i \
        /usr/share/pixmaps/gnome-set-time.png "ALERT" \
        "You will be logged out in 1 minute."' \$Name
EOF
chmod +x $basedir/send1.sh
cat << EOF > $basedir/logout.sh
#!/bin/bash
Name=\$1
/usr/bin/pkill -KILL -u \$Name
rm -rf /tmp/kidtimer.shutdown.\$Name
EOF
chmod +x $basedir/logout.sh
cat << EOF > $basedir/schedule/blank
#hour weekday weekend (y/n)
00 n n
01 n n
02 n n
03 n n
04 n n
05 n n
06 n n
07 n n
08 y y
09 y y
10 y y
11 y y
12 y y
13 y y
14 y y
15 y y
16 y y
17 y y
18 y y
19 y y
20 n n
21 n n
22 n n
23 n n
#minutes weekday weekend
MAX 120 240
EOF
}


go_check () {
for I in `cat $configdir/kid.list`; do
        /usr/bin/users | grep -q $I
        if [ $? -eq 0 ]; then
                if [ -e $basedir/time/$I.ttl ]; then
                        C=`cat $basedir/time/$I.ttl`
                        C=$((C + 1))
                        echo $C > $basedir/time/$I.ttl
                else
                        echo 1 > $basedir/time/$I.ttl
                        C=1
                fi
        else
        go_clean_jobs $I
        exit 0
    fi
        # check total time.
        W="no"
        [ $DOW -eq 6 ] && W="yes"
        [ $DOW -eq 7 ] && W="yes"
        [ "$W" == "no" ] && TIME_LIMIT=`cat $basedir/schedule/$I | grep ^MAX | awk '{ print $2 }'`
        [ "$W" == "yes" ] && TIME_LIMIT=`cat $basedir/schedule/$I | grep ^MAX | awk '{ print $3 }'`
        if [ $C -ge $TIME_LIMIT ]; then
                if [ ! -e /tmp/kidtimer.shutdown.$I ]; then
                        /usr/bin/passwd $I -l
                        go_logout $I
                fi
        fi
done
}


go_clean_jobs () {
K=$1
for I in `/usr/bin/atq | awk '{ print $1 }' | sort`; do
    /usr/bin/at -c $I | grep kidtimer | grep -q $K
    [ $? -eq 0 ] && /usr/bin/at -d $I
done
[ -e /tmp/kidtimer.shutdown.$K ] && rm -rf /tmp/kidtimer.shutdown.$K
}


go_daily () {
for I in `cat $configdir/kid.list`; do
    ls -l $basedir/time/$I.ttl | grep -q "$Cdate"
    if [ ! $? -eq 0 ]; then
        echo "0" > $basedir/time/$I.ttl
    fi
done
}


go_hourly () {
if [ -s $configdir/kid.list ]; then
    for I in `cat $configdir/kid.list`; do
        if [ -e $basedir/schedule/$I ]; then
            [ "$WEEKEND" == "no" ] && TL=`cat $basedir/schedule/$I | grep ^MAX | awk '{ print $2 }'`
            [ "$WEEKEND" == "yes" ] && TL=`cat $basedir/schedule/$I | grep ^MAX | awk '{ print $3 }'`
            [ -e $basedir/time/$I.ttl ] && C=`cat $basedir/time/$I.ttl`
            [ $C -ge $TL ] && /usr/bin/passwd $I -l && exit 0
            [ "$WEEKEND" == "no" ] && R=`grep ^$HOUR $basedir/schedule/$I | awk '{ print $2 }'`
            [ "$WEEKEND" == "yes" ] && R=`grep ^$HOUR $basedir/schedule/$I | awk '{ print $3 }'`
            if [ "$R" == "y" ]; then
                /usr/bin/passwd $I -u
            else
                /usr/bin/passwd $I -l
                /usr/bin/users | grep -q $I && /usr/local/bin/kidtimer shutdown $I
            fi
        fi
    done
fi
}


go_logout () {
K=$1
echo "$basedir/send5.sh $K" | at now + 1 minutes
echo "$basedir/send4.sh $K" | at now + 2 minutes
echo "$basedir/send3.sh $K" | at now + 3 minutes
echo "$basedir/send2.sh $K" | at now + 4 minutes
echo "$basedir/send1.sh $K" | at now + 5 minutes
echo "$basedir/logout.sh $K" | at now + 6 minutes
touch /tmp/kidtimer.shutdown.$K
}


go_addtime () {
U=$KID
A=$Time
if [ "$KID" == "reset" ]; then
    echo "0" > $basedir/time/$U.ttl
    echo "Done."
    exit 0
elif [ "$KID" == "" ]; then
    echo "Error."
    echo "Syntax: addtime <user> <minutes|reset>"
    exit 1
else    
    C=`cat $basedir/time/$KID.ttl`
    C=$((C - Time))
    echo $C > $basedir/time/$KID.ttl
    echo "New total minutes is "$C"."
    echo "Done."
fi

/usr/bin/passwd $KID -u
}


go_tui () {
go_command_list
echo -n "Choose: "; read -e X
case "$X" in
1) go_setup_user
        ;;
2) go_modify_user
        ;;
3) go_remove_user
        ;;
4) go_list_users
    ;;
5) exit 0
        ;;
esac
go_tui
}


go_command_list () {
echo
echo "1) Setup user limits."
echo "2) Modify user limits."
echo "3) Remove user limits."
echo "4) List configured users."
echo "5) Quit."
echo
}


go_list_users () {
echo
echo "Users configured for kidtimer:"
if [ -s $configdir/kid.list ]; then
    cat $configdir/kid.list
else
    echo "No configured users."
fi
}

go_setup_user () {
echo
echo -n "Username: "; read -e U
/usr/bin/id $U > /dev/null 2>&1
if [ $? -eq 0 ]; then
    /bin/cp $basedir/schedule/blank $basedir/schedule/$U
    echo "0" > $basedir/time/$U.ttl
    echo $U >> $configdir/kid.list
    echo "Done."
    echo
    echo -n "Modify limits now ?(y/n): "; read -e M
    if [ "$M" == "y" ]; then
        if [ -e /usr/bin/nano ]; then
                    /usr/bin/nano $basedir/schedule/$U
                    echo "Done."
            else
                    /usr/bin/vi $basedir/schedule/$U
                    echo "Done."
            fi
    fi
else
    echo "Error. User does not exist. Please create user using the useradd command first."
fi
}


go_modify_user () {
echo
echo -n "Username: "; read -e U
grep -q ^$U $configdir/kid.list
if [ $? -eq 0 ]; then
    if [ -e /usr/bin/nano ]; then
        /usr/bin/nano $basedir/schedule/$U
        echo "Done."
    else
        /usr/bin/vi $basedir/schedule/$U
        echo "Done."
    fi
else
    echo "Error. User not setup. Please setup user first."
fi
}


go_remove_user () {
echo
echo -n "Username: "; read -e U
grep -q ^$U $configdir/kid.list
if [ $? -eq 0 ]; then
    grep -v ^$U $configdir/kid.list > /tmp/kidtimer.tmp
    cat /tmp/kidtimer.tmp > $configdir/kid.list
    echo "Done."
else
    echo "Error. User is not setup."
fi
}


go_help () {
echo
echo "Commands:"
echo "--------------------------------------------------------------------------------"
echo "addtime <user> <minutes> ... Increases allowed time for the day."
echo "logout <user>            ... Starts logout sequence for user."
echo "hourly                   ... Enables/disables user access based on the schedule."
echo "daily                    ... Resets time for the new day."
echo "help                     ... This list."
echo "--------------------------------------------------------------------------------"
}

###################### Code ####################
################################################

go_check_install
[ $TUI -eq 1 ] && go_tui

case "$COMMAND" in
addtime) go_addtime
    ;;
logout) go_logout $KID
    ;;
initialize) go_initialize
    ;;
hourly) go_hourly
    ;;
daily) go_daily
    ;;
check)  go_check
    ;;
-h) go_help
    ;;
help) go_help
    ;;
esac
exit 0

L'exécuter:
```
sudo ./kidtimer.install
```
Exécuter:
```
sudo kidtimer
```
Configurez un compte d'utilisateur existant.
Terminé.

Pour aider:

sudo kidtimer help

Ajouter du temps au compte d'un utilisateur (pour ce jour seulement):

sudo kidtimer addtime user minutes

Fonctionnalités:

Laissez à votre enfant des heures précises de la journée accéder à l'ordinateur, en semaine et le week-end.
Définissez la durée maximale, à la fois en semaine et le week-end.

Fichiers clés:

/etc/kidtimer/kid.list
/etc/cron.d/kidtimer
/usr/local/kidtimer/schedule/<user>
/usr/local/kidtimer/time/<user>.ttl
/usr/local/bin/kidtimer

Cronjobs:

Vérifiez toutes les minutes pour voir si l'utilisateur est connecté. Si c'est le cas, incrémentez la durée totale. Si vous atteignez l'heure maximale, désactivez le compte et démarrez la séquence de déconnexion (5 minutes au total).
Vérifiez toutes les heures pour voir si l'utilisateur est autorisé à se connecter. Si oui, activez le compte.
À minuit, réinitialiser l'heure.

Remarque:

L'application utilise notify-sendpour alerter l'utilisateur que le temps est compté. Lorsque le temps imparti est écoulé, tous les processus utilisateur sont terminés. Préparez donc l'utilisateur.

grover66
la source

5

timekpr - Ce programme suivra et contrôlera l'utilisation de vos comptes d'utilisateurs par l'ordinateur. Vous pouvez limiter leur utilisation quotidienne en fonction d'une durée d'accès programmée et configurer des périodes de la journée où ils peuvent ou ne peuvent pas se connecter. Avec cette application, les administrateurs peuvent limiter la durée de connexion au compte ou le nombre d'heures d'accès au compte. L'application fonctionne comme un contrôle du temps parental et sera utile aux parents qui souhaitent limiter le temps d'accès des enfants.

Even Nedberg proposed the following answer:
Just started copying into the 11.10 version for the PPA. Should finish
in a few minutes.

Vous pouvez mettre à jour votre système avec des packages non pris en charge à partir de ce PPA non approuvé en ajoutant ppa:timekpr-maintainers/ppades sources de logiciels à votre système.

deb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu oneiric main 
deb-src http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu oneiric main

Ce forfait est disponible en:

Problème onirique voir le rapport de bogue ....
natty
Maverick
lucide
Karmique
Désinvolte
Intrépide
Robuste
Que sont les PPA et comment les utiliser?

PROBLÈME:

Je signale que le bogue est ici, alors croisez votre doigt et attendez ....

hhlp
la source

Oh c'est une bonne nouvelle. Nous avions l'habitude d'utiliser timekpr ici. J'espère que cela fonctionnera - il est toujours installé sur ma boîte 11.10, fonctionne bien mais ne verrouille pas les comptes de mes enfants.

Takkat

et pour 14.04 ça marche?

rogerdpack

3

introduction

Nous pouvons vérifier si un utilisateur est connecté avec la commande:

who -u

ce qui nous donne une sortie comme:

$ who -u
jacob    :0           2016-03-17 20:48   ?          2557 (:0)
newuser  :1           2016-03-17 20:50   ?          4466 (:1)

Dans la sortie, nous obtenons le pid de l'utilisateur ciblé, qui doit être interrompu si le temps dépasse la limite.

La solution

En supposant que votre utilisateur ne dispose pas de sudoprivilèges:

Cette solution est un petit script d'arrière-plan. Il limite l'utilisation quotidienne à un nombre défini de minutes, à définir dans l'en-tête du script. Une fois installé (ce qui n’est pas trop difficile), la procédure est très simple et aucune action supplémentaire n’est nécessaire par la suite.

Pour éviter la perte de données non souhaitée de fichiers éventuellement ouverts 60 secondes avant l'expiration du délai imparti à l'utilisateur ciblé, un message apparaîtra sur celui-ci DISPLAY:

Le scénario

#!/usr/bin/python3
import subprocess
import os
import sys
import time


#--- set the time limit below (minutes)
minutes = 120
#--- set the user name to limit below
user = "newuser"

uselog = "/opt/limit/uselog"
datefile = "/opt/limit/currdate"

def read(f):
    try:
        return int(open(f).read().strip())
    except FileNotFoundError:
        pass

def message(disp, user):
    return "DISPLAY="+disp+" su - "+user+" -c "+'"'+\
      "notify-send 'User "+user+\
      " will be logged off in 60 seconds'"+'"'


currday1 = read(datefile)

while True:
    time.sleep(10)
    currday2 = int(time.strftime("%d"))
    # check if the day has changed, to reset the used quantum
    if currday1 != currday2:
        open(datefile, "wt").write(str(currday2))
        try:
            os.remove(uselog)  
        except FileNotFoundError:
            pass
    # if the pid of the targeted process exists, add a "tick" to the used quantum
    check = subprocess.check_output(["who", "-u"]).decode("utf-8")
    pid = [l.split() for l in check.splitlines() if user in l]
    if pid:
        n = read(uselog)
        n = n + 1 if n != None else 0
        open(uselog, "wt").write(str(n))
        # when time exceeds the permitted amount, kill the process
        if n > minutes*6:
            disp = [d for d in [d[1] for d in pid] if all([":" in d, not "." in d])][0]
            subprocess.Popen(["/bin/bash", "-c", message(disp, user)])
            time.sleep(60)
            pids = [p[-2] for p in pid]
            for p in pids:
                subprocess.Popen(["kill", p])  

    currday1 = currday2

Comment utiliser

Sur votre bureau (ou ailleurs), créez un dossier nommé: limit
Copiez le script dans un fichier vide, enregistrez-le sous limit_use(sans extension) dans le dossier et rendez-le exécutable.
Modifiez dans l'en-tête du script le nom d'utilisateur à limiter et le nombre maximal de minutes autorisées. Dans l'exemple:
```
#--- set the time limit below (minutes)
minutes = 1
#--- set the user name to limit below
user = "jacob"
```
Copiez le dossier dans le répertoire /opt:
```
cp -r /path/to/limit /opt
```
Maintenant, éditez /etc/rc.localpour que le script l'exécute comme rootau démarrage:
```
sudo -i gedit /etc/rc.local
```
Juste avant la ligne
```
exit 0
```
une autre ligne:
```
/opt/limit/limit_use &
```

Explication; Comment ça fonctionne

Une fois toutes les 10 secondes, le script recherche si l'utilisateur ciblé est connecté. Si c'est le cas, il ajoute "un" point à une utilisation totale, à enregistrer dans un fichier ( /opt/limit/uselog). Si la limite quotidienne est atteinte, le script n'autorise plus la connexion de l'utilisateur et tue son processus s'il existe.
Lors du changement de jour (la date est enregistrée dans un fichier, le redémarrage ne vous aidera pas), le fichier journal est supprimé, ce qui permet une nouvelle durée d'utilisation.
Étant donné que le script s'exécute au démarrage , rc.localseuls les utilisateurs dotés des privilèges sudo peuvent l'arrêter, même si l'utilisateur connaît le nom du processus.

Arrête le script

Si vous souhaitez arrêter le script, utilisez la commande suivante:

sudo kill "$(pgrep limit_use)"

Mais vous aurez besoin du mot de passe sudo pour le faire.

Jacob Vlijm
la source

2

J'ai essayé timekprmais je ne l'ai pas fait fonctionner. Puis fait une variante de celui-ci qui fonctionne sur mon Ubuntu. Voici ce qu'il faut faire pour cette variante:

Ajouter une limite de temps dans le /var/lib/timelimit/user_to_be_limited.limitfichier avec les droits root uniquement. par exemple, 1800 pour une limite quotidienne de 1 800 secondes (30 minutes).

Créer /usr/local/bin/timelimit.shavec les droits root avec les éléments suivants:

#!/bin/bash

pollTime=30
export DISPLAY=:0

while(true); do
    sleep $pollTime
    usersLogedIn=$( users|sed -e 's/\s\+/\n/g'|sort|uniq )
    for userName in $usersLogedIn; do
        if [[ -e "/var/lib/timelimit/$userName.limit" ]]
        then
            if [[ ! -e "/var/lib/timelimit/$userName.time" || `( stat -c '%z'  /var/lib/timelimit/$userName.time|cut -c9,10 )` != `date +%d` ]]
            then 
                echo $pollTime > /var/lib/timelimit/$userName.time
            else
                timeUsed=$(( `cat /var/lib/timelimit/$userName.time` + $pollTime ))
                echo $timeUsed > /var/lib/timelimit/$userName.time
            fi
            if [[ `cat /var/lib/timelimit/$userName.time` -gt `cat /var/lib/timelimit/$userName.limit` ]]
            then
                export XAUTHORITY=/home/$userName/.Xauthority
                notify-send --icon=gtk-dialog-warning --urgency=critical -t 30000 "$userName" "You have 60 seconds left!"
                sleep 60
                pkill -u $userName
            fi
        fi
    done
done

Ajouter à /etc/rc.local:
```
sudo /usr/local/bin/timelimit.sh &
```
Redémarrer Ubuntu

Csaba
la source

2

Je viens de rendre une réponse disponible facilement. Le code est expliqué à la discussion http://forums.linuxmint.com/viewtopic.php?f=213&t=77687 . En bref: une limite configurée en minutes par jour, un travail cron toutes les minutes, un message à l'utilisateur pour le tenir informé et une fermeture de session forcée.

Pour télécharger et installer ceci, ouvrez un terminal et exécutez les commandes ci-dessous:

cd /tmp/
git clone https://github.com/Thomas-Baeckeroot/ParentalControl.git
cd ParentalControl/
./install.sh

Un mot de passe administrateur sera demandé lors de l'installation (installer le travail cron, copier le script,…). De là, vous serez guidé pour tous. Il existe également un fichier ./uninstall.sh au même endroit, juste au cas où. Il est construit pour fonctionner avec toutes les distributions basées sur Ubuntu (Mint, etc… probablement aussi avec debian également). Si un problème survient, merci de me le signaler, y compris la version du système et l'environnement graphique dans les commentaires:

uname -a
echo $XDG_CURRENT_DESKTOP

Thomas Baeckeroot

Thomas Baeckeroot
la source

1

Je viens de publier une version bêta de ma nouvelle application LittleBrothercapable de surveiller le temps de lecture sur des machines Linux. Les utilisateurs de test sont invités à essayer le paquet Debian. Des instructions sur la façon de le télécharger et de l’utiliser peuvent être trouvées ici: https://github.com/marcus67/little_brother . L'installation peut encore être un peu rude, cependant. Ce sont les fonctionnalités de l'application:

N'importe quel nombre d'utilisateurs peut être surveillé.
Chaque utilisateur peut avoir un ensemble spécifique de règles définissant la durée de lecture autorisée.
Les règles peuvent être adaptées à des "contextes", tels que le jour de la semaine et / ou un programme de vacances (actuellement, seuls les programmes en allemand sont pris en charge).
La durée de lecture peut être limitée à une fenêtre temporelle (de, à).
Un temps de jeu maximum par jour peut être défini.
Les utilisateurs peuvent être obligés de faire une pause après un certain temps maximal de session.
Les utilisateurs peuvent être obligés d'attendre un temps de pause minimum après leur activité.
Vous pouvez surveiller n'importe quel nombre d'hôtes clients Linux (pour le moment, les utilisateurs doivent avoir la même connexion sur toutes les machines).
Il y a un hôte principal avec un historique des activités de tous les utilisateurs. Cet hôte maître vérifie les ensembles de règles et invite les hôtes clients à mettre fin aux processus, le cas échéant.
L'hôte principal offre une interface Web simple permettant de visualiser l'activité de l'utilisateur sur une longueur d'historique configurée (par exemple, 7 jours) et une page d'administration permettant de définir de manière dynamique les exceptions de règles pour un nombre de jours configuré dans le futur.
L'application Web peut être exécutée derrière un proxy afin d'être accessible de l'extérieur, ce qui permet une administration à distance après avoir reçu des appels de jeunes utilisateurs demandant plus de temps de lecture.
L'application prend en charge les langues internationales. Des traductions anglaise et allemande sont actuellement fournies. Les utilisateurs sont invités à fournir des traductions dans d'autres langues.
L'application utilise la génération de voix pour informer l'utilisateur des déconnexions forcées imminentes. De plus, ces messages parlés sont internationalisés.
En plus du temps passé sur les hôtes Linux, l'application peut également surveiller le temps d'activité sur d'autres périphériques tels que des téléphones intelligents ou des tables. Il tire parti du fait que la plupart des systèmes d'exploitation modernes mettent les périphériques en mode d'économie d'énergie lorsqu'ils ne sont pas utilisés. De cette façon, la réponse du réseau (par ping) peut être utilisée pour déterminer l'activité sur ces périphériques. Contrairement aux hôtes Linux, l'application ne pourra pas mettre fin à l'activité. Cependant, le temps de jeu sera ajouté au temps de jeu total et aura donc un impact sur le temps imparti et sur les règles de temps de pause des hôtes Linux.

Quelques captures d'écran:

Marcus Rickert
la source

Comment puis-je limiter le temps de calcul de mes enfants?

Réponses:

Verrouiller la minuterie de l'écran

Créez votre propre minuterie de verrouillage d'écran au lieu d'applications tierces

Utiliser `gedit`pour créer un script`lock-screen-timer`

Copiez et collez le code de la fenêtre ci-dessous pour `lock-screen-timer`

Marquer `lock-screen-timer`comme exécutable

Essaye-le!

Configurer Nautilus pour exécuter des scripts bash

Créer un lien de raccourci sur le bureau

Temps d'affichage restant dans la zone de notification / système

TimeKpr

Timekpr

pour 14.04:

Pour aider:

Ajouter du temps au compte d'un utilisateur (pour ce jour seulement):

Fonctionnalités:

Fichiers clés:

Cronjobs:

Remarque:

introduction

La solution

Le scénario

Comment utiliser

Explication; Comment ça fonctionne

Arrête le script

Quelques captures d'écran:

Comment puis-je limiter le temps de calcul de mes enfants?

Réponses:

Verrouiller la minuterie de l'écran

Créez votre propre minuterie de verrouillage d'écran au lieu d'applications tierces

Utiliser geditpour créer un scriptlock-screen-timer

Copiez et collez le code de la fenêtre ci-dessous pour lock-screen-timer

Marquer lock-screen-timercomme exécutable

Essaye-le!

Configurer Nautilus pour exécuter des scripts bash

Créer un lien de raccourci sur le bureau

Temps d'affichage restant dans la zone de notification / système

TimeKpr

Timekpr

pour 14.04:

Pour aider:

Ajouter du temps au compte d'un utilisateur (pour ce jour seulement):

Fonctionnalités:

Fichiers clés:

Cronjobs:

Remarque:

introduction

La solution

Le scénario

Comment utiliser

Explication; Comment ça fonctionne

Arrête le script

Quelques captures d'écran:

Utiliser `gedit`pour créer un script`lock-screen-timer`

Copiez et collez le code de la fenêtre ci-dessous pour `lock-screen-timer`

Marquer `lock-screen-timer`comme exécutable