Come realizzare una Time Machine con un Raspberry Pi

Personalmente vi consiglio un Raspberry Pi Zero W, costa sui 10 euro e ha Wi-Fi integrato. Con l’aggiunta di un hard disk esterno (costo sui 40 euro per 1TB) potrete realizzare una Time Machine per il vostro Mac.

Allora iniziamo con l’aggiornare il Raspberry (qualunque esso sia, presupponendo che abbiate l’ultima versione di Raspian installata):

sudo apt update
sudo apt upgrade
sudo apt install netatalk hdparm

Ora identificate l’UUID del vostro hard disk (anche qua presupponendo che l’abbiate formattato in ext4) e copiatelo:

sudo blkid

Modifichiamo questo file:

sudo nano /etc/fstab

Aggiungendo in fondo (cambiando 0123456789abc con quello copiato prima):

UUID=0123456789abc /media/disk ext4 defaults 0 2

Poi create la cartella dove andrà montato e montiamo l’hard disk:

sudo mkdir /media/disk
sudo chmod 777 -R /media/disk
sudo mount -a

Ora modifichiamo il parametro di spinning dell’hard disk (per evitare di tenerlo sempre attivo anche quando non c’è nulla che scrive):

sudo nano /etc/hdparm.conf

E incollate al fondo questo:

/dev/sda {
spindown_time = 60
}

Poi modifichiamo l’ultima riga di questo file:

sudo nano /etc/netatalk/AppleVolumes.default

Incollando questo (ovviamente se non volete chiamarlo Tardis, dategli il nome che preferite):

/media/disk "Tardis" options:tm allow:pi

Ora aggiungete questo per avere un’icona nel Finder uguale a quella di una Time Capsule:

sudo nano /etc/avahi/services/afpd.service

Incollando questo:

<?xml version="1.0" standalone='no'?>
<!DOCTYPE service-group SYSTEM "avahi-service.dtd">
<service-group>
<name replace-wildcards="yes">Tardis</name>
<service>
<type>_afpovertcp._tcp</type>
<port>548</port>
</service>
<service>
<type>_device-info._tcp</type>
<port>0</port>
<txt-record>model=TimeCapsule8,119</txt-record>
</service>
</service-group>

E riavviate i processi con:

sudo service avahi-daemon restart
sudo service netatalk restart

E voilà, ecco a voi una Time Machine Wi-Fi (o nel caso ethernet) con meno di 50 euro! Che ne pensate?

Dimenticavo, vi dovrete connettere con l’username pi e la password vostra (nel caso non l’abbiate ancora cambiata dovrebbe essere raspberry).

Cos’è l’UUID

L’UUID è un identificativo univoco universale usato in informatica per identificare ad esempio un hard disk in un sistema informatico. È composto da 32 caratteri esadecimali, quindi le combinazioni possibili sono 16^32 cioè 340.282.366.920.938.463.463.374.607.431.768.211 possibilità.

Se volete potete generarne uno da qua: https://www.uuidgenerator.net ma vi basterà formattare un hard disk esterno o una pendrive per vederne implicazioni pratiche (può essere usato per montare un disco all’avvio oppure una condivisione ecc).

Come visualizzare spazio libero su Raspberry Pi

O su qualunque distribuzione tipo Ubuntu, Debian ecc vi basterà eseguire da terminale:

df -h

Vi visualizzerà sul terminale una schermata simile a questa:

Filesystem      Size  Used Avail Use% Mounted on
/dev/vda1       9.9G  6.7G  2.8G  72% /
udev             10M     0   10M   0% /dev
tmpfs           393M   40M  353M  11% /run
tmpfs           982M     0  982M   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs           982M     0  982M   0% /sys/fs/cgroup
tmpfs           197M     0  197M   0% /run/user/0

E potrete valutare se e come liberare spazio, nel caso non ne abbiate più disponibile.

Come rimuovere automaticamente i torrent completati da Transmission

Se utilizzate Transmission sul vostro Raspberry Pi (o su qualunque altro tipo di computer/server) e volete automaticamente rimuovere dalla lista i torrent che hanno finito, dovete seguire questi semplici passaggi.

Prima di tutto stoppate il servizio di transmission con:

sudo service transmission stop

Poi cambiate due righe qua:

sudo nano /var/lib/transmission-daemon/info/settings.json

Con:

"script-torrent-done-enabled": true,
"script-torrent-done-filename": "/home/pi/transmissionpurge.sh",

Ora chiudete e salvate con CTRL+X ed eseguite:

sudo nano transmissionpurge.sh

E incollate:

#!/bin/sh

SERVER="9091 --auth transmission:transmission"

TORRENTLIST=`transmission-remote $SERVER --list | sed -e '1d;$d;s/^ *//' | cut --only-delimited --delimiter=" " --fields=1`

transmission-remote $SERVER --list

for TORRENTID in $TORRENTLIST

do

echo Processing : $TORRENTID

DL_COMPLETED=`transmission-remote $SERVER --torrent $TORRENTID --info | grep "Percent Done: 100%"`
STATE_STOPPED=`transmission-remote $SERVER --torrent $TORRENTID --info | grep "State: Seeding\|Stopped\|Finished\|Idle"`

if [ "$DL_COMPLETED" ] && [ "$STATE_STOPPED" ]; then

transmission-remote $SERVER --torrent $TORRENTID --remove

else

echo "Torrent #$TORRENTID is not completed. Ignoring."

fi

done

Ora dategli i permessi di esecuzione con:

sudo chmod 777 /home/pi/transmissionpurge.sh

E il gioco è fatto! ora ogni volta che ultimerete un torrent, esso verrà subito cancellato dalla lista.

Ah quasi dimenticavo, riavviate transmission con:

sudo service transmission start

Quale iPhone acquistare nel 2017

Se siete qua è perché vi state domandando: vorrei acquistare un iPhone ma non so quale comprare, quale posso prendere?

E la risposta semplicissima è: dipende tutto dal vostro budget. Sì è proprio così, secondo me, dipende solo e unicamente da quanti soldi siete disposti a spendere.

Sono tutt’oggi ottimi dispositivi, sia l’SE che il 6s funzionano bene anche con iOS 11. Ovvio che più salite con il prezzo, più le prestazioni si sentiranno! Ma per un utilizzo giornaliero di un occhio non troppo attento, qualsiasi di questo dispositivo potrà garantirvi privacy, sicurezza e stabilità.

Come potrete notare dall’immagine sopra (i quali prezzi variano di circa il 10% se convertiti in euro) avrete un range dai 350 ai 1200 circa.

Differenza tra i processori m3, i5 e i7

Se state decidendo quale nuovo Mac acquistare e siete in dubbio tra i tre processori, beh… non posso che dirvi che la vostra scelta dipende solamente dalle vostre tasche.

Com’è ovvio che sia le prestazioni sono nettamente diverse e c’è differenza tra generazione diversa (ora siamo arrivati alla settima).

Per farla semplice e breve l’m3 è un processore molto semplice montato sul MacBook (che non ha neanche le ventole, quindi potete immaginare), che consuma poco e fa il suo dovre.

L’i5 e l’i7 sono ovviamente migliori, l’i7 è più performante ed entrambi (dipende dal caso) hanno sia il Turbo Boost che Hyper-Threading.

Ecco dei benchmark che poco dicono perché le reali prestazioni sono diversi da dei freddi benchmark:

Mentre qui potete vedere dei test effettuati con Xcode: https://github.com/ashfurrow/xcode-hardware-performance

Come monitorare il sensore delle piante di Xiaomi con Domoticz

Il sensore che sto per presentarvi costa abbastanza su Amazon ma potete trovarlo a meno su qualche sito cinese, nel caso il prezzo sia troppo elevato.

Xiaomi tra le tante cose ha realizzato un sensore molto compatto che può monitorare praticamente tutto quello che può essere utile per gestire una pianta (che sia un Bonsai o altro non importa, il sensore andrà impiantato nel terreno come in figura).

Con l’integrazione con Domoticz potrete gestire comodamente tutte le statistiche e fare dei grafici che potrebbero tornarvi utili in qualche modo con automazioni varie (monitorando la quantità di luce e la temperatura, le opzioni sono infinite).

Iniziamo:

sudo git clone https://github.com/marcotini/miflora /home/pi/domoticz/scripts/

Modificate il file:

sudo nano /home/pi/domoticz/scripts/miflora/demo.py

Cambiando l’indirizzo MAC del vostro sensore (lo trovate nel retro o con una semplice scansione BLE):

poller = MiFloraPoller("AB:CD:12:34:56:78")

E cambiate ovviamente anche gli IDX di temperatura, luce, umidità, conduttività e batteria (ovviamente ognuno di questi dovrà essere un sensore virtuale già esistente) che vanno da 100 a 104.

Ora create uno script che sia facilmente chiamabile da Domoticz:

sudo nano /home/pi/domoticz/scripts/flora.sh

E incollate:

#!/bin/bash

sudo /usr/bin/python3 /home/pi/domoticz/scripts/miflora/demo.py

Potete quindi ora creare un sensore virtuale che all’On Action esegua:

script:///home/pi/domoticz/scripts/flor1.sh

E potrete anche automatizzarlo nel crontab con sudo crontab -e per farlo eseguire ogni 20 minuti (lo uso da mesi e la batteria non è praticamente scesa). Incollate al fondo:

20 * * * * /home/pi/domoticz/scripts/flora.sh

Guardate ad esempio il sensore della luce:

Oppure quello dell’umidità:

Con Domoticz potete ovviamente creare tutte le automazioni del caso quindi ad esempio essere informati quando arriva a un certo valore di umidità del terreno, oppure quando non c’è abbastanza luce. Le possibilità sono davvero illimitate!

Come monitorare la bilancia di Xiaomi con Domoticz

La Xiaomi Mi Scale è la bilancia di Xiaomi con il Bluetooth (quindi per farla semplice potrete salvarvi i dati dove meglio preferite e farvi un grafico con i pesi misurati) che potete acquistare qui.

Con l’integrazione con Domoticz potrete gestirla come meglio preferite, eventualmente anche con HomeKit di Apple e l’emulazione del server con Homebridge.

Iniziamo!

sudo git clone https://github.com/marcotini/node-xiaomi-scale /home/pi/domoticz/scripts

Ora create un sensore virtuale che abbia uno switch (quindi un semplice bottone) e mettete come On Action:

script:///home/pi/domoticz/scripts/weight.sh

Vi serviranno anche 2 sensori virtuali per persona che usa la bilancia, uno per i KG e uno per il valore di BMI.

Adesso create lo script con sudo nano /home/pi/domoticz/scripts/weight.sh e incollate:

#!/bin/bash

before=$(head -1  /home/pi/domoticz/scripts/node-xiaomi-scale/scaleData.txt)

sudo /usr/bin/node /home/pi/domoticz/scripts/node-xiaomi-scale/fetchscaledata.js > /home/pi/domoticz/scripts/node-xiaomi-scale/scaleData.txt

kg=$(head -1  /home/pi/domoticz/scripts/node-xiaomi-scale/scaleData.txt)
bmi=$(tail -1 /home/pi/domoticz/scripts/node-xiaomi-scale/scaleData.txt)

maggiore=60
zero=0

if (( $(echo "$kg != $before" |bc -l) )); then
if (( $(echo "$kg > $maggiore" |bc -l) )); then

curl -s -k "http://127.1.1.1:8080/json.htm?type=command&param=udevice&idx=123&nvalue=0&svalue=$kg" > /dev/null
curl -s -k "http://127.1.1.1:8080/json.htm?type=command&param=udevice&idx=456&nvalue=0&svalue=$bmi" > /dev/null

elif (( $(echo "$kg > $zero" |bc -l) )); then

curl -s -k "http://127.1.1.1:8080/json.htm?type=command&param=udevice&idx=789&nvalue=0&svalue=$kg" > /dev/null
curl -s -k "http://127.1.1.1:8080/json.htm?type=command&param=udevice&idx=012&nvalue=0&svalue=$bmi" > /dev/null

fi
fi

Lo script è utile per due persone ma può essere allargato per quante preferite.
Gli IDX 123 e 456 si riferiscono ai KG e BMI della persona che pesa di più di 60 KG (come potrete notare dalla variabile maggiore è stato settato così, ma potete benissimo mettere quello che preferite in base alla vostra differenza di peso). 789 e 012 invece si riferiscono a quella che ha peso inferiore.

Inoltre lo script controlla che il valore non sia uguale al precedente (nel caso abbiate effettuato due letture consecutive).

NB: dovete aver installato sul vostro sistema Node JS.

Eventualmente potete anche creare l’automazione per far in modo che (ad esempio il Raspberry Pi) la bilancia venga interrogata la mattina, ad esempio alle 7, 8 o 9 di mattina (così da non dover ogni volta ripremere il tasto su Domoticz). Voi sapete che ogni giorno alle 7.00 di mattina la bilancia fornisce i dati, se ce ne sono: lo script li salva. Altrimenti no. Eseguite sudo crontab -e e incollate:

0 7 * * * /home/pi/domoticz/scripts/weight.sh
0 8 * * * /home/pi/domoticz/scripts/weight.sh
0 9 * * * /home/pi/domoticz/scripts/weight.sh

Come gestire e monitorare i consumi con Domoticz e la presa TP-Link HS100/HS110

Se non conoscete ancora la presa intelligente della TP-Link è ora di conoscerla… e acquistarla! Qui potete acquistare la HS100 che ha solo lo swtich on e off. Mentre qua per soli 5 euro in più potete acquistare quella con anche il monitoraggio della corrente.

Dovete prima di tutto creare un sensore virtuale che sia di tipo Wall socket. Inserite in on e off questi due (cambiate ovviamente gli IP).

Per il tasto on:

script:///home/pi/domoticz/scripts/tplink-smartplug.py -t 172.24.1.123 -c on

Per il tasto off:

script:///home/pi/domoticz/scripts/tplink-smartplug.py -t 172.24.1.123 -c off

Non premetelo ancora! Prima create lo script monitorare il consumo:

sudo nano /home/pi/domoticz/scripts/HS110.py

E incollate:

#!/usr/bin/env python
#
# TP-Link Wi-Fi Smart Plug Protocol Client
# For use with TP-Link HS110: energy monitor
#
# Gets current power (W) and cumulative energy (kWh)
# and sends to Domoticz
import socket
import argparse
import json
import urllib
import urllib2
# ip, port, and command for HS110
ip = '172.24.1.123'
port = 9999
cmd = '{"emeter":{"get_realtime":{}}}'
# Domoticz command stub and IDx of HS110
baseURL = 'http://127.1.1.1:8080/json.htm?type=command&param=udevice&nvalue=0'
HSIdx = 456
# Encryption and Decryption of TP-Link Smart Home Protocol
# XOR Autokey Cipher with starting key = 171
def encrypt(string):
key = 171
result = "\0\0\0\0"
for i in string:
a = key ^ ord(i)
key = a
result += chr(a)
return result
def decrypt(string):
key = 171
result = ""
for i in string:
a = key ^ ord(i)
key = ord(i)
result += chr(a)
return result
def domoticzrequest (url):
request = urllib2.Request(url)
#   request.add_header("Authorization", "Basic %s" % base64string)
response = urllib2.urlopen(request)
return None;
# Send command and receive reply
try:
sock_tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_tcp.connect((ip, port))
sock_tcp.send(encrypt(cmd))
data = sock_tcp.recv(2048)
sock_tcp.close()

#   print "Sent:     ", cmd
result = decrypt(data[4:])
jsonData = json.loads(result)
#   print "Received: "
#   print json.dumps(jsonData, indent=4, sort_keys=True)
power = jsonData['emeter']['get_realtime']['power']
total = jsonData['emeter']['get_realtime']['total'] * 1000
#   print power, total
except socket.error:
quit("Cound not connect to host " + ip + ":" + str(port))
# Send data to Domoticz
try:
url = baseURL + "&idx=%s&svalue=%s;%s" % (HSIdx, power, total)
domoticzrequest(url)
except urllib2.URLError, e:
print e.code

Create un altro sensore virtuale per monitorare il consumo:

Mentre questo sudo nano /home/pi/domoticz/scripts/tplink-smartplug.py incollate:

#!/usr/bin/env python
#
# TP-Link Wi-Fi Smart Plug Protocol Client
# For use with TP-Link HS-100 or HS-110
#
# by Lubomir Stroetmann
# Copyright 2016 softScheck GmbH
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#
import socket
import argparse
version = 0.1
# Check if IP is valid
def validIP(ip):
try:
socket.inet_pton(socket.AF_INET, ip)
except socket.error:
parser.error("Invalid IP Address.")
return ip
# Predefined Smart Plug Commands
# For a full list of commands, consult tplink_commands.txt
commands = {'info'     : '{"system":{"get_sysinfo":{}}}',
'on'       : '{"system":{"set_relay_state":{"state":1}}}',
'off'      : '{"system":{"set_relay_state":{"state":0}}}',
'cloudinfo': '{"cnCloud":{"get_info":{}}}',
'wlanscan' : '{"netif":{"get_scaninfo":{"refresh":0}}}',
'time'     : '{"time":{"get_time":{}}}',
'schedule' : '{"schedule":{"get_rules":{}}}',
'countdown': '{"count_down":{"get_rules":{}}}',
'antitheft': '{"anti_theft":{"get_rules":{}}}',
'reboot'   : '{"system":{"reboot":{"delay":1}}}',
'reset'    : '{"system":{"reset":{"delay":1}}}'
}
# Encryption and Decryption of TP-Link Smart Home Protocol
# XOR Autokey Cipher with starting key = 171
def encrypt(string):
key = 171
result = "\0\0\0\0"
for i in string:
a = key ^ ord(i)
key = a
result += chr(a)
return result
def decrypt(string):
key = 171
result = ""
for i in string:
a = key ^ ord(i)
key = ord(i)
result += chr(a)
return result
# Parse commandline arguments
parser = argparse.ArgumentParser(description="TP-Link Wi-Fi Smart Plug Client v" + str(version))
parser.add_argument("-t", "--target", metavar="<ip>", required=True, help="Target IP Address", type=validIP)
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("-c", "--command", metavar="<command>", help="Preset command to send. Choices are: "+", ".join(commands), choices=commands)
group.add_argument("-j", "--json", metavar="<JSON string>", help="Full JSON string of command to send")
args = parser.parse_args()
# Set target IP, port and command to send
ip = args.target
port = 9999
if args.command is None:
cmd = args.json
else:
cmd = commands[args.command]
# Send command and receive reply
try:
sock_tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_tcp.connect((ip, port))
sock_tcp.send(encrypt(cmd))
data = sock_tcp.recv(2048)
sock_tcp.close()
print "Sent:     ", cmd
print "Received: ", decrypt(data[4:])
except socket.error:
quit("Cound not connect to host " + ip + ":" + str(port))

Ora potete impostare un’automazione che esegua lo script di controllo del consumo e che aggiorni l’IDX corrispettivo.

Per comodità ho messo come IP della presa 172.24.1.123 e come IDX 456 (cercateli nei due script e modificateli).

Se non volete creare l’automazione che controlli il consumo, semplicemente create un altro sensore virtuale che al tasto on abbia come parametro:

script:///home/pi/domoticz/scripts/HS110.py

Abbastanza semplice no?

Dopo che avrete monitorato i consumi per qualche mese avrete a disposizione un bel grafico su cui poter lavorare:

Come monitorare la temperatura della CPU con Domoticz

Se volete controllare la temperatura della CPU del vostro Raspberry Pi e avere un grafico riportato nel vostro pannello Domoticz, vi basterà usare questo script:

sudo nano /home/pi/domoticz/scripts/cputemp.sh

E incollare (cambiate 123 in base all’IDX del sensore che avete su Domoticz)

#!/bin/bash

milcel=$(cat /sys/class/thermal/thermal_zone0/temp)

MEMUSG=`echo "scale=3;$milcel/1000" | bc`

curl -s -k "http://127.1.1.1:8080/json.htm?type=command&param=udevice&idx=123&nvalue=0&svalue=$MEMUSG" > /dev/null

Ora aggiungete a sudo crontab -e questo (controllerà ogni 5 minuti la temperatura, salvandovela nel sensore virtuale e facendovi poi un grafico):

5 * * * * /home/pi/domoticz/scripts/cputemp.sh

Come creare un sensore virtuale su Domoticz

Se volete creare un sensore virtuale per monitorare delle risorse che possono essere la temperatura della CPU, piuttosto che un bottone o tasto che esegue qualche script/applicativo, vi basterà aprire Domoticz e andare su HARDWARE. Selezionate Dummy (Does nothings, use for virtual switches only):

E dategli il nome che preferite (anche Dummy va bene). Ora cliccate su CREATE VIRTUAL SENSOR alla riga Dummy e aggiungete quello che preferite, ad esempio uno di temperatura:

Adesso spostatevi su DEVICE e segnatevi l’IDX che potrà servirvi per accedervi. Potrete semplicemente aggiornare il dato facendo una chiamata tipo (presupponendo IDX=123 e valore da aggiornare 99):

http://127.1.1.1:8080/json.htm?type=command&param=udevice&idx=123&nvalue=0&svalue=99</>

Semplice no?

Come tenere Domoticz sempre attivo

Dato che molto spesso tra sensori vari o thread aperti da plugin non troppo funzionanti Domoticz può smettere di funzionare da un punto all’altro, il mio suggerimento è quello di crearvi uno script gestito dal crontab e fare in modo che controlli ogni minuto se è attivo. E nel caso, lo riattivi. Presupponendo che l’abbiate installato nella home del vostro Raspberry Pi (nel caso cambiate semplicemente path):

sudo nano /home/pi/domoticz/scripts/checkdomoticz.sh

Incollate:

#!/bin/bash

ip=127.0.0.1
port=8080
idx=1

function jsonValue() {
KEY=$1
num=$2
awk -F"[,:}]" '{for(i=1;i<=NF;i++){if($i~/'$KEY'\042/){print $(i+1)}}}' | tr -d '"' | sed -n ${num}p
}

DOMOTICZ=`curl -s --connect-timeout 2 --max-time 5 "http://$ip:$port/json.htm?type=devices&rid=$idx"`
STATUS=$(echo $DOMOTICZ | jsonValue status 1)
OK="OK"

echo "Domoticz status = $STATUS"

if [ "$STATUS" == "" ] ; then

echo Domoticz status NOK1, retrying in 5 seconds...
sleep 5
DOMOTICZ=`curl -s --connect-timeout 2 --max-time 5 "http://$ip:$port/json.htm?type=devices&rid=$idx"`
STATUS2=$(echo $DOMOTICZ | jsonValue status 1)
echo Domoticz status = $STATUS2

if [ "$STATUS2" == "" ] ; then
echo Domoticz status NOK2, retrying in 5 seconds...
sleep 5
DOMOTICZ=`curl -s --connect-timeout 2 --max-time 5 "http://$ip:$port/json.htm?type=devices&rid=$idx"`
STATUS3=$(echo $DOMOTICZ | jsonValue status 1)
echo Domoticz status = $STATUS3

if [ "$STATUS3" == "" ] ; then
echo Domoticz status NOK3, stopping service, killing process, starting service...
sudo service domoticz stop
sleep 5
sudo service domoticz start
fi
fi
fi

Ora eseguite: sudo crontab -e

E aggiungete in fondo:

* * * * * /home/pi/domoticz/scripts/checkdomoticz.sh

Questo controllerà ogni minuto se è attivo, così male che vada (e nel caso non ci siano ovviamente problemi gravi) Domoticz vi rimarrà disattivato al massimo per 1 minuto.

Come configurare Monit con Domoticz

sudo nano /etc/monit/conf.d/domoticz

Copiate e incollate:

check process domoticz with pidfile /var/run/domoticz.pid
start program = "/etc/init.d/domoticz.sh start"
stop  program = "/etc/init.d/domoticz.sh stop"
if failed
url http://127.0.0.1:8080/json.htm?type=command&param=getversion
and content = '"status" : "OK"'
for 2 cycles
then restart
if 5 restarts within 5 cycles then exec "/sbin/reboot"

E poi riavviate Monit con:

sudo monit reload

Come configurare Monit con Plex

sudo nano /etc/monit/conf.d/plex

Incollate questo (modificando le porte nel caso vi servissero, ma la 32400 dovrebbe andar bene):

check process Plex with pidfile "/var/lib/plexmediaserver/Library/Application\ Support/Plex\ Media\ Server/plexmediaserver.pid"
    start program = "/usr/sbin/service plexmediaserver start" with timeout 60 seconds
    stop program  = "/usr/sbin/service plexmediaserver stop"
    if failed host 127.0.0.1 port 32400 with timeout 30 seconds for 5 cycles then restart
    #if failed port 32401 with timeout 30 seconds for 5 cycles then restart
    #if failed port 32469 with timeout 30 seconds for 5 cycles then restart
    #if failed port 1909 with timeout 30 seconds for 5 cycles then restart
    #if failed url http://127.0.0.1:32400/web/index.html with timeout 30 seconds for 5 cycles then restart

E poi riavviate Monit con:

sudo monit reload

Come configurare Monit con Transmission

sudo /etc/monit/conf.d/transmission

Copiate e incollate:

check process Transmission matching "transmission-daemon"
    start program = "/etc/init.d/transmission-daemon start"
    stop program  = "/etc/init.d/transmission-daemon stop"
    if failed host 127.0.0.1 port 9091 type TCP for 2 cycles then restart
    if 2 restarts within 3 cycles then unmonitor

E poi riavviate Monit con:

sudo monit reload

Come configurare Monit con Samba

Se avete precedentemente installato Monit e avete capito le sue infinite possibilità e volete monitorare il vostro server SMB, ecco come configurarlo perché controlli e nel caso riavvii Samba:

sudo nano /etc/monit/conf.d/smbmonitor

E incollate:

check process Samba with pidfile "/var/run/samba/smbd.pid"
start program = "/etc/init.d/smbd start"
stop program = "/etc/init.d/smbd stop"
if failed host 127.0.0.1 port 139 type tcp for 2 cycles then restart
if 2 restarts within 3 cycles then unmonitor

Poi riavviate Monit con sudo monit reload e andate da browser alla porta 2812 (nel caso non l’abbiate cambiata).