Paco Hernández

http://static.springsource.org/downloads/nightly/snapshot-download.php?project=SPR

http://static.springsource.org/downloads/nightly/release-download.php?project=SPR

xmlns:s="library://ns.adobe.com/flex/spark"
xmlns:mx="library://ns.adobe.com/flex/mx" xmlns:local="*"
creationComplete="init()">

import mx.core.UIComponent;
import mx.events.ResizeEvent;

import org.alivepdf.display.Display;
import org.alivepdf.fonts.CoreFont;
import org.alivepdf.fonts.FontFamily;
import org.alivepdf.layout.Layout;
import org.alivepdf.layout.Orientation;
import org.alivepdf.layout.Size;
import org.alivepdf.layout.Unit;
import org.alivepdf.pages.Page;
import org.alivepdf.pdf.PDF;
import org.alivepdf.saving.Method;

private var pdfViewer: HTMLLoader;

private function init(): void {

// Creamos un PDF con AlivePDF desde el mismo Flex
var pdf: PDF = new PDF(Orientation.PORTRAIT, Unit.MM, Size.A4);
pdf.setDisplayMode(Display.FULL_PAGE, Layout.SINGLE_PAGE);

// Añadimos una página
var page: Page = new Page(Orientation.PORTRAIT, Unit.MM, Size.A4);
pdf.addPage(page);

// Añadimos el contenido de la página
pdf.setFont(new CoreFont(FontFamily.ARIAL), 25);
pdf.writeText(23, "Hello World!");
pdf.drawRect(new Rectangle(100, 100, 100, 100));

// Almacenamos el PDF generado en la carpeta de almacenamiento de la aplicación
var folder: File = File.applicationStorageDirectory;
var file: File = new File(folder.url + "test.pdf");
var fs: FileStream = new FileStream();
fs.open(file, FileMode.WRITE);
fs.writeBytes(pdf.save(Method.LOCAL));
fs.close();

// Si el ordenador tiene capacidad para ver el PDF
if (HTMLLoader.pdfCapability == HTMLPDFCapability.STATUS_OK) {

// Cargamos el PDF generado en el visor de HTML desde local
var request: URLRequest = new URLRequest(folder.url + "test.pdf");
pdfViewer = new HTMLLoader();
pdfViewer.load(request);

//pdfViewer.loadString("h“);

// Añadimos el visor de PDF a la aplicación
var container: UIComponent = new UIComponent();
container.addChild(pdfViewer);
container.addEventListener(ResizeEvent.RESIZE, resizeHandler);
container.percentHeight = 100;
container.percentWidth = 100;
addElement(container);
}
}

private function resizeHandler(event: ResizeEvent): void {

// Ajustamos el tamaño del visor al tamaño disponible de la aplicación
pdfViewer.width = DisplayObject(event.target).width
pdfViewer.height = DisplayObject(event.target).height;
}
]]>

Supongamos tres ordenadores:

(Ojo con las mayúsculas y minúsculas, son importantes).

1. El controlador de dominio del dominio “LAB.COM” con Active Directory (DC-LAB.LAB.COM). Esta máquina tiene Windows 2003 Server.

2. El servidor donde reside nuestra aplicación (RS-LAB.LAB.COM). Este servidor también está en el dominio “LAB.COM”.

3. Una máquina que también está en el dominio “LAB.COM” desde donde se conectará un usuario con Internet Explorer a nuestra aplicación utilizando autenticación basada en Kerberos v5.

Pasos:

1. Configurar “C:\WINDOWS\krb5.ini” en la máquina donde reside nuestra aplicación:

[domain_realm]
.lab.com = LAB.COM
lab.com = LAB.COM

[libdefaults]
default_realm = LAB.COM

[realms]
LAB.COM = {
kdc = DC-LAB.LAB.COM
admin_server = DC-LAB.LAB.COM
default_domain = LAB.COM
}

2. Generamos un usuario en el controlador de dominio para nuestra aplicación. Se trata de un usuario normal. Se pone cualquier contraseña (no importa) y se marca para que no expire. Por ejemplo, creamos el usuario “http-rs-lab.lab.com”.

3. A continuación en el controlador de dominio, utilizando el comando ktpass, creamos el archivo cifrado con la clave privada que permitirá identificar a nuestra aplicación ante el servidor de Kerberos:

> ktpass -princ HTTP/rs-lab.lab.com@LAB.COM -mapuser http-rs-lab.lab.com@lab.com -pass * -out http-rs-lab.keytab

Targeting domain controller: DC-LAB.LAB.COM
Using legacy password setting method
Successfully mapped HTTP/rs-lab.lab.com to http-rs-lab.lab.com.
Type the password for HTTP/rs-lab.lab.com:
Type the password again to confirm:
WARNING: pType and account type do not match. This might cause problems.
Key created.
Output keytab to http-rs-lab.keytab:
Keytab version: 0×502
keysize 62 HTTP/rs-lab.lab.com@LAB.COM ptype 0 (KRB5_NT_UNKNOWN) vno 4 etype 0×1
7 (RC4-HMAC) keylength 16 (0x399f9bb3158d6b454313f297192705dd)

Aunque da un warning, no importa, funciona perfectamente.

Pienso que la clave está en hacer coincidir la parte de la url que hay después de “HTTP/” con la url de la aplicación (con minúsculas), ya que en mayúsculas no funciona.

4. A continuación copiamos el archivo “http-rs-lab.keytab” a la carpeta WEB-INF/classes de nuestra aplicación. Por lo visto es mejor tenerla fuera del classpath cuando esté en producción. Se puede referenciar también con el protocolo “file:” posteriormente en el XML de configuración de spring.

5. Configuramos spring:

<?xml version=”1.0″ encoding=”UTF-8″?>
<beans xmlns=”http://www.springframework.org/schema/beans”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xmlns:sec=”http://www.springframework.org/schema/security”
xsi:schemaLocation=”http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.0.xsd”>

<sec:http entry-point-ref=”spnegoEntryPoint”>
<sec:intercept-url pattern=”/secure/**” access=”IS_AUTHENTICATED_FULLY” />
<sec:custom-filter ref=”spnegoAuthenticationProcessingFilter”
position=”BASIC_PROCESSING_FILTER” />
</sec:http>

<bean id=”spnegoEntryPoint”
class=”org.springframework.security.extensions.kerberos.web.SpnegoEntryPoint” />

<bean id=”spnegoAuthenticationProcessingFilter”
class=”org.springframework.security.extensions.kerberos.web.SpnegoAuthenticationProcessingFilter”>
<property name=”authenticationManager” ref=”authenticationManager” />
</bean>

<sec:authentication-manager alias=”authenticationManager”>
<sec:authentication-provider ref=”kerberosServiceAuthenticationProvider” />
</sec:authentication-manager>

<bean id=”kerberosServiceAuthenticationProvider”
class=”org.springframework.security.extensions.kerberos.KerberosServiceAuthenticationProvider”>
<property name=”ticketValidator”>
<bean
class=”org.springframework.security.extensions.kerberos.SunJaasKerberosTicketValidator”>
<property name=”servicePrincipal” value=”HTTP/rs-lab.lab.com@LAB.COM” />
<property name=”keyTabLocation” value=”classpath:http-rs-lab.keytab” />
<property name=”debug” value=”true”/>
</bean>
</property>
<property name=”userDetailsService” ref=”dummyUserDetailsService” />
</bean>

<!– Just returns the User authenticated by Kerberos and gives him the ROLE_USER –>>
<bean id=”dummyUserDetailsService” class=”org.springframework.security.extensions.kerberos.sample.DummyUserDetailsService”/>
</beans>

Hasta aquí todo como lo explica estupendamente Mike en su blog (http://blog.springsource.com/2009/09/28/spring-security-kerberos/).

Cuando en el navegador se pidan los credenciales, el usuario se puede introducir de dos maneras:
Como “lab\paco” o como “paco@lab.com”. Ambas formas son compatibles.

Ahora vamos a ver cómo configurar Flex para conseguir que aquellos usuarios que estén en el dominio se puedan autenticar utilizando Kerberos y aquellos que no estén en el dominio puedan utilizar una autenticación basada en formularios de Flex.

…. DRAFT

Example cache configuration:

proxy_cache_path /usr/local/nginx/cache/altaller levels=1:2 keys_zone=altaller:8m max_size=1000m inactive=600m;
proxy_temp_path /usr/local/nginx/cache/tmp;

server {
listen 80;
server_name admin.altaller.es;
index index.html;

auth_basic “altaller.es”;
auth_basic_user_file htpasswd;

location / {
proxy_pass http://localhost:8080;
proxy_cache altaller;
proxy_cache_key $uri$is_args$args;
proxy_cache_valid 200 302 60m;
proxy_cache_valid 404 1m;
}
}

This configuration specifies that there is a cache “altaller” stored in “/usr/local/nginx/cache/altaller”.

Each time that a new page is requested using http, a new file with a strange name is created inside previous folder. In this case, we request a “/admin/hello.html” page and a file “e74e6f246520c52df1b3e41fee0a5cdb” is created inside the cache structure that contains the following code:

z?1N????j?1N??0?NG
KEY: /admin/hello.html
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Content-Type: text/html;charset=ISO-8859-1
Content-Language: en-US
Content-Length: 399
Date: Thu, 28 Jul 2011 21:53:46 GMT
Connection: close

Thu Jul 28 21:53:46 UTC 2011
5
23
hello

This is a message

hola
……………

As you can see, the key “/admin/hello.html” and the HTML content is contained inside this file.

If we delete this file, the page is invalidated from the nginx cache.

Looking inside the code of nginx_ngx_cache_purge plugin, it uses a nginx function “ngx_http_file_cache_create_key” that creates the name of the file using the key of the cached page.

And finally, the strange name is a MD5 digest of the key in hexadecimal.

To test this, I have developed in Java the equivalent code:

MessageDigest digest = MessageDigest.getInstance(“MD5″);
byte[] bytes = digest.digest(“/admin/hello.html”.getBytes(“utf-8″));
StringBuffer sb = new StringBuffer();
for (int i = 0; i < bytes.length; i++) {
sb.append(Integer.toString((bytes[i] & 0xff) + 0×100, 16).substring(1));
}
System.out.println(sb.toString());

And TACHÁN!!! The result is:
e74e6f246520c52df1b3e41fee0a5cdb

Finally, the only thing we must do to explicitly invalidate a page from the cache using Java is deleting the file whose name is a MD5 of the key in hexadecimal.

The file is created in two levels folder structure (“/cache/altaller/b/cd/e74e6f246520c52df1b3e41fee0a5cdb”).

First level is taken from the last letter in the file name “b”.
Second level is taken from the two letters before the last “cd”.

That’s all folks!

We needed a reverse proxy cache to manage the traffic to a Tomcat server. After evaluating several alternatives (G-WAN, Traffic Server, Varnish, Lighttpd, …), we decided to use nginx for its low memory usage.

This is the basic configuration to manage the traffic to the Tomcat server:

http {
  proxy_cache_path  /Users/paco/cache/altaller levels=1:2 keys_zone=altaller:8m max_size=1000m inactive=600m;
  proxy_temp_path /Users/paco/cache/tmp; 

  server {
    location / {
      proxy_pass http://localhost:8080;
      proxy_cache altaller;
      proxy_cache_valid  200 302  60m;
      proxy_cache_valid  404      1m;
    }
  }
}

That's all folks!

The other day I needed to merge two XML documents using ActionScript (Flex). I show here a simple example of a recursive function to do so.

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
    xmlns:s="library://ns.adobe.com/flex/spark"
    xmlns:mx="library://ns.adobe.com/flex/mx"
    applicationComplete="example()">
  <fx:Script>
  <![CDATA[
    import mx.controls.Alert;

    private function example(): void {

      var xml1: XML =
        <fx:XMLList xmlns:fx="http://ns.adobe.com/mxml/2009">
          <fx:menuitem label="menu-1">
            <fx:menuitem label="menu-1-1">
              <fx:menuitem label="option-1"/>
              <fx:menuitem label="option-2"/>
            </fx:menuitem>
            <fx:menuitem label="menu-1-2">
              <fx:menuitem label="option-3"/>
            </fx:menuitem>
          </fx:menuitem>
          <fx:menuitem label="menu-2">
            <fx:menuitem label="option-4"/>
          </fx:menuitem>
        </fx:XMLList>

      var xml2: XML =
        <fx:XMLList xmlns:fx="http://ns.adobe.com/mxml/2009">
          <fx:menuitem label="menu-1">
            <fx:menuitem label="menu-1-1">
              <fx:menuitem label="option-2"/>
              <fx:menuitem label="option-6"/>
            </fx:menuitem>
            <fx:menuitem label="menu-1-2">
              <fx:menuitem label="menu-1-2-1">
                <fx:menuitem label="option-7"/>
                <fx:menuitem label="option-8"/>
              </fx:menuitem>
            </fx:menuitem>
          </fx:menuitem>
          <fx:menuitem label="menu-3">
            <fx:menuitem label="option-5"/>
          </fx:menuitem>
        </fx:XMLList>

      merge(xml1, xml2);

      Alert.show(xml1.toXMLString());
    }

    private function merge(destination: XML, source: XML): void {
      var t1: XML;
      var t2: XML;

      for each (t2 in source.*) {
        var exists: Boolean = false;

        for each (t1 in destination.*) {
          if (t1.@label == t2.@label) {
            exists = true;
            break;
          }
        }

        if (exists) {
          merge(t1, t2);
        }
        else {
          destination.appendChild(t2);
        }
      }
    }
  ]]>
  </fx:Script>
</s:Application>

See you soon!

C:\>xming :0 -clipboard -multiwindow

In putty.exe -> SSH -> X11 -> Check “Enable X11 forwarding” and introduce localhost:0 in “X display location”.

From Putty console:

# firefox (or whatever you want)