Ipotizziamo di avere un file zip sotto la directory download, vogliamo leggerlo e scompattarlo nella directory dove lanciamo la routine go.

reader, err := zip.OpenReader("C:\\Users\\Valerio\\Downloads\\rdt.zip")
	if err != nil {
		fmt.Println("Errore: ", err)
	}

A questo punto creiamo una directory rdt con permessi di scrittura

err = os.Mkdir("rdt", 0755)
	if err != nil {
		fmt.Println("Errore: ", err)
	}

Infine scorriamo l’elenco dei file presenti all’interno dello zip, li leggiamo e li copiamo all’interno della directory appena generata

fileszip := reader.File
	for _, fil := range fileszip {
		singlereader, _ := fil.Open()
		newpath := filepath.Join("rdt", fil.Name)
		newfile, _ := os.Create(newpath)
		io.Copy(bufio.NewWriter(newfile), singlereader)
	}

In questo esempio di nuovo vediamo il pakage filepath che ci permette di costruire dei percorsi sul file system con la function Join che concatena i percorsi ricevuti.

Alla prossima

Vediamo come creare un tar e un file zip. In particolare consideriamo una cartella e mettiamo il contenuto della cartella in un file tar e in un file zip

package main

import (
	"archive/tar"
	"archive/zip"
	"fmt"
	"io/ioutil"
	"os"
)

func main() {
	fmt.Println("Start")

	filetar, err := os.Create("../mytar.tar")
	filezip, err := os.Create("../mytar.zip")

	if err != nil {
		fmt.Println("Errore: ", err)
	}
	writerTar := tar.NewWriter(filetar)
	writerZip := zip.NewWriter(filezip)

	defer writerTar.Close()
	defer writerZip.Close()

	files, err := ioutil.ReadDir(".")
	for _, singlefile := range files {
		if !singlefile.IsDir() {
			content, _ := ioutil.ReadFile(singlefile.Name())
			hdr := &tar.Header{
				Name: singlefile.Name(),
				Size: singlefile.Size(),
			}
			err = writerTar.WriteHeader(hdr)
			writerTar.Write(content)

			wr, _ := writerZip.Create(singlefile.Name())
			wr.Write(content)
		}
	}

	fmt.Println("End")
}

Tramite la fucntion Create creo sia il file tar che il file zip e per ognuno di essi genero un writer. Tramite il comando defer mi assicuro che la chiusura del writer venga effettuato alla fine di tutti i miei comandi.

Tramite la funcion readDir recupero tutti i file della directory corrente, genero l’header per il tar che inizializzo con il nome e la size del file che sto provessando e finalmente posso scrivere tramite il writer sia l’header che il contenuto del file.

Per lo zip il giro è ancora più semplice perchè non è obbligatorio il passaggio dell’header.

Nel prossimo articolo vedremo come leggere e recuperare i dati dai miei archivi.

Per effettuare una GET si usa la funzione get, che restituisce un oggetto Response e un oggetto Error.

response, err := http.Get("http://www.google.it")
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()
	fmt.Println("Response status:", response.Status)
	body, err := ioutil.ReadAll(response.Body)
	fmt.Println("Response body:", string(body))

Nell’esempio sto invocando la homepage di google, e verifico la presenza di errore e il codice restituito dalla risposta. Successivamente tramite il package ioutil recupero il body della response e lo stampo a video.

Se invece volessi inviare una post Golang mette a disposizione 2 funzioni: post e postForm.

La funzione post riceve in ingresso l’url cui inviare la post, il content type del dato che sto inviando e un reader del package io

response, err = http.Post("http://www.google.it", "image/jpeg", bytes.NewBufferString("prova"))
	if err != nil {
		panic(err)
	}
	fmt.Println("Response status:", response.Status)

La funzione postForm invece riceve in ingresso l’url cui inviare la post e il form dei dati chiave, valore

Le 3 funzioni consentono di inviare get e post, ma qualora volessi usare altri metodi come la put o la delete occorre usare il metodo addNewRequest per creare una request e usare il client http per inviare la richiesta.

request, err := http.NewRequest(http.MethodDelete, "http://www.google.it", bytes.NewBufferString("prova"))
	if err != nil {
		panic(err)
	}
	client := &http.Client{}
	response, err = client.Do(request)
	if err != nil {
		panic(err)
	}
	fmt.Println("Response status:", response.Status)

Per gestire le caratteristiche avanzate delle connessioni Go mette a disposizione l’oggetto Transport che opportunamente configurato consente di definire un proxy per l’invocazione del servizio. Questo caso si presenta quando il nostro client è presente all’interno di una rete il cui accesso ad internet è veicolato dalla presenza di un proxy.

proxyUrl, err := url.Parse("http://user:password@127.0.0.1:3128")
	if err != nil {
		panic(err)
	}
	tr := &http.Transport{
		MaxIdleConns:       10,
		IdleConnTimeout:    30 * time.Second,
		DisableCompression: true,
		Proxy:              http.ProxyURL(proxyUrl),
	}
	client = &http.Client{Transport: tr}
	response, err = client.Do(request)
	if err != nil {
		panic(err)
	}
	fmt.Println("Response status:", response.Status)

Qualora invece il nostro server voglia un certificato occorre caricare il certificato e configurato sempre nel transport affinchè venga usato in trasmissione

caCert, err := ioutil.ReadFile("miocertificato.crt")
	if err != nil {
		log.Fatal(err)
	}
	caCertPool := x509.NewCertPool()
	caCertPool.AppendCertsFromPEM(caCert)
	tr := &http.Transport{
		MaxIdleConns:       10,
		IdleConnTimeout:    30 * time.Second,
		DisableCompression: true,
		TLSClientConfig: &tls.Config{
			RootCAs: caCertPool,
		},
	}
	client = &http.Client{Transport: tr}

Nell’esempio sto leggendo il certificato e lo sto configurando all’interno del transport per poi fornirlo al client.

Abbiamo quindi visto come invocare i vari metodi e come gestire una rete con proxy e una connessione crittografata con invio del certificato.

Alla prossima

Incominciamo instanziando il server e implementando un servizio di keepalive che serve a stabilire se il server è attivo regolarmente.

http.HandleFunc("/isAlive", isAlive)
	log.Fatal(http.ListenAndServe(":10000", nil))

La funzione HandleFunc definisce il path e il relativo handler. Per handler si intende la funzione che verrà eseguita dal server in corrispondenza della richiesta riceveuta.

func isAlive(response http.ResponseWriter, request *http.Request) {
	fmt.Fprintf(response, "alive")
}

Se abbiamo fatto tutto bene invocando il servizio http://localhost:10000/isAlive riceveremo un 200 ok con testo alive.

A questo punto supponiamo di voler gestire una rubrica dei contatti e pertanto definiamo prima di tutto la nostra struct Contatto

type contatto struct {
	Nome    string `json:"Nome"`
	Cognome string `json:"Cognome"`
}

La struct presenta 2 parametri Nome e Cognome e relative regole di trascodifica in json. Definiamo l’elenco dei contatti e lo inizializziamo con dei dati di prova, simulando la presenza di un database

var contatti []contatto
func main() {

	contatti = []contatto{
		contatto{Nome: "nome 1", Cognome: "Cognome 1"},
		contatto{Nome: "nome 2", Cognome: "Cognome 2"},
	}

Infine definiamo l’handler relativo

func elencoContatti(response http.ResponseWriter, request *http.Request) {
	json.NewEncoder(response).Encode(contatti)
}

func main() {
        http.HandleFunc("/contatti", elencoContatti)
}

In tal modo invocando l’url http://localhost:10000/contatti otterremo il seguente json [{“Nome”:”nome 1″,”Cognome”:”Cognome 1″},{“Nome”:”nome 2″,”Cognome”:”Cognome 2″}]

Di seguito il codice completo

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
)

type contatto struct {
	Nome    string `json:"Nome"`
	Cognome string `json:"Cognome"`
}

func isAlive(response http.ResponseWriter, request *http.Request) {
	fmt.Fprintf(response, "alive")
}

func elencoContatti(response http.ResponseWriter, request *http.Request) {
	json.NewEncoder(response).Encode(contatti)
}

var contatti []contatto

func main() {

	contatti = []contatto{
		contatto{Nome: "nome 1", Cognome: "Cognome 1"},
		contatto{Nome: "nome 2", Cognome: "Cognome 2"},
	}

	fmt.Println("Http server up ")
	http.HandleFunc("/isAlive", isAlive)
	http.HandleFunc("/contatti", elencoContatti)

	log.Fatal(http.ListenAndServe(":10000", nil))
}

Il package http ci ha consentito di tirare su il server e configurare delle risposte su dei path statici. Il package ha dei limiti, non ci permette di configurare degli endpoint variabili ed esplicitare il metodo http supportato. Per superare questo limite ci viene in soccorso un nuovo package “github.com/gorilla/mux”. Il package va installato con il comando

go get -u github.com/gorilla/mux

A questo per tirare su il server e configurare opportunamente gli endpoint possiamo scrivere

myRouter := mux.NewRouter().StrictSlash(true)
	myRouter.HandleFunc("/isAlive", isAlive).Methods("GET")
	myRouter.HandleFunc("/contatti", elencoContatti).Methods("GET")
	myRouter.HandleFunc("/contatti/{id}", singoloContatto).Methods("GET")
	myRouter.HandleFunc("/contatti", creaContatto).Methods("POST")
	myRouter.HandleFunc("/contatti/{id}", eliminaContatto).Methods("DELETE")
	log.Fatal(http.ListenAndServe(":10000", myRouter))

Il packge ci mette a disposizione l’oggetto router che consente per ogni handler di definire maggiori proprietà per meglio mappare il comportamento

func singoloContatto(response http.ResponseWriter, request *http.Request) {
	vars := mux.Vars(request)
	key := vars["id"]
	for index, contatto := range contatti {
		fmt.Println(index, " ", key)
		i, _ := strconv.Atoi(key)
		if index == i {
			json.NewEncoder(response).Encode(contatto)
			return
		}
	}
	response.WriteHeader(http.StatusNotFound)
}

Il package ci consente agevolmente di leggere le path variable e superare i limiti del package net/http.

Di seguito il codice completo per l’analisi dei metodi restanti

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"strconv"

	"github.com/gorilla/mux"
)

type contatto struct {
	Nome    string `json:"Nome"`
	Cognome string `json:"Cognome"`
}

func isAlive(response http.ResponseWriter, request *http.Request) {
	fmt.Fprintf(response, "alive")
}

func elencoContatti(response http.ResponseWriter, request *http.Request) {
	json.NewEncoder(response).Encode(contatti)
}

func creaContatto(response http.ResponseWriter, request *http.Request) {
	var contatto contatto
	json.NewDecoder(request.Body).Decode(&contatto)
	contatti = append(contatti, contatto)
	json.NewEncoder(response).Encode(contatti)
}

func singoloContatto(response http.ResponseWriter, request *http.Request) {
	vars := mux.Vars(request)
	key := vars["id"]
	for index, contatto := range contatti {
		fmt.Println(index, " ", key)
		i, _ := strconv.Atoi(key)
		if index == i {
			json.NewEncoder(response).Encode(contatto)
			return
		}
	}
	response.WriteHeader(http.StatusNotFound)
}

func eliminaContatto(response http.ResponseWriter, request *http.Request) {
	vars := mux.Vars(request)
	key := vars["id"]
	for index := range contatti {
		fmt.Println(index, " ", key)
		i, _ := strconv.Atoi(key)
		if index == i {
			contatti = append(contatti[:index], contatti[index+1:]...)
			response.WriteHeader(http.StatusOK)
			return
		}
	}
	response.WriteHeader(http.StatusNotFound)
}

var contatti []contatto

func main() {

	contatti = []contatto{
		contatto{Nome: "nome 1", Cognome: "Cognome 1"},
		contatto{Nome: "nome 2", Cognome: "Cognome 2"},
	}

	fmt.Println("Http server up ")
	//http.HandleFunc("/isAlive", isAlive)
	//http.HandleFunc("/contatti", elencoContatti)

	myRouter := mux.NewRouter().StrictSlash(true)
	myRouter.HandleFunc("/isAlive", isAlive).Methods("GET")
	myRouter.HandleFunc("/contatti", elencoContatti).Methods("GET")
	myRouter.HandleFunc("/contatti/{id}", singoloContatto).Methods("GET")
	myRouter.HandleFunc("/contatti", creaContatto).Methods("POST")
	myRouter.HandleFunc("/contatti/{id}", eliminaContatto).Methods("DELETE")
	log.Fatal(http.ListenAndServe(":10000", myRouter))
}

Alla prossima

Prima di tutto introduciamo il package per la gestione del db database/sql e insieme al package dobbiamo importare il driver specifico per il database cui connettersi. L’elenco dei driver disponibili e le relative basi di dati supportati sono disponibili al link https://github.com/golang/go/wiki/SQLDrivers. Per lavoro uso Oracle, pertanto nell’esempio integro il driver godror. Per poter usare questo driver occorre installarlo e configurarlo nell’ambiente go tramite la direttiva:

go get github.com/godror/godror

Il driver è realizzato in cgo pertanto è richiesta la presenza di un gcc compiler, nel mio caso ho utilizzato quello disponibile all’indirizzo https://jmeubank.github.io/tdm-gcc/. Maggiori informazioni su godror sono disponibili al l’url https://github.com/godror/godror

Dopo aver installato gcc e godror possiamo finalmente definire l’import

import (
	"database/sql"
	"fmt"
	_ "github.com/godror/godror"
)

Per la connessione al db il comando da usare è Open del package db

db, err := sql.Open("godror", "ldc/ldc@localhost:1521/xe")
	if err != nil {
		panic(err)
	}

Il primo parametro della Open è il nome del driver e a seguire la stringa di connessione verso il db nel formato username@password@ip:port:sid

La funzione restituisce una istanza db e come secondo parametro un oggetto error che potrà essere gestito tramite la funzione panic.

Vediamo subito come effettuare una operazione di scrittura tramite la funzione Exec

tx, _ := db.Begin()
	rowsDeleted, err := db.Exec("delete from audit_obj where id=1")
	if err != nil {
		panic(err)
	}
	fmt.Println("rowsDeleted: ", rowsDeleted)

	rowsInserted, err := db.Exec("insert into audit_obj (id, dataora, operazione) values(1, sysdate, 'insert')")
	if err != nil {
		panic(err)
	}
	fmt.Println("rowsInserted: ", rowsInserted)
	tx.Commit()

Nell’esempio tramite la funzione Begin ho avviato una transazione con commit previsto a fine operazioni di scrittura. Nel caso specifico sto facendo la cancellazione di un record dalla tabella di audit e successivo inserimento La funzione Exec ritorna un oggetto Result che rappresenta l’esito di una qualsiasi chiamata al db mostrando quante righe sono state coinvolte e l’id dell’ultimo inserimento.

Se volessi leggere i dati mi viene in aiuto la funzione Query che restituisce un cursore che scorre sulle righe selezionate

rows, err := db.Query("select id, dataora, operazione  from audit_obj")
	if err != nil {
		panic(err)
	}
	defer rows.Close()

	var id int
	var dataora time.Time
	var operazione string
	for rows.Next() {
		rows.Scan(&id, &dataora, &operazione)
		fmt.Println(id, dataora, operazione)
	}
	db.Close()

Nell’esempio sto leggenda dalla tabella audit tutti i record e tramite la funzione Scan dell’oggetto Rows la assegna a delle variabili per stamparne successivamente il valore. Con il comando defer chiudo il cursore alla fine di tutte le operazioni.

Per semplificare il lavoro con il db ci vengono in soccorso altri package che consentono di velocizzare il lavoro. Oggi introduco il package sqlx disponibile all’url https://jmoiron.github.io/sqlx/

Per installarlo il comando è

go get github.com/jmoiron/sqlx

ad installazione effettuata può essere importato con la direttiva github.com/jmoiron/sqlx”. Questo package consente di mappare le query direttamente su struct senza dover ricorrere al comando Scan.

type Audit struct {
	ID      uint64    `db:"ID"`
	DATAORA time.Time `db:"DATAORA"`
}

Ho definito una struct Audit che presenta i parametri ID e dataora, ne ho definito il tipo e tramite il thick ho definito il mapping, tramite la regola del contesto:nomecolonna.

A questo punto ottengo il gioco è fatto

dbx, err := sqlx.Open("godror", "ldc/ldc@localhost:1521/xe")
	if err != nil {
		panic(err)
	}

	var audit Audit
	err = dbx.Get(&audit, "select id, dataora from audit_obj where id = 1")
	if err != nil {
		panic(err)
	}
	fmt.Println(audit)

	audits := []Audit{}
	dbx.Select(&audits, "select id, dataora  from audit_obj")
	if err != nil {
		panic(err)
	}
	fmt.Println(audits)

Con la Open ottengo un riferimento al db che mi espone le funzioni Get per il recupero del singolo oggetto e Select per il recupero di un set di righe,

Alla prossima

ps. per i pigri a seguire l’intero codice

package main

import (
	"database/sql"
	"fmt"
	"time"

	_ "github.com/godror/godror"
	"github.com/jmoiron/sqlx"
)

type Audit struct {
	ID      uint64    `db:"ID"`
	DATAORA time.Time `db:"DATAORA"`
}

func main() {

	fmt.Println("Start")

	db, err := sql.Open("godror", "ldc/ldc@localhost:1521/xe")
	if err != nil {
		panic(err)
	}

	tx, _ := db.Begin()
	result, err := db.Exec("delete from audit_obj where id=1")
	if err != nil {
		panic(err)
	}
	fmt.Println("rowsDeleted: ", result)

	result, err = db.Exec("insert into audit_obj (id, dataora, operazione) values(1, sysdate, 'insert')")
	if err != nil {
		panic(err)
	}
	fmt.Println("rowsInserted: ", result)
	tx.Commit()

	rows, err := db.Query("select id, dataora, operazione  from audit_obj")
	if err != nil {
		panic(err)
	}
	defer rows.Close()

	var id int
	var dataora time.Time
	var operazione string
	for rows.Next() {
		rows.Scan(&id, &dataora, &operazione)
		fmt.Println(id, dataora, operazione)
	}
	db.Close()

	dbx, err := sqlx.Open("godror", "ldc/ldc@localhost:1521/xe")
	if err != nil {
		panic(err)
	}

	var audit Audit
	err = dbx.Get(&audit, "select id, dataora from audit_obj where id = 1")
	if err != nil {
		panic(err)
	}
	fmt.Println(audit)

	audits := []Audit{}
	dbx.Select(&audits, "select id, dataora  from audit_obj")
	if err != nil {
		panic(err)
	}
	fmt.Println(audits)

	dbx.Close()
	fmt.Println("End")

}

package main

import (
	"bufio"
	"fmt"
	"io/ioutil"
	"os"
)

func main() {

	nuovofile, errore := os.Create("miofile.txt")
	if errore == nil {
		fmt.Println("File creato: ", nuovofile.Name())
	} else {
		fmt.Println("Errore: ", errore)
		panic(errore)
	}
	nuovofile.WriteString("ciao a tutti")

	myWriter := bufio.NewWriter(nuovofile)
	myWriter.WriteString("\nciao a tutti")
	myWriter.Flush()
	nuovofile.Close()
	fmt.Println("File popolato")

	nuovofile, errore = os.Open("miofile.txt")
	if errore == nil {
		myslice := make([]byte, 100)
		n1, _ := nuovofile.Read(myslice)
		fmt.Println("char letti", n1)
		nuovofile.Seek(10, 0)
		n1, _ = nuovofile.Read(myslice)
		fmt.Println("char letti", n1)
	} else {
		panic(errore)
	}

	nuovofile.Seek(0, 0)
	myReader := bufio.NewReader(nuovofile)
	lettura, _, errore := myReader.ReadLine()
	if errore == nil {
		fmt.Println(string(lettura))
	} else {
		fmt.Println(errore)
	}
	nuovofile.Close()

	txt, errore := ioutil.ReadFile(nuovofile.Name())
	if errore == nil {
		fmt.Println("File letto: ", nuovofile.Name(), "->", string(txt))
	}

	errore = os.Remove(nuovofile.Name())
	if errore == nil {
		fmt.Println("File rimosso: ", nuovofile.Name())
	} else {
		fmt.Println("Errore: ", errore)
	}

}

Come si può vedere ho introdotto nuovi package: os, io/ioutil e bufio. os è il package che offre i metodi per la creazione e cancellazione dei file, ioutil offre funzioni per la manipolazione del file e bufio offre metodi bufferizzati per la lettura e scrittura

Nell’esempio in sequenza creo il file, lo popolo, ne leggo il contenuto e poi lo rimuovo dal file system.

nuovofile, errore := os.Create(“miofile.txt”) crea un file di nome miofile.txt nella directory dove eseguo il file .go. Il metodo Create restituisce 2 variabili, la prima di tipo file e la seconda di tipo Error che sarà valorizzato con il messaggio di errore se l’operazione non è possibile. Successivamente per popolare il file uso il metodo writestring della classe File e aggiungo ulteriore testo utilizzando un Writer offerto dal package bufio. Il writer bufferizzato migliora le prestazioni in caso di molte operazioni di scrittura e le rende effettive con il metodo flush, Infine con il close rendo il file disponibile per altre manipolazioni.

nuovofile, errore = os.Open(“miofile.txt”) apre il file con il nome passato come parametro e lo cerca nella directory dove il file go viene lanciato. Restituisce un oggetto di tipo file e l’eventuale errore. La lettura del contenuto può essere fatta in vari modi. La funzione Read legge il contenuto e lo salva in uno slice, restituendo in uscita il numero di caratteri letti. La funzione Seek consente di spostare il punto di inizio di lettura del file. Anche per la lettura il bufio ci mette a disposizione il reader che consente di effettuare le letture sfruttando il buffer in memoria. Il package ioutil mette a disposizione delle funzioni che agevolano l’operazione di lettura, es. txt, errore := ioutil.ReadFile(nuovofile.Name()), restituisce il contenuto del file in una variabile di tipo []byte.

Infine per cancellare il file il package io mette a disposizione la funzione Remove che riceve in ingresso il nome del file.

package main

import (
	"fmt"
	"time"
)

func main() {

	timer := time.NewTimer(time.Second * 2)

	go func() {
		<-timer.C
		fmt.Println("Passati 2 secondi")
	}()

	time.Sleep(time.Second * 5)
}

Nell’esempio ho definito un timer che scatta dopo 2 secondi e una goroutine che allo scadere del timer darà evidenza a video del tempo trascorso. La goroutine aspetta il valore inviato sul channel, attributo dell’oggetto timer. Questo meccanismo ci permette di impostare agevolmente dei timeout nel nostro codice. Tramite la funzione Stop del timer possiamo evitare la sua attivazione.

go func() {
		timer.Stop()
	}()

Qualora si voglia effettuare delle operazioni ad intervalli regolari Go mette a disposizione l’oggetto Ticker

ticker := time.NewTicker(time.Second * 1)
	go func() {
		for t := range ticker.C {
			fmt.Println("Ticker", t.Second())
			if t.Second() == 10 {
				ticker.Stop()
			}
		}
	}()

Nell’esempio ho creato un oggetto che inserisce un messaggio nel channel a intervalli regolari di un secondo. Anche il ticker presente una funzione Stop che consente di interrompere l’esecuzione del ticker.

func workerCloser(channel chan string) {
	channel <- "workerCloser"
	close(channel)
}
main() {
	canale4 := make(chan string)
	go workerCloser(canale4)
	msg3, ok := <-canale4
	fmt.Println(msg3)
	msg3, ok = <-canale4
	if !ok {
		fmt.Println("Canale chiuso")
	}
}

Nell’esempio ho realizzato una funzione che scrive un messaggio e successivamente chiude il canale. Per capire se il canale è stato chiuso o meno leggo il secondo parametro ok di tipo boolean che vale false qualora il canale sia stato chiuso esplicitamente.

Insieme al close go mette a disposizione range, che avevamo visto usato per scorrere gli slices e che applicato ai channel permette di leggere tutti i valori nel channel fino alla chiusura.

func contatore(channel chan int, max int) {
	for i := 0; i < max; i++ {
		channel <- i
	}
	close(channel)
}
main() {
	canale5 := make(chan int, 10)
	go contatore(canale5, 5)
	for valore := range canale5 {
		fmt.Println(valore)
	}
}

Nell’esempio ho creato una funzione contatore che riceve un parametro in ingresso e tramite ciclo for invia i parametri sul channel. Terminato il ciclo chiude il channel con il comando close. Nel main tramite il range leggo i valori dal channel e il ciclo si interrompe da solo. Notate che in questo caso il valore restituito dal range non l’indice ma il valore stesso.

Go permette di gestire la lettura di più channel concorrenti utilizzando la stessa goroutine. Per fare ciò si avvale del comando select che consente la lettura dei valori da channel differenti. Come sintassi ricorda molto lo switch case.

go func() {
		canale6 <- "1"
		canale6 <- "2"
	}()

	go func() {
		canale7 <- "3"
		time.Sleep(time.Second * 3)
		canale7 <- "4"
	}()

	for i := 0; i < 4; i++ {
		select {
		case mess1 := <-canale6:
			fmt.Println(mess1)
		case mess2 := <-canale7:
			fmt.Println(mess2)
		default:
			fmt.Println("Niente")
		}
	}

Nell’esempio ho creato 2 funzioni anonime che scrivono i messaggi su 2 channel separati, tramite il comando select inserito all’interno nel ciclo for recupero tutti i valori inviati. Nel caso di messaggi concorrenti la select sceglie casualmente quale processare per primo. Con lo statement default possiamo implementare della logica da eseguire qualora non sia presente alcun dato nei channel gestiti dal select. Senza default la select rimarrà in attesa di messaggi dal channel ad ogni iterazione.

Il costrutto select consente anche di implementare in modo agevole un meccanismo di timeout tramite la funzione After del package time.

for i := 0; i < 2; i++ {
		select {
		case mess1 := <-canale6:
			fmt.Println(mess1)
		case <-time.After(time.Second * 2):
			fmt.Println("timeout")
		}
	}

La funzione After simula la ricezione di un messaggio nel channel, in tal modo implementiamo una attesa di 2 secondi sul channel canale, trascorso il quale viene gestita la condizione di timeout.

Infine qualora si voglia gestire l’accesso concorrente a risorse di più goroutines Go mette a disposizioni le funzioni Lock e Unlock del package sync. I 2 comandi ci assicurano che solo un thread per volta potrà eseguire il codice compreso tra i 2 statement

func (cont *contatoreStruct) somma(val int) {
	var mutex sync.Mutex
	mutex.Lock()
	cont.counter = cont.counter + val
	mutex.Unlock()
}

package main

import (
	"fmt"
	"time"
)

func hello() {
	fmt.Println("ciao mondo")
}

func main() {

	hello()

	go hello()

	go func() {
		hello()
	}()

	time.Sleep(time.Second * 3)
}

Nell’esempio ho definito la func hello che si limita a stampare a video il classico messaggio “ciao mondo” e per invocarne l’esecuzione chiamo la function anteponendo la parola chiave go, con cui avvio un thread dedicato per l’esecuzione. Notate che ho importato il package time con cui ho impostato un attesa di 5 secondi per vedere il messaggio stampato altrimenti il programma avrebbe finito la sua esecuzione e non avremmo visto niente a schermo. Con semplicità ho gestito in maniera asincrona una funzione che non lo era. La parola chiave go può essere applicata anche a funzioni anonime ottenendo lo stesso effetto.

Le goroutines comunicano tra di loro tramite i channel,canali di comunicazioni monodirezionali detti in informatica pipe. Per creare una pipe si usa la parola chiave make seguito dalla parola chiave chan e il tipo di dato gestito. L’invio o la ricezione del dato avviene tramite la parola chiave -> e <-

messaggi := make(chan string)
	go func() {
		time.Sleep(time.Second * 3)
		messaggi <- "ciao"
	}()
	msg := <-messaggi
	fmt.Println(msg)

Nell’esempio ho creato un chanel che accetta stringhe e nella goroutine anonima ho inviato la stringa “ciao” tramite il comando channel <- con un ritardo di 3 secondi. Con il comando <- channel effettuo la lettura del dato e in questo caso non è stato necessario gestire ritardi e sincronizzazione perchè l’esecuzione del codice si interrompe in attesa della lettura del flusso dal channel.

Go mette a disposizione i channel con buffer, ovvero channel che possono ricevere più di un valore in attesa che poi venga letti. La sintassi prevede la dimensione del buffer successivamente al tipo gestito.

messaggiBufferend := make(chan string, 2)
	messaggiBufferend <- "Ciao"
	messaggiBufferend <- "Mondo"

Nell’esempio ho creato un channel con dimensione del buffer pari a 2 e su questo ho inviato 2 messaggi separati.

Grazie ai channel è possibile sincronizzare i processi visto che i channel bloccano l’esecuzione dei comandi stando in attesa di un valore.

func worker(channel chan string) {
	time.Sleep(time.Second * 3)
	channel <- "fine"
}
main () {
	canale := make(chan string)
	go worker(canale)
	msg2 := <-canale
	fmt.Println(msg2)
}

Nell’esempio ho creato una funzione worker che attende 3 secondi prima di comunicare la fine sul channel ricevuto come parametro. Nel main avvia la goroutine con il worker e resto in attesa dell’esito della elaborazione per chiudere l’esecuzione.

E’ possibile stabilire in sede di passaggio di una channel ad una funzione la direzione del channel, ovvero specificare se è abilitata l’invio o la ricezione

func chiamante(channel chan<- string) {
	channel <- "sono il ricevente"
}

func ricevente(channel <-chan string) {
	fmt.Println(<-channel)
}
main () {
	can := make(chan string)
	go chiamante(can)
	go ricevente(can)
}

Nell’esempio ho definito una funzione chiamante che accetta un channel su cui inviare solo dati, una finzione ricevente che accetta un channel che riceve solo dati e nel main ho lanciato le go routine associate.

Nel prossimo articolo vedremo altre funzioni collegate ai channel

package main

import (
	"errors"
	"fmt"
)

func noerrore(valore string) string {
	return valore
}

func possibileerrore(valore string) error {
	var error error
	if valore == "prova" {
		error = errors.New("Valore non ammesso")
	}
	return error
}

func valoreconpossibileerrore(valore string) (string, error) {
	var error error
	if valore == "prova" {
		error = errors.New("Valore non ammesso")
	}
	return valore, error
}

func main() {
	fmt.Println(noerrore("prova"))
	fmt.Println(possibileerrore("prova"))
	fmt.Println(valoreconpossibileerrore("prova"))
}

Nell’esempio ho creato 3 funzioni con 3 comportamenti distinti: la prima non può generare un errore, la seconda può generare un errore, la terza restituisce una stringa e può generare un errore. Per convenzione l’errore è l’ultimo tipo di valore restituito e in assenza di errore esso vale nil. Per generare l’errore ci viene in soccorso il package errors che mette a disposizione la funzione New che genera un errore contenente un testo.

Go ci permette di definire nuovi tipi di errori basati sul comando structs, la cosa fondamentale è che essi implementino l’interafaccia error che presenta il metodo Error da implementare

type myError struct {
	codice      int
	descrizione string
}

func (e *myError) Error() string {
	return fmt.Sprintf("%d - %s", e.codice, e.descrizione)
}

func possibileMyerrore(valore string) error {
	var error error
	if valore == "prova" {
		error = &myError{1, "KO"}
	}
	return error
}

In questo caso ho definito un error custom che presenta i campi codice e descrizione. Ho implementato la funzione Error() che sostanzialmente fa il toString dell’errore e implementato un metodo di esempio che lo utilizza

A questo punto il metodo restituisce una interfaccia error e pertanto non sono accessibili i campi della struct definita. Per ovviare a questa limite occorre sfruttare il meccanismo della type assertion che permette di forzare il tipo che si desidera (il meccanismo ricordo il casting di java) e il gioco è fatto.

var errore = possibileMyerrore("prova")
	var er = errore.(*myError)
	fmt.Println(er.codice)