Caused by: com.mongodb.MongoTimeoutException: Timed out after 30000 ms while waiting for a server that matches ReadPreferenceServerSelector { readPreference= ReadPreference {name=secondary, hedgeOptions=null}}. Client view of cluster state is {type=REPLICA_SET, servers=[{address=*, type=REPLICA_SET_PRIMARY, TagSet{[Tag{name='region', value=''}]}, roundTripTime=199.7 ms, state=CONNECTED}

Tutto quello che si trova in rete non ci permette di risolvere perchè non va, fino a quando non rivedo la configurazione adottata con Spring

@Override
protected void configureClientSettings(MongoClientSettings.Builder builder) {        
    builder
        .applyConnectionString(new ConnectionString(mongoUri))              
        .readPreference(ReadPreference.secondary());
}

E qui finalmente si svela l’arcano. Essendo un cosmosdb configurato per il dev per limitare i costi non abbiamo attivato la read replica, mentre da nella configurazione avevamo specificato di leggere il secondario che non era stato attivato. L’eccezione non proprio parlante non ci ha permesso di individuare subito, ma per risolvere agevolmente è stato sufficiente cambiare la configurazione in questo modo

@Override
protected void configureClientSettings(MongoClientSettings.Builder builder) {        
    builder
        .applyConnectionString(new ConnectionString(mongoUri))              
        .readPreference(ReadPreference.primary());
}

nvm:  '1.1.7'
npm:  '8.1.2'
node: '16.13.2

Nel momento in cui scrivo sono presenti queste versioni

|   CURRENT    |     LTS      |  OLD STABLE  | OLD UNSTABLE |
|--------------|--------------|--------------|--------------|
|    18.2.0    |   16.15.0    |   0.12.18    |   0.11.16    |
|    18.1.0    |   16.14.2    |   0.12.17    |   0.11.15    |
|    18.0.0    |   16.14.1    |   0.12.16    |   0.11.14    |
|    17.9.0    |   16.14.0    |   0.12.15    |   0.11.13    |
|    17.8.0    |   16.13.2    |   0.12.14    |   0.11.12    |

Ma solo la 16.3.2 non presente il problema in oggetto e riporto per comodità un estratto del file di log e della console

--console
npm version
npm ERR! Unexpected token '.'

--file di log
28 verbose stack SyntaxError: Unexpected token '.'
28 verbose stack     at Object.compileFunction (node:vm:352:18)
28 verbose stack     at wrapSafe (node:internal/modules/cjs/loader:1033:15)

Secondo gli amici di Github occorre avanzare nvm ad una versione successiva (1.1.9) e rimuovere e reinstallare la 16.15.0 di node

Per risolvere ho letto la risposta come byte[] e poi ho usato la classe org.apache.commons.fileupload.MultipartStream presente nel in Commons FileUpload per leggere il contenuto da un byte[], scartare gli header e leggere solo il file di mio interesse

RestTemplate restTemplate = new RestTemplate();
byte[] bytes = restTemplate.getForObject(fileUlr, byte[].class);
String txt = new String(bytes);
String boundary = StringUtils.substringBefore(txt, "\r\n").substring(2);
MultipartStream multipartStream = new MultipartStream(new ByteArrayInputStream(bytes), 
		boundary.getBytes(), 1024, null);
boolean nextPart = multipartStream.skipPreamble();
while (nextPart) {
     	multipartStream.readHeaders();
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        multipartStream.readBodyData(bos);
        return bos.toByteArray();
}
return bytes;

Lo stack tecnologico si evolve con il tempo e capita che soluzioni adottate precedentemente non siano più percorribili. E’ il caso di jasper report e spring boot. Spring boot, altro prodotto validissimo, ci permette di generare dei jar eseguibili che tramite l’uso dei tomcat embedded ci permette di tirare dei servizi web senza particolari problemi. Non hai più la necessità di gestire una istanza tomcat, e di generare il war che va installata su di essa, ma generi un jar che eseguito espone il servizio richiesto. Se all’interno del jar prevediamo la presenza dei template jasper per l’elaborazione del report occorre non più fornire il path ma fornire questo template sotto forma di inputstream. Su questo argomento avevo già scritto un articolo che trovate qui.

In questi giorni però mi è capitato di dover gestire un report che a suo volta conteneva un subreport passato sotto forma di path ed ecco che si è ripresentata di nuovo l’eccezione FILENOTFOUNDEXCEPTION, perchè giustamente anche il subreport va passato come inpustream per risolvere il problema.

Ricapitolando:

In JasperReport definisco un parametro di tipo inputstream

Lo utilizzo come espressione del subreport

E nella classe java dove invoco il metodo per la generazione del report lo passo come parametro

params.put("SUBREPORT_INPUTSTREAM", report.getInputStream());

Buon lavoro

Sostanzialmente il messaggio indicava che uno dei vari plugin configurati nella build del processo non era gestito correttamente nel ciclio di vita gestito da STS. Nel mio caso si trattava del plugin jasperreports-plugin responsabile della compilazione dei file .jrxml in file.jasper e la condizione di errore veniva indicata sul tag execution

Per gestire l’errore è stato sufficiente sfruttare un’altra feature del maven, ovvero il dependency management e definire tramite un altro plugin (lifecycle-mapping) il comportamento di Eclipse. Il dependency managament è un tag disponibile all’interno del tag build.

Una volta aggiornato il pom, STS ha rimosso l’errore, compilato i file e generato i file jasper attesi.

E’ possibile configurare lo stesso plugin anche per ignorare il plugin incriminato all’interno della gestione di STS, in questo caso invece di usare l’action execute si usa l’action ignore

Per maggiori informazioni vi invito a leggere la documentazione ufficiale disponibile qui, mentre per l’ottimo plugin di compilazione di report la pagina ufficiale è questa.

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

Inoltre la libreria consente di configurare agevolmente un client per poter invocare dei servizi esposti su un altro server e sulla configurazione base rimando sempre al tutorial di spring che trovate qui.

In questo articolo approfondiamo come configurare il client che gira all’interno di una rete con proxy e che richiede lo scambio dei certificati con il server su cui sono esposti i servizi soa.

Il nostro client si trova in una rete con 2 livelli di sicurezza: un proxy che regola il traffico verso l’esterno della nostra rete e un server che accetta chiamate crittografate con un certificato associato.

Per fare questo dobbiamo configurare il messagesender presente nella classe WebServiceTemplate con una istanza della classe org.springframework.ws.transport.http.HttpComponentsMessageSender che utilizza la classe Apache HttpClient per l’invio di Post.

HttpComponentsMessageSender httpComponentsMessageSender = httpComponentsMessageSender();
        httpComponentsMessageSender.setHttpClient(httpClient());
		client.setMessageSender(httpComponentsMessageSender);

Nella classe client sto settando il message sender tramite un metodo seguente in configuro i tempi di timeout e a questo passo il client httoClient dove effettivamente configuro il proxy e il certificato

@Bean
public HttpComponentsMessageSender httpComponentsMessageSender() {     
    HttpComponentsMessageSender sender = new HttpComponentsMessageSender();
    sender.setReadTimeout(3000);
    sender.setConnectionTimeout(3000);
    return sender;
}

@Bean
	public HttpClient httpClient() throws Exception {     
		
		KeyStore ks = KeyStore.getInstance("JKS");
        ks.load(keyStore.getInputStream(), keyStorePassword.toCharArray());
        try {
            keyStore.getInputStream().close();
        } catch (IOException e) {
        	e.printStackTrace();
        }
        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        keyManagerFactory.init(ks, keyStorePassword.toCharArray());

        KeyStore ts = KeyStore.getInstance("JKS");
        ts.load(trustStore.getInputStream(), trustStorePassword.toCharArray());
        try {
            trustStore.getInputStream().close();
        } catch(IOException e) {
        	e.printStackTrace();
        }
        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        trustManagerFactory.init(ts);
        
        SSLContext sslContext = SSLContexts.custom()
        		.loadKeyMaterial(ks, keyStorePassword.toCharArray())
        		.loadTrustMaterial(ts, null)
        		.build();
        SSLConnectionSocketFactory sslsf = new 
                SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
        HttpClientBuilder clientBuilder = HttpClients.custom().setSSLSocketFactory(sslsf).
        		addInterceptorFirst(new HttpComponentsMessageSender.RemoveSoapHeadersInterceptor());
       	HttpHost proxy = new HttpHost(proxyHost, proxyPort);
       	clientBuilder.setProxy(proxy);
         HttpClient httpClient = clientBuilder.build();
        
        return httpClient;

	}

Definisco il contesto SSL fornendo il keystore e il truststore. Definisco il proxy fornendo host e porta e infine creo il client usando la classe HttpClientBuilder.

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