Asw_Project

Le guide più significative consultate per utilizzare Wildfly con Vagrant ed effettuare il Deploy di un .war

https://gist.github.com/sukharevd/6087988
https://kb.novaordis.com/index.php/Start_WildFly_as_a_systemd_Service_on_Linux
http://support.elegantjbi.com/support/solutions/articles/9000108381-configuring-wildfly-as-a-service-in-linux
https://stackoverflow.com/questions/42907443/wildfly-as-systemd-service
https://github.com/Phidelux/vagrant-javaee-wildfly/blob/master/Vagrantfile
https://github.com/Phidelux/vagrant-javaee-wildfly
http://planet.jboss.org/post/vagrant_with_docker_provider_using_wildfly_and_java_ee_7_image
https://github.com/Phidelux/vagrant-javaee-wildfly/blob/master/vagrant/conclusion.sh

Le guide più significative consultate per effettuare il porting di un'app EJB:

https://developer.jboss.org/people/fjuma/blog/2017/09/08/getting-started-with-ejbs-and-elytron-part-2
http://www.soluzionijava.it/index.php?option=com_content&view=article&id=109:lookup-remoto-di-un-ejb-30-session&catid=36:ejb&Itemid=66
https://developer.jboss.org/thread/276015
https://docs.jboss.org/author/display/AS71/EJB+invocations+from+a+remote+server+instance
https://docs.oracle.com/javase/jndi/tutorial/beyond/env/source.html
http://www.mastertheboss.com/jboss-server/jboss-as-7/jboss-as-7-remote-ejb-client-tutorial
https://github.com/wildfly/quickstart/tree/master/ejb-remote

Commenti riguardanti la prima fase del progetto (.WAR)

Durante la prima fase nella realizzazione del progetto il nostro obiettivo è stato quello di installare in maniera corretta Wildfly e farlo partire su una VM di prova. Il primo grande problema a cui si è andati incontro, è stato il fatto che eseguendo lo script di wildfly standalone.sh la nostra bash rimaneva occupata dall'esecuzione di wildfly e non era possibile più utilizzarla. Per rendere più comodo e immediato l'avvio dell'application server da parte dell'utente abbiamo consultato numerose guide (linkate in testa alla pagina), per far partire lo script di wildfly come un servizio, si è però notato che molte di esse modificavano file come standalone.xml o altri file di configurazione al fine di aggiungere variabili d'ambiente per funzionalità arricchite, che per il fine del progetto non erano necessarie. Abbiamo ovviato alla creazione di tale servizio realizzando uno script start-wildfly.shche fa partire wildfly in background attraverso una semplice linea di comando. Fatto questo si è passati al deploy di una applicazione web Hello_World classica, non ancora buildata. Per il build abbiamo utilizzato Maven, poichè ha un canale preferenziale con wildfly. Attraverso Maven è possibile il deploy di un progetto buildato, direttamente usando la stringa di comando : mvn wildfly:deploy Per fornire una panoramica completa di come è possibile deployare un progetto in Wildfly, abbiamo scelto di non utilizzare questo comando, di cui ci avvarremo nel deploy dell'EJB, e deployare il progetto in maniera " Standard " cioè attraverso lo script fornito da wildfly chiamato jboss-cli.sh che si trova nella directory /bin di Wildfly. Abbiamo, per l'appunto, buildato il progetto attraverso maven, preso il .war generato nella cartella di target e spostato nella cartella di Wildfly. Fatto questo attraverso il nostro script deploy-project.sh avviamo lo script jboss-cli.sh e deployamo il progetto. Arriviamo all'ultima parte di questa prima fase, l'obiettivo ultimo era quello di eseguire correttamente il port forwarding, aver specificato la porta per il port forwarding sembrava non bastare. Per quanto riguarda i membri del gruppo che utilizzavano un Pc MacBook il port forwarding riusciva senza particolari intoppi, mentre chi utilizzava un sistema operativo Windows riscontrava numerosi problemi per visualizzare nel browser dell'host il corretto funzionamento degli script di start e deploy di Wildfly. Dopo numerose ricerche e settaggi vari (inutili) abbiamo scoperto che la causa del mancato port forwarding era l'antivirus di Windows Windows Defender. Una volta disattivato il port forwarding ha cominciato a funzionare anche per chi usava Windows. Fatto questo ci siamo occupati di fare questa stessa cosa con Docker e tentare di deployare ed eseguire un progetto EJB

Commenti riguardanti la seconda fase del progetto (Docker)

Docker non ci ha causato troppi problemi, avendo risolto il problema del port forwarding è bastata qualche guida ( linkata in alto ) e una consultazione della documentazione ufficiale di docker (https://hub.docker.com/r/jboss/wildfly/ ) per far partire tutto.

Commenti riguardanti la terza fase del progetto (Porting EJB)

Durante questa fase abbiamo passato un pò di tempo a cercare dei progetti EJB già svolti, di esempio, che potessimo usare come riferimento per il nostro progetto. Tra i tanti trovati, inizialmente nessuno di essi funzionava a dovere (alcuni non finivano con successo la build mentre altri fallivano la ricerca con JNDI). Ci siamo dunque concentrati sul capire quale fosse il problema, e dopo vari tentativi, tra cui cambiamenti di ip e modifiche al file /etc/host, abbiamo identificato il problema in un errore di configurazione del Vagrantfile; più precisamente assegnavamo un unico ip globale privato sia al server che al client (errore di sintassi dopo che abbiamo diviso la singola macchina developer in due macchine client e server). Risolto questo problema, sembrava che il client riuscisse ad arrivare al server, ma non aveva i permessi per accederci. Dunque, dopo aver consultato varie guide, abbiamo aggiunto un nuovo utente al server wildfly ed abbiamo aggiunto al file "wildfly-config.xml" le credenziali di accesso al server (wildfly elytron). Finalmente alcuni progetti (tra quelli trovati precedentemente) funzionavano. Ci siamo dunque concentrati a smembrare i progetti che funzionavano, per ridurli al minimo indispensabile e siamo giunti al progetto v1, perfettamente funzionante. Abbiamo proseguito cercando di semplificare ulteriormente la sintassi del codice: abbiamo aggiunto un file jndi.properties il quale si occupa dell'inizializzazione del contesto dell'applicazione ed abbiamo tolto dal client tutta l'implementazione delle interfacce lasciandoci solo le dichiarazioni dei metodi (progetto v3). Anche qui abbiamo utilizzato Maven in quanto integrato perfettamente con Wildfly. Tramite esso abbiamo integrato i plugin di Wildfly per Deploy ed Esecuzione veloci e la dipendenza tra il client e l'interfaccia del server. Come ultimo step volevamo effettuare il lookup del client al server tramite Injection, come fatto da lei nei progetti di esempio EJB. Purtroppo però i vari tentativi non sono andati bene, e quest'ultimo step non lo abbiamo completato.
Abbiamo provato varie possibilità tra cui le guide: https://stackoverflow.com/questions/43282192/how-to-specify-the-ejb-bean-name-in-the-jndi-tree-in-jee7
https://www.tutorialspoint.com/ejb/ejb_annotations.htm
Senza però alcun successo. Il risultato è sempre NullPointer sulle classi dove dovrebbe esserci l'Injection della dipendenza. Abbiamo quindi deciso di lasciare i metodi ad-hoc di lookup, i quali funzionano bene.

Configurazione Client/Server

Inizializzare il Client ed il Server:

1. Posizionarsi nella cartella Developer ed eseguire:

 vagrant up 

Nella macchina virtuale 'Server' viene automaticamente lanciata un'istanza di Wildfly.

2. Finita la configurazione delle macchine virtuali è possibile accedere ad esse:

 vagrant ssh server/client 

Test Deploy di un'applicazione .war

1. Accedere al nodo 'Server':

 vagrant ssh server 

2. Andare nella cartella contenente il progetto:

 cd /home/asw/_shared/deploy 

All'interno vi si trova un progetto di esempio denominato 'SpringBootBasic'

3. Posizionarsi nella cartella del progetto:

 cd SpringBootBasic 

4. Generare il .war SpringBootBasic.war:

 mvn clean package 

5. Spostare il file SpringBootBasic.war nella cartella 'standalone' di Wildfly:

 sudo cp target/SpringBootBasic.war /usr/local/wildfly-13.0.0.Final/standalone/ 

6. Andare nella cartella contenente gli script:

 cd /home/asw/_shared/scripts 

7. Eseguire lo script 'deploy-project.sh':

 sudo sh deploy-project.sh 

Questo script esegue il deploy di tutti i progetti nella cartella 'standalone' di Wildfly.

Finita l'esecuzione dello script si può testare la riuscita accedendo da host all'indirizzo: http://0.0.0.0:8088/SpringBootBasic/hello/Professore

Test Docker

1. Posizionarsi nella cartella Docker ed eseguire:

vagrant up 

2. Finita la configurazione della macchina virtuale è possibile accedere ad essa:

vagrant ssh docker

3. Posizionarsi nella cartella Dockerproject:

cd dockerproject

4. Eseguire il comando:

docker build --tag=wildfly .

5. In seguito, eseguire:

docker run -p 8080:8080 -it wildfly

Fatto questo possiamo vedere all'url : http://localhost:8081/ che Wildfly è correttamente funzionante e possiamo vedere anche che il progetto .war deployato funziona correttamente accedendo al seguente url : http://localhost:8081/hello-world/hello

Test esecuzione App EJB

Configurazione SERVER

1. Posizionarsi nella cartella HOME / ASW / _SHARED / DEPLOY / ASWPROJECTV3 / SERVER:

 cd /home/asw/_shared/deploy/ASWProjectV3/server 

2. Eseguire il comando:

sudo mvn clean install

3. Finita l'installazione eseguire:

sudo mvn wildfly:deploy

Configurazione CLIENT

1. Posizionarsi nella cartella HOME / ASW / _SHARED / DEPLOY / ASWPROJECTV3 / CLIENT / SERVERINTERFACE :

 cd /home/asw/_shared/deploy/ASWProjectV3/client/serverinterface/ 

2. Eseguire il comando:

sudo mvn clean install

3. Finita l'installazione posizionarsi nella cartella HOME / ASW / _SHARED / DEPLOY / ASWPROJECTV3 / CLIENT / CLIENT:

 cd /home/asw/_shared/deploy/AswProjectV3/client/client/ 

4. Eseguire il comando:

sudo mvn clean install

5. Finita l'installazione eseguire:

sudo mvn exec:exec

Dovrebbero comparire sul terminale i messaggi inviati dal 'Client' le risposte del 'Server'.