Archivi autore: LombaX

L’HomeLab di LombaX – seconda puntata

Home-assistant – telecamere e automazioni

Ed eccoci arrivati al secondo appuntamento della serie #LombaXHomeLab , potete trovare gli altri articoli semplicemente cliccando sull’hashtag.

Iniziamo ad analizzare più nel dettaglio le varie componenti del mio HomeLab, ho deciso di partire da Home Assistant (o Hass, in breve), che forse è un po’ il “cuore” del progetto. Tutto è iniziato da Home Assistant, inizialmente installato su un piccolo Raspberry Pi.

Raspberry

Poi, col tempo, le mie esigenze sono cambiate e ho dovuto potenziare il tutto con un Intel Nuc, ma questa è un’altra storia.

Cos’è Home Assistant? 

Dal sito ufficiale:

> “Open source home automation that puts local control and privacy first.“

Quindi, in poche parole, un Hub per tutti i dispositivi IoT di casa nostra, con un forte focus su controllo locale e privacy.

In questo articolo però non mi voglio focalizzare su cos’è Home Assistant o su informazioni “base” per installarlo, quindi non prendetelo come un tutorial, ma piuttosto uno stimolo alla vostra creatività. Non esitate, però, a commentare e chiedere chiarimenti qualora qualcosa non fosse chiaro.

Infine, dato che con Hass faccio tante cose, l’articolo sarebbe un po’ troppo “corposo” quindi lo spezzerò in varie puntate.

Questa è la schermata principale del mio Home Assistant:

Hass

É totalmente personalizzabile nel mood grafico, cosa che però non ho fatto e non penso che farò, perchè sono totalmente incapace in tutto ciò che ha a che fare con grafica e UX 🙂 quindi mi sono concentrato più su quello che c’è sotto il cofano.

Bando alle ciance, un breve indice e poi si parte.

Di cosa parleremo in questa serie di articoli?

  • Videosorveglianza: collegare e gestire telecamere, accenderle e spegnerle quando necessario
  • Controllo luci: gestione di luci di vari generi e vendor, automazioni per gestirle in base agli orari o a determinate condizioni
  • Comandi vocali: utilizziamo Siri per gestire luci, e magari anche la TV
  • Controllo temperature e alert: fa freddo? fa caldo? E se fa troppo caldo, ti avviso.
  • Tempi di viaggio previsti: a che ora parto per andare a lavoro?
  • Teniamo d’occhio i consumi di corrente: Engage Efergy

Videosorveglianza

In alto a sinistra vediamo le Telecamere, i primi componenti che ho iniziato a controllare con Home Assistant, che in questa immagine sono spente. Why?

La prima esigenza è nata proprio così: ho 2 telecamere D-Link (vecchiotte), che supportano 2 funzionalità importanti, motion detection e alert via e-mail. Purtroppo però non sono programmabili gli orari di attivazione, senza contare che questi orari non sono sempre prevedibili. Come attivare la videosorveglianza ma evitare di ricevere alert quando io o mia moglie siamo in casa? E come rispettare la nostra privacy?

Ho sfruttato alcune componenti di Home Assistant e un po’ di hardware “di riciclo”, che avevo in casa.

Perchè il bello di Home Assistant è proprio questo: 
oggi supporta circa 1.200 componenti, quindi è altamente probabile 
che il vecchio device IoT che avete comprato 2 anni fa, e che ora è 
chiuso in una scatola perchè non si integra con nulla, possa essere 
gestito con Home Assistant

Hardware:

  • Per l’accensione/spegnimento delle telecamere, ho usato due Belkin Wemo switch
  • Ovviamente le telecamere 🙂 , due D-Link di cui non ricordo il modello e forse poco importa

Wemo

Dlink

Software:

  • Hass gestisce nativamente gli switch Belkin Wemo, se sono sulla stessa rete locale li autorileva e può controllarli senza bisogno di far nulla. Tutti i device che possiedono un interruttore, sono chiamati “switch” su Hass, e vengono visualizzati con un semplice interruttore on-off nell’interfaccia.
  • Geolocalizzazione: un altro componente di Hass è il “device_tracker”, componente che rileva la posizione/presenza di un device (tipicamente un cellulare) in vari modi. Può eseguire scansioni temporizzate all’interno della rete con NMap per rilevare se il Mac Address del vostro cellulare è connesso, può basarsi sulla presenza rilevata tramite Bluetooth, oppure (come ho fatto io), sul GPS dei vostri cellulari.
  • Automazioni: un altro componente importante di Home Assistant è “automation”, che permette di eseguire automaticamente alcune attività solo se si presentano determinate condizioni.
  • OwnTracks: App disponibile su iOS e Android, traccia costantemente la posizione del vostro cellulare e la invia a un MQTT Broker di vostra scelta. Hass offre questa funzionalità anche con la sua App nativa, ma si tratta di una funzionalità implementata in un secondo momento, che non ho ancora testato.
  • MQTT: si tratta di un protocollo di messaging “machine to machine” molto leggero, lo useremo per “trasportare” le informazioni di localizzazione da OwnTracks a Hass. Necessità di un server MQTT, nel mio caso ho deciso di utilizzarne uno cloud e gratuito chiamato CloudMQTT. Hass dovrebbe avere un MQTT server integrato, ma anche in questo caso si tratta di una funzionalità aggiunta in seguito, che non ho ancora testato.

NB: Hass ha moltissimi “componenti”, ma un altro componente core che vale la pena citare anche se in questo caso non è stato utilizzato, si chiama “sensor”.
Un Sensor permette di rilevare lo stato di qualsiasi cosa. Esistono sensori fisici (es. un termometro digitale, un rilevatore di movimento, un rilevatore di gas), sensori “virtuali” (es che rilevano le previsioni del tempo, quando il sole sorgerà o tramonterà).

Ora che abbiamo tutti gli ingredienti, la ricetta:

Sorvolo sul collegamento di Switch Belkin Wemo e delle Telecamere, in pochi minuti sarete in grado di collegarli e fare in modo di accendere/spegnere le telecamere dall’interfaccia di Hass.

Una volta fatto ciò, dobbiamo collegare Hass al nostro MQTT Broker, in configuration.yaml andiamo a inserire i dati di CloudMQTT (dopo esservi iscritti, li trovate nella vostra area personale)

In configuration.yaml andiamo a inserire i seguenti dati (NB yaml è sensibile all’indentazione, quindi ricontrollatela bene perchè potrebbe essere “saltato” qualche spazio durante il copia e incolla)

mqtt:
  broker: xxx.cloudmqtt.com
  port: 10109
  username: “your_username”
  password: “your_password”

questi stessi dati andranno inseriti su OwnTracks, con l’aggiunta di un id che identifichi il cellulare (chiamato Topic nel gergo di MQTT). Nel mio caso avremo 2 topic, uno per il mio cellulare (es marito) e uno per mia moglie.

A questo punto, nel file known_devices.yaml di Hass andiamo a inserire 2 nuovi devices:

your_username_marito:
  name: MaritoiPhone
  track: yes
  hide_if_away: no

your_username_moglie:
  name: MoglieiPhone
  track: yes
  hide_if_away: no

Mancano ancora un paio di cose. Sempre in configuration.yaml dobbiamo inserire la posizione di casa

zone:
  name: home
  latitude: 11.12345
  longitude: 22.23456
  radius: 250

(NB ho scelto un raggio un po’ ampio, 250 metri, ma nulla vi vieta di modificarlo. Fate un po’ di prove, la scelta giusta dipende anche dalla precisione del vostro cellulare)

A questo punto, Hass dovrebbe essere in grado di rilevare se siete in casa o no:

Infine, dobbiamo creare un “gruppo” per la famiglia (per rilevare quando almeno un membro della famiglia è in casa), e uno con gli switch delle Telecamere (per accenderle/spegnerle entrambe contemporaneamente)

group:
  family:
    name: Famiglia
    view: yes
    entities:
      - device_tracker.your_username_moglie
      - device_tracker.your_username_marito
  telecamere:
    name: Telecamere
    entities:
      - switch.telecamera_sala
      - switch.telecamera_studio

A questo punto siamo pronti per creare la nostra automation

automation:
  - alias: Turn on camera when family outside
    trigger:
      platform: state
      entity_id: group.family
      from: 'home'
    action:
      - service: switch.turn_on
        entity_id: group.telecamere
      - service: notify.ios_iphone_di_lombax
        data:
          message: "Telecamere accese"
          data:
            push:
              badge: 0
              category: "DEFAULT_NOTIFICATION"
  - alias: Turn off camera when family inside
    trigger:
      platform: state
      entity_id: group.family
      to: 'home'
    action:
      - service: switch.turn_off
        entity_id: group.telecamere
      - service: notify.ios_iphone_di_lombax
        data:
          message: "Telecamere spente"
          data:
            push:
              badge: 0
              category: "DEFAULT_NOTIFICATION"

Molto semplice, come potete vedere.

Nella prima automation stiamo dicendo che quando lo “state” del gruppo “family” non è più “home” (ricordate come abbiamo chiamato la zona di casa nostra?), deve scattare una action “switch.turn_on” sul gruppo “telecamere”. Nel secondo, viceversa.

In questa configurazione vedete anche un “service” specifico per le notifiche. Si tratta di un tema che vedremo in uno dei prossimi articoli, vi basti sapere che…quando l’automazione si verifica, ricevo una notifica push sul mio cellulare.

Per oggi è tutto, alla prossima puntata!

L’HomeLab di LombaX – prima puntata

Da appassionato di tutto ciò che è il mondo informatico, ho sempre avuto voglia di “toccare con mano” le tecnologie che ritengo più interessanti. Un po’ come il garage è “la stanza dei giochi” per un appassionato di meccanica o bricolage, l’HomeLab è la stanza dei giochi dell’appassionato di informatica, qualcosa che nasce per hobby, e viene coltivato sempre per hobby. Poi, nel tempo, diventa utile…probabilmente (almeno nel mio caso) non indispensabile…perchè poter dire “ehi Siri, accendi il Natale” per far accendere l’albero e varie luci colorate è cool, ma si può vivere anche senza 🙂

Questa sarà l’intro di una serie di articoli più tecnici e hands on, penso che una premessa – prima di entrare nei dettagli dei singoli servizi e tecnologie utilizzate per realizzare il mio HomeLab – sia d’obbligo. Farà anche un po’ da indice per i prossimi articoli.

Quindi…com’è il mio HomeLab? Cosa fa? A che serve? Come è organizzato?

Intel Nuc

 

Postazione

​Io direi di partire dai servizi, principalmente domotica, automazione, monitoring e multimedia in casa:

– fa da hub per tutti i dispositivi domotici che ho in casa (lampadine Philips Hue, switch Belkin Wemo e Sonoff, termometri “artigianali” sviluppati su Raspberry Pi, TV), permettendomi di accenderli e spegnerli da remoto (pc o cellulare), di controllare le temperature ecc…

– si interfaccia con Siri e HomeKit di Apple, permettendo a me e mia moglie di controllare gli stessi dispositivi con comandi vocali ai nostri iPhone o Apple Watch. “Ehi Siri, accendi le luci della Sala”, “spegni le luci della Camera”, “imposta luci calde in Studio”, “dimmi che temperatura c’è in Soggiorno”.

– gestisce la TV (Samsung Smart TV), permettendoci di accenderla, spegnerla, gestire canali e volumi sempre tramite controllo vocale

– ci permette di memorizzare file (documenti, foto, video) in una condivisione di grandi dimensioni e al tempo stesso proteggerli (encryption + backup offsite – in  particolare su Amazon AWS S3), ci permette di vederli direttamente in tv condividendoli con il protocollo DLNA.

– gestisce il nostro “mini” impianto di videosorveglianza, la casa è piccola ma abbiamo un paio di telecamere, tuttavia per rispetto della nostra privacy preferiamo che si spegnano quando io o mia moglie siamo a casa. Quindi, tramite geolocalizzazione sul cellulare e protocollo MQTT, non appena uno dei due entra in casa, le telecamere si disattivano.

– ci avvisa, tramite notifiche sul cellulare, se qualcosa non va: temperature troppo alte, rilevato movimento dalle telecamere

– gestisce un minimo di automazione: se siamo fuori casa facciamo accendere le luci al crepuscolo, così da non lasciare il cane al buio

– permette di monitorare consumi elettrici, banda internet, temperature delle varie stanze, con grafici facilmente esplorabili

– protegge, filtra e monitora la navigazione internet (tramite Pi-hole e protocollo SNMP)

…e questa lista è in continua evoluzione 🙂

Il componenti principali, ad oggi, sono:

Software

– Home Assistant: è l’hub di automazione principale, in brevissimo, si connette a tutti i device IOT della casa e permette di interagirci da un’unica interfaccia, integrata con HomeKit (e anche con la concorrenza… 🙂 ). Scriverò un articolo specifico in proposito, ma nel frattempo potete informarvi meglio quì: Home Assistant

Home Assistant

– Grafana: software per creare dashboard come queste

Grafana

– InfluxDB, memorizza tutte le metriche da HomeAssistant e altri servizi, permettendo poi di visualizzarle su Grafana

– Pi-hole, dns server che blocca la maggior parte dei domini di advertising, phishing e malevoli, rendendo più sicura e anonima la navigazione internet

Pihole

– MiniDLNA per condividere in rete i file multimediali e vederli dalla tv

– Un po’ di software custom (linguaggi principali utilizzati: PHP, Javascript con Node.js, Python e un bel po’ di sano bash scripting) scritto per fare da “collante” dove necessario.

– VMWare ESXi 6.7 per virtualizzare il tutto

vmware 1

vmware 2

 

XSIBackup per il backup delle macchine virtuali

– OS: il mio OS principale è MacOS, ma adoro anche Linux e in casa mia non viene discriminato nemmeno Windows, in questo momento (tra portatili, fissi e virtuali) almeno una 15ina di macchine: 2 mac, 3 windows, il resto Linux (Ubuntu o Raspbian, in generale sono della squadra Debian) 🙂

– Apple Homekit per i comandi vocali

– OWNTracks su cellulare per la geolocalizzazione

– Altri servizi esterni: quando necessario, mi appoggio ad Amazon AWS (in questo momento S3 per i backup) e OVH (macchina virtuale su cui risiede questo sito e alcuni script di controllo). CloudMQTT come broker MQTT per geolocalizzazione e temperature

Hardware

– Intel NUC 7th gen. i3, NVMe Samsun Evo 970 da 500GB per le virtual, Seagate BarraCuda da 2TB per storage, 16GB di RAM

nuc

 

samsung evo nvmenvme speed

– Alcuni dischi USB esterni per i backup delle macchine virtuali

– Hub e luci Philips HUE

– Hub Engage Efergy per il controllo dei consumi elettrici

– Vari Belkin Wemo e Sonoff come smart switch

– Telecamere D-Link

– UPS

– 4 Raspberry Pi sparsi per casa per controllare temperature (sensori DHT-22) o fare da Thin Client verso le macchine virtuali

Raspberry

– 3 Monitor (Lenovo 27″ 4K, Samsung 24″ FullHD, Samsung 19″ “di servizio”)

I motivi di queste scelte saranno dettagliati negli articoli di approfondimento, ma è bene tener presente alcuni “constraints” che mi hanno portato a farle:

– come detto a inizio articolo, tutto nasce principalmente per hobby. Voglia di provare delle tecnologie, hype, voglia di imparare un particolare linguaggio o usare uno strumento…quindi non cercate troppa logica in quello che ho fatto. Sicuramente si poteva “ingegnerizzare” meglio, ma lo scopo principale era uno solo: intrattenermi, e vi assicuro che ad oggi lo scopo è raggiunto 😉

– spendere “il giusto”. Ognuno di noi ha un concetto, totalmente personale, di quanto sia “il giusto”, e non è sempre uguale in ogni momento della vita. Il mio HomeLab è nato un pezzo alla volta, in alcuni momenti si è evoluto più velocemente, in altri meno. Lo espando per “iterazioni”. Generalmente, se in 2-3 occasioni all’anno sono più libero e mi avanzano 200-300€, mi “coccolo” regalandomi qualche pezzo di hardware nuovo (telecamere, switch, dischi ecc ecc). Tranne questo Natale che ho fatto evaporare una parte consistente di 13esima…ma questa è un’altra storia che leggerete nell’approfondimento dedicato all’Intel NUC.

– limitare i consumi elettrici: l’HomeLab (monitor esclusi, quindi Intel Nuc, disco esterno, router Internet + Wifi, UPS e qualche Raspberry) consuma appena 40watt! Con i 2 monitor principali accesi, arrivo a 120watt!

Direi che per la premessa è tutto.

Ora ci dobbiamo concentrare sui dettagli tecnici – più divertenti – relativi ai vari punti. I prossimi articoli quindi andranno a esplorare nel dettaglio tutti i punti sopra riportati, uno alla volta (man mano aggiungerò link a questo articolo).

Se avete domande o preferenze su quale argomento trattare per primo non esitate a commentare.

LombaXMonday N° 10 – links and resources from the IT World

What is this? Every day I read a lot of articles about computer programming and languages, infrastructures, new technologies, quick tips, trends, architectures and so on. I read them immediately or put in my “read later” list. All my readings helped me to grow and learn new things…so why don’t share them with my readers? For this reason, I decided to publish and share, every monday, a list of the links I came accross during the past days.


Node.js project for reading temperatures from DHT11 – DHT22 and send it to an MQTT Broker via Raspberry Pi – link

Create a budget Temperature and Humidity Wireless monitor with Raspberry Pi and DHT sensors.

Each sensor, if using Pi Zero W and DHT22, costs about 35€

The linked project is a Node.js wrapper that can be added to the Raspberry crontab and:

– reads the temperature from the attached sensor
– sends it to an MQTT broker

Then, you can read the temperature from your central Home Assistant

In the next days I’ll write a detailed post about the complete project, that consists of a central hub (Raspberry Pi + Home Assistant) and many Raspberry Pi Zero W as sensors for the rooms.

IMG_1302

Schermata 2018-09-17 alle 11.10.23

Stay tuned for the detailed post in few days


An example of response time and server costs optimization – link and link

I’m sure that you know Troy Hunt. And if you don’t…he is the creator of https://haveibeenpwned.com , a database containing over 500 million passwords from previous data breaches in big companies like LinkedIn, Adobe etc…

He recently added a free-to-use and free-to-integrate API for searching if a password is in the pwned database, sending only the first 5 digits of the SHA-1 hash of the password, with a simple call like this

https://api.pwnedpasswords.com/range/21BD1

This can be integrated in every password form (web, application) and suggest users if their password is in the pwned database.

But we are not here to talk about the service 🙂 but how it scaled a lot and why it is so fast.

Click on the first link for a very interesting article about how he optimized performances (calls below 50ms) of the hosting.

In the second link, you can find another very interesting article that focus on the costs, and how it’s possible to spend LESS THAN 1$/month to run a service that receives more than 140 million hits per month.


Analyze disk usage on Unix with ncdu – link

Linux o MacOS without free space? Do you want to find quickly that folder with a bunch of .old|.bak|.wtf files that you haven’t touched in the last 10 years?

#Linux
apt-get install ncdu 

#Mac
brew install ncdu

From Wikipedia:

ncdu (NCurses Disk Usage) is a disk utility for Unix systems. Its name refers to its similar purpose to the du utility, but ncdu uses a text-based user interface under the [n]curses programming library.[1] Users can navigate the list using the arrow keys and delete files that are taking up too much space by pressing the ‘d’ key. Version 1.09 and later can export the file listing in JSON format.

Ncdu_screenshot


 

That’s all for today’s LombaXMonday, if you liked it, have any question or want to let me know that this article sucks, don’t hesitate to add a comment 🙂

LombaXMonday N° 9 – links and resources from the IT World

What is this? Every day I read a lot of articles about computer programming and languages, infrastructures, new technologies, quick tips, trends, architectures and so on. I read them immediately or put in my “read later” list. All my readings helped me to grow and learn new things…so why don’t share them with my readers? For this reason, I decided to publish and share, every monday, a list of the links I came accross during the past days.


What is Branch Prediction – link

An impressive explanation of what is branch prediction and how knowing it could help us to write more efficient code. Read the whole question and the accepted answer, it’s worth it


Distributed JWT Token Cracker – link

A tool written in Javascript by Luciano Mammino (more info in the link), for cracking JWT Token via bruteforce. This tool is distributed, it means that you can publish a server (take track of the job) and as many client as you want, to increase the cpu power.


How to fix npm broken dependencies – link

You are using a fantastic npm dependency but…there is a bug. And you can’t modify the source in the node_modules because at every npm install/update you lose your modifications? Don’t worry, this tool will save your life (personally, I prefer to fork and update the dependency directly on Github…but “de gustibus”)


 

That’s all for today’s LombaXMonday, if you liked it, have any question or want to let me know that this article sucks, don’t hesitate to add a comment 🙂

How to create an IVR that reads from Google Sheet with Amazon Connect and AWS Lambda

In this quick tutorial, I will explain how to create a basic IVR that can access a Google Sheet and communicate a 3 digit code via voice.

This tutorial assume that you have a basic knowledge of AWS Console, what is AWS Lambda (the demo function is written in Javascript) and how to create, upload and debug a function via the console.

Need: we have this basic “manual” and “human” flow. We have a safe with a 3 digit code. This safe contains the key of a specific room in the office that must be protected but sometimes opened by guests when no staff is in the office, and we want to give them access only after a phone authorization. When someone has access, the code is changed (usually the day after).

So a guest now do this:
– in front of the safe there is a phone number.
– the guest calls the phone number
– me or my colleague answer and give him the code (The code is stored in a Google Sheet to permit us to find and remember it easily after a change)
– the guest opens the safe and take the key of the room
– the day after, the member of the staff who received the call changes the safe code and update the Google Sheet

What we want now, is to change this flow to avoid that someone of the staff answer to the phone in the night only for giving a stupid 3 digit code 🙂

Start with Amazon Connect.

1) Claim a new Phone Number

1 - claim phone number

2) create a contact flow

2 - create contact flow

3 - create contact flow

3) edit the contact flow like this

4 - contact flow details

4) look at the configuration of “Invoke AWS Lambda Function”

Specifically, in the “Invoke AWS Lambda Function”,  you must insert your function ARN.
By now you haven’t created the Lambda function yet, so leave this field empty, but after creating the function you will insert the ARN which is a code like this:

arn:aws:lambda:eu-central-1:123456789012:function:name-of-lambda-function

4) change the “Play prompt” configuration

The upper “play prompt” must be configured like in this image

5 - play prompt details

 

the lower one is simply an audio that plays “There was an error”

That’s all by now, simply save and publish.

100 - publish

If you call the phone number now, you will hear “There was an error”


 

Now, let’s create a Lambda function. You have to edit it in your local editor, the lambda function must be uploaded via .zip file (or s3) with the whole node_modules directory and the Google credentials.

Disclaimer: This function is not well formatted and organized, I copied and pasted it adding some spaghetti code, so rewrite it as you prefer 🙂 however it works.

var fs = require('fs');
var readline = require('readline');
var google = require('googleapis');
var googleAuth = require('google-auth-library');
// If modifying these scopes, delete your previously saved credentials
// at ~/.credentials/sheets.googleapis.com-nodejs-quickstart.json
var SCOPES = ['https://www.googleapis.com/auth/spreadsheets.readonly'];
//var TOKEN_DIR = (process.env.HOME || process.env.HOMEPATH || process.env.USERPROFILE) + '/.credentials/';
var TOKEN_DIR = './.credentials/';
var TOKEN_PATH = TOKEN_DIR + 'sheets.googleapis.com-nodejs-quickstart.json';
var final_callback = null;
/**
 * Create an OAuth2 client with the given credentials, and then execute the
 * given callback function.
 *
 * @param {Object} credentials The authorization client credentials.
 * @param {function} callback The callback to call with the authorized client.
 */
function authorize(credentials, callback) {
    var clientSecret = credentials.installed.client_secret;
var clientId = credentials.installed.client_id;
var redirectUrl = credentials.installed.redirect_uris[0];
var auth = new googleAuth();
var oauth2Client = new auth.OAuth2(clientId, clientSecret, redirectUrl);
// Check if we have previously stored a token.
fs.readFile(TOKEN_PATH, function(err, token) {
        if (err) {
            getNewToken(oauth2Client, callback);
} else {
            oauth2Client.credentials = JSON.parse(token);
callback(oauth2Client);
}
    });
}

/**
 * Get and store new token after prompting for user authorization, and then
 * execute the given callback with the authorized OAuth2 client.
 *
 * @param {google.auth.OAuth2} oauth2Client The OAuth2 client to get token for.
 * @param {getEventsCallback} callback The callback to call with the authorized
 *     client.
 */
function getNewToken(oauth2Client, callback) {
    var authUrl = oauth2Client.generateAuthUrl({
        access_type: 'offline',
scope: SCOPES
    });
console.log('Authorize this app by visiting this url: ', authUrl);
var rl = readline.createInterface({
        input: process.stdin,
output: process.stdout
});
rl.question('Enter the code from that page here: ', function(code) {
        rl.close();
oauth2Client.getToken(code, function(err, token) {
            if (err) {
                console.log('Error while trying to retrieve access token', err);
return;
}
            oauth2Client.credentials = token;
storeToken(token);
callback(oauth2Client);
});
});
}

/**
 * Store token to disk be used in later program executions.
 *
 * @param {Object} token The token to store to disk.
 */
function storeToken(token) {
    try {
        fs.mkdirSync(TOKEN_DIR);
} catch (err) {
        if (err.code != 'EEXIST') {
            throw err;
}
    }
    fs.writeFile(TOKEN_PATH, JSON.stringify(token));
console.log('Token stored to ' + TOKEN_PATH);
}


function readCode(auth) {
    var sheets = google.sheets('v4');
sheets.spreadsheets.values.get({
        auth: auth,
spreadsheetId: 'XXXXXX', // id of the spreadsheet
range: 'SHEET_NAME!A1:A1', // cell name for the code
}, function(err, response) {
        if (err) {
            console.log('The API returned an error: ' + err);
return;
}
        var rows = response.values;
if (rows.length == 0) {
            console.log('No data found.');
} else {
            if (final_callback) {
                final_callback(null, {code: rows[0][0]});
}
        }
    });
}


exports.handler = (event, context, callback) => {
    // Load client secrets from a local file.
fs.readFile('client_secret.json', function processClientSecrets(err, content) {
        if (err) {
            console.log('Error loading client secret file: ' + err);
return;
}
        // Authorize a client with the loaded credentials, then call the
        // Google Sheets API.
authorize(JSON.parse(content), readCode);
});
final_callback = callback;
};
exports.handler('1','2', (a, b) => console.log(b.code));

in the readCode function you have these 2 parameters to fill:

spreadsheetId: 'XXXXXX', // id of the spreadsheet
range: 'SHEET_NAME!A1:A1', // cell name for the code

Some things to remember:

– You will need a Google client_secret.json file
– You have to execute this function at least one time from your PC. The function will ask you to visit a Google link to obtain a token and paste it back. The token is then saved in a .credentials folder inside your project directory (you have to create it!!). Then, the credentials file must be uploaded with the function to Lambda.
– You have to include the whole node_modules directory to the uploaded zip file.
– create the Lambda function in the same region of Connect

After doing this, the last things to do are:

– Connect the Amazon Connect “Invoke AWS Lambda Function” node to the right function ARN, you can find it in the AWS Lambda section in the upper right corner.
– Add the correct permissions to Connect for accessing the Lambda function, this must be done via AWS CLI with this command

aws lambda add-permission –function-name function:lambda-function-name –statement-id 1 –principal connect.amazonaws.com  –action lambda:InvokeFunction –source-account 123456789012 –source-arn arn:aws:connect:eu-central-1:123456789012:instance/faf03769-52ce-4577-bedf-dd82c9a933c8 –region eu-central-1

Parameters are:

–function-name is always “function:xxxx” where xxx is the lambda function name
–source-account is your Amazon account ID, you find it in the upper-right “My Account” section of AWS Console
–source-arn is the Amazon Connect ARN
–region  is the Connect and Lambda region

That’s all, if you have done all correctly, you will hear a prompt with the code present in your Google Sheet file.

Next step, this code should be improved to add some controls, for example to save the CLI for the caller and to block anonymous calls, so our staff can know when and who called.

If something is not clear feel free to write me an e-mail.

Bye

Fabio Lombardo

 

 

 

LombaXMonday N° 8 – links and resources from the IT World

What is this? Every day I read a lot of articles about computer programming and languages, infrastructures, new technologies, quick tips, trends, architectures and so on. I read them immediately or put in my “read later” list. All my readings helped me to grow and learn new things…so why don’t share them with my readers? For this reason, I decided to publish and share, every monday, a list of the links I came accross during the past days.


Linux quick tips & commands for performance monitoring

Here is my list of commands that I use to understand why a Linux machine is hanging, running slow or having unexpected behavior

Process analysis, load average, wa, cpu/ram used, disk usage
top
htop
iotop

Process tree, uninterruptible sleep process (D)
ps auxf –> D state processes are in uninterruptible sleep
ps axl –> under the WCHAN column you can see on which kernel function uninterruptible sleep processes are stuck

Stats over time
vmstat 1
iostat 1

Network
netstat
ss -l (network queue length)

Tracing
lsof
strace -e trace=open <application> <— trace an application
strace -e trace=open -p <pid> <— trace a pid

 


Ultra fast http server for local file sharing

python -m http.server 7777

warning: this command shares the content of the current directory via the choosen port (in this case 7777) to the WHOLE WORLD. Use carefully and remember to close it when you have finished


Bash parameter expansion in depth – link

An useful article that explains in depth how parameter expansion works in bash


That’s all for today’s LombaXMonday, if you liked it, have any question or want to let me know that this article sucks, don’t hesitate to add a comment 🙂

LombaXMonday N° 7 – links and resources from the IT World

What is this? Every day I read a lot of articles about computer programming and languages, infrastructures, new technologies, quick tips, trends, architectures and so on. I read them immediately or put in my “read later” list. All my readings helped me to grow and learn new things…so why don’t share them with my readers? For this reason, I decided to publish and share, every monday, a list of the links I came accross during the past days.


Quickstart with Elasticsearch – link

I always wanted to try Elasticsearch but the time is never enough. I found this 5 minutes tutorial that is a good start point.

One quicker variant is to use the elasticsearch docker image to do all the tests. At this link you will find how, shortly:

docker pull docker.elastic.co/elasticsearch/elasticsearch:5.4.1

docker run -p 9200:9200 -e "http.host=0.0.0.0" -e "transport.host=127.0.0.1" docker.elastic.co/elasticsearch/elasticsearch:5.4.1

Another thing to do, in all the example curl commands of the provided links you must add the authentication. For example, the command

curl -XPUT 'http://localhost:9200/blog/user/dilbert' -d '{ "name" : "Dilbert Brown" }'

must be changed in

curl --user elastic:changeme -XPUT 'http://localhost:9200/blog/user/dilbert' -d '{ "name" : "Dilbert Brown" }'

adding –user elastic:changeme (default user-password of the Elasticsearch docker image).
Enjoy


Chain of Responsibility Pattern – link

and why is different from the Decorator Pattern: link and link


Comment one line programmatically with sed

Quick tip: suppose we have this line in /etc/php5/cgi/php.ini file

disable_functions = pcntl_alarm,pcntl_fork

if we want to comment this line programmatically, simply do

sed -e '/disable_functions/ s/^;*/;/' -i /etc/php5/cgi/php.ini

 


That’s all for today’s LombaXMonday, if you liked it, have any question or want to let me know that this article sucks, don’t hesitate to add a comment 🙂

LombaXMonday N° 6 – links and resources from the IT World

What is this? Every day I read a lot of articles about computer programming and languages, infrastructures, new technologies, quick tips, trends, architectures and so on. I read them immediately or put in my “read later” list. All my readings helped me to grow and learn new things…so why don’t share them with my readers? For this reason, I decided to publish and share, every monday, a list of the links I came accross during the past days.


JQ, an useful tool for handling JSON – link and link

JQ is a very useful command line tool for handling JSON.
It permits you to extract parts of a JSON using a simple syntax.

Look at this example

If you want to take the Title and the Acronym (and change their name):

curl 'https://www.lombax.it/documents/json.json' | jq '.glossary | {MyTitle: .title, MyAcronym: .GlossDiv.GlossList.GlossEntry.Acronym}'

Explore utf8mb4 performance in the new MySQL 8.0 (not yet released) – link

MySQL 8.0 is in the last phases of the development process and it brings a lot of new features. One of this is an huge increase in performances even using the news utf8mb4 encoding.


HTTPS on StackOverflow – link

Implementing HTTPS on a website may seem simple and straightforward. But what happens when you manage the world biggest Q&A site with hundreds of domains?
Enjoy this (long but good) post by Nick Craver


That’s all for today’s LombaXMonday, if you liked it, have any question or want to let me know that this article sucks, don’t hesitate to add a comment 🙂

LombaXMonday N° 5 – links and resources from the IT World

What is this? Every day I read a lot of articles about computer programming and languages, infrastructures, new technologies, quick tips, trends, architectures and so on. I read them immediately or put in my “read later” list. All my readings helped me to grow and learn new things…so why don’t share them with my readers? For this reason, I decided to publish and share, every monday, a list of the links I came accross during the past days.


Inspect and inject HTTP/HTTPS requests with mitmproxy – link

Mitmproxy is an useful tool for web developers. It permits to inspect web requests (https requests to) acting as a middleware between your browser and the final url. Yes, modern browser inspectors gives us the inspection functionalities without installing anything, but mitmproxy permits you to block/pause the requests and inject/change the content manually. You can add filters on specific words/patterns in the request (url, cookies and so on), and then mitmproxy will block the request and wait for your input. Then, you will be able to change the request content. This is useful expecially when debugging complex request/response flows: you will be able to do all the flow via browser, and then add a “breakpoint” only when needed. Cool


Cloud Computing comes at a price – link

Short story of a startup that forgot that “pay per use” is not always as cheap as it seems…expecially if you don’t make correct planning


That’s all for today’s LombaXMonday, if you liked it, have any question or want to let me know that this article sucks, don’t hesitate to add a comment 🙂