Comments

Red Hat non ha più reso disponibili i binary di JBoss dalla versione 7.1 in poi. Per poterlo utilizzare in produzione adesso bisogna usare o la 7.1 appunto oppure la EAP alpha 1. Per la EAP final occurre pagare la licenza per il supporto.

Le due versioni libere sono un po’ vecchiotte, e essendo JBoss open source Red Hat permette l’utilizzo dei sorgenti, allora costruiamoci un 7.2 da mettere in produzione.

Per prima cosa cloniamo il progetto JBoss, ormai rinominato in WildFly al tag 7.2:

1
2
3
git clone https://github.com/wildfly/wildfly.git
cd wildfly
git checkout 7.2.0.Final

Ora semplicemente compiliamolo, tralasciando i test perché diversi non passano (/ no comment /)

1
mvn install -Dmaven.test.skip=true

Ora avrete come risultato un JBoss 7.2 perfettamente funzionante che potrete usare liberamente in produzione.

Bonus

Potete aggiungere il fantastico Torquebox al JBoss appena compilato semplicemente scompattando lo zip per l’overlay nella cartella principale di jboss:

http://torquebox.org/release/org/torquebox/torquebox-dist/3.0.1/torquebox-dist-3.0.1-eap-overlay.zip
unzip torquebox-dist-3.0.1-eap-overlay.zip

e per finire lanciate JBoss in questo modo per attivare torquebox

$JBOSS_HOME/bin/standalone.sh --server-config=standalone-full.xml

Happy Coding!

Comments

Adoro sperimentare nuove tecnologie, era da tempo che volevo fare qualche esperimento con AngularJS.

La particolarità di questo framework javascript sta nelle directive, è possibile creare dei tag custom in modo da estendere il classico HTML.

Per intenderci, ho creato una directive che mostra una mappa con le ESRI ArcGIS API for Javascript.

1
2
3
4
<map>
  <dynamic-layer url="http://gis.lugano.ch/arcgis/rest/services/.../MapServer"></dynamic-layer>
  <feature-layer url="http://gis.lugano.ch/arcgis/rest/services/.../FeatureServer/0"></feature-layer>
</map>

L’implementazione è davvero semplice, la prima directive crea l’oggetto mappa, mentre la seconda, tiledLayer, richiede la prima grazie al require ed accede all’oggetto mappa tramite il proprio controller:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
var map = angular.module('map', []) // modulo mappa senza dipendenze

map.directive('map', function() {
  return {
    restrict: 'E', // E sta per element
    controller: function($scope) {
      this.map = {};
    },
    link: function(scope, element, attrs, controller) {
      var defaults = {
        center: typeof attrs.center !== 'undefined' ? JSON.parse(attrs.center) : null,
        zoom: attrs.zoom || null
      }
      controller.map = new esri.Map(element[0], defaults);
    }
  }
});

map.directive('tiledLayer', function() {
  return {
    restrict: 'E',
    require: '^map',
    scope: false,
    link: function(scope, element, attrs, mapCtrl) {
      scope.$watch(mapCtrl.map, function() {
        mapCtrl.map.addLayer(new esri.layers.ArcGISTiledMapServiceLayer(attrs.url));
      })
    }
  }
});

Piccola pecca, visto che il framework di ESRI è costruito su Dojo, dobbiamo aspettare che sia caricato tutto prima di inizializzare la nostra app in Angular, per fortuna non dobbiamo scrivere molto codice per farlo:

1
2
3
4
dojo.require("esri.map");
dojo.addOnLoad(function() {
  angular.bootstrap(document, ['map']);
});

Per vedere il codice completo ho creato un repository su GitHub.

Happy Coding!

Comments

Per non esporre direttamente il DNS del nostro ArcGIS Server di produzione ho escogitato alcuni trucchi. Tutte le nostre applicazioni Web sono proxate da un Apache in modo da introdurre un layer di separazione in più. I benefici sono molteplici, ad esempio si può configurare mod_security in modo da filtrare richieste non valide, oppure utilizzare mod_pagespeed, …

Utilizzando questa configurazione mi permette di non esporre direttamente l’indirizzo dell’ArcGIS Server e di poter cambiare dietro le quinte il server in caso di update, da 10.0 a 10.1 ad esempio.

Quindi, la mia applicazione è raggiungibile a gis.lugano.ch. Da qui tutte le applicazioni deployate nell’application server sono disponibili.

Così avremmo:

  • gis.lugano.ch, pagina di welcome
  • gis.lugano.ch/GisWeb, applicazione principale
  • gis.lugano.ch/arcgis/rest, pagina di listing di ArcGIS Server
  • gis.lugano.ch/arcgismanager, bloccato dall’esterno

Inoltre anche ArcMap non si accorge della cosa, ed è possibile aggiungere un MapServer ad un progetto mxd. Anche qui i vantaggi sono quelli di non avere mai direttamente il nome della macchina e di poterla aggiornare in futuro senza dover modificare i vari progetti.

Ecco la configurazione di Apache che uso, nulla di più semplice:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<VirtualHost *:80>
  ServerAdmin luca.simone@lugano.ch
  ServerName gis.lugano.ch
  ServerAlias www.gis.lugano.ch

  ProxyPass /arcgis/manager !
  ProxyPass /arcgis http://srvgispr001.lugano.ch:8399/arcgis
  ProxyPassReverse /arcgis http://srvgispr001.lugano.ch:8399/arcgis

  # Root Proxy
  ProxyPass / ajp://localhost:8009/ keepalive=On
  ErrorLog logs/gis.lugano.ch-error_log
  CustomLog logs/gis.lugano.ch-access_log combined

</VirtualHost>

Happy Coding!

Comments

Utilizzare librerie Java in JRuby, oltre che essere molto semplice, può essere veramente comodo. Basti pensare ad iText, una delle librerie per creare PDF più complete che esistano. Ma a volte è necessario il contrario, wrappare delle librerie Ruby in Java può essere molto utile per la dinamicità che Java non può dare. Un esempio pratico è il mio wrapper della gemma Faker.

La possibilità di eseguire script da Java risale al lontano 2006, quando è stata rilasciata la Final Release di JSR-228.

Passando al codice, prendo un esempio direttamente dal mio wrapper e lo complifico un poco:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package ch.lugano.test.faker;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class Faker {

  static ScriptEngine jruby;
  static {
    jruby = new ScriptEngineManager().getEngineByName("jruby");
    try {
      jruby.eval("puts 'Hello World!'");
    }
    catch (ScriptException e) {
      System.out.println(e.getMessage());
    }
  }

}

Il codice parla da solo, unico passo da eseguire ancora è aggiungere jruby-complete.jar alle dipendenze. Può essere fatto in 2 modi, o come dipendenza maven oppure aggiungendo il jar al classpath.

1
2
3
4
5
6
<dependency>
  <groupId>org.jruby</groupId>
  <artifactId>jruby-complete</artifactId>
  <version>1.7.4</version>
  <scope>runtime</scope>
</dependency>

Happy coding!

Comments

La potenza di JRuby sta nell’integrazione fra i due linguaggi, uno molto espressivo, l’altro onnipresente.

Utilizzare una libreria Java con JRuby è una cosa semplicissima, per prima cosa basta mettere il jar da qualche parte, generamente la cartella lib di progetto è la più indicata.

Application.rb
1
2
3
4
5
6
7
require 'rails/all'

# require di tutti i jar nella cartella
Dir["lib/jars/*.jar"].each { |jar| require jar }

if defined?(Bundler)
...

Poi basta semplicemente importare le classi da utilizzare ed il gioco è fatto. JRuby mappa i metodi della classe da CamelCase a snake_case automaticamente, quindi il metodo .getDocumentList() puo’ essere tranquillamente usato anche come .document_list().

documents_controller.rb
1
2
3
4
5
6
7
8
9
10
11
12
13
class DocumentsController < ApplicationController

  import "ch.lugano.opentext.util.ContentWrapper"
  import "ch.lugano.opentext.util.Document"

  def index
  end

  def show
    @documents = ContentWrapper.documents_list(params[:id])
  end

end

Happy Coding!

Comments

Era il momento di rinnovare il sito, da troppo tempo non scrivevo più nulla su queste pagine. Finalmente mi sono ritagliato 5 minuti per aggiornare layout e migrare tutto a Octopress.

Nei post che verranno ho intenzione di condividere piccoli trucchi, metodologie, pattern…insomma, qualsiasi cosa che possa condividere.

Negli ultimi anni ho appreso diverse nuove tecnologie, contribuendo a progetti open source ho migliorato la mia conoscenza di Java, Ruby, Javascript, Python, Coffeescript, ActionScript e Objective-C.

La lista ormai è lunga, vediamo di cominciare!

Copyright © 2014 - Luca Simone -