CloudBees offers a service to build and run JEE applications. After registering you get an ready to use Jenkins build system and an application server instance to run your application. Both is free with some limitations. The best thing is: You can combine both services. After building your application Jenkins is deploying it automatically to it’s CloudBees fellow and the build result is online and ready for use immediately afterwards.

I choosed an easy to install web application to test the service: Pebble, a lightweight, open source, Java EE blogging tool, build my maven. The goal was to build and run Pebble by CloudBees.

Since I had to change to maven configuration of the Pebble project a little I imported the SVN repository to my own at github. After that I could change and commit the pom.xml to run Maven goals of CloudBees. In the pluginRepositories of the pom.xml section I added:

 <pluginRepositories>
   <pluginRepository>
     <id>bees-plugins-snapshots</id>
     <url>http://repository-cloudbees.forge.cloudbees.com/public-snapshot/  </url>
     <releases>
       <enabled>true</enabled>
     </releases>
     <snapshots>
       <enabled>true</enabled>
     </snapshots>
    </pluginRepository>
 </pluginRepositories>

and the following to section build:

<build>
   <plugins>
     <plugin>
       <groupId>com.cloudbees</groupId>
       <artifactId>bees-maven-plugin</artifactId>
     </plugin>
   </plugins>
 </build>

After that I switched over to CloudBess and added the Applications service to my account which is also called RUN@cloud. In the service configuration I added a new application called pebble. No more configuration is needed here since Pebble needs no external database to run.

Next think was to add the Jenkins service to my account, called DEV@cloud. Jenkins is configured by the standard web interface:

I created a new job and choosed Build a maven2/3 project. In section Source Code Management of the job I selected Git an entered the Url of the repo: git://github.com/murygin/pebble.git.

More complicated is section Build. Here you have add the maven goal of CloudBees to deploy the application the application server:
bees:deploy -Dbees.appid=[ACCOUNT]/[APPLICATION± -Dbees.apikey=[API-KEY] -Dbees.secret=[SECRET-KEY]

API key and secret key you find in your CloudBees account settings.
Remember: This maven goal only works if you added the CloudBees plugin to your pom.xml as described above.

After running the job the project was build and deployed to the CloudBees application server. See my running example at: http://pebble.murygin.cloudbees.net/

To get a list of all indices execute the following:

SELECT
    t.relname AS table_name,
    i.relname AS index_name,
    a.attname AS column_name
FROM
    pg_class t,
    pg_class i,
    pg_index ix,
    pg_attribute a
WHERE
    t.oid = ix.indrelid
    AND i.oid = ix.indexrelid
    AND a.attrelid = t.oid
    AND a.attnum = ANY(ix.indkey)
    AND t.relkind = 'r'
ORDER BY
    t.relname,
    i.relname;

You can exclude indices of system tables by adding where clauses:

SELECT
    t.relname AS table_name,
    i.relname AS index_name,
    a.attname AS column_name
FROM
    pg_class t,
    pg_class i,
    pg_index ix,
    pg_attribute a
WHERE
    t.oid = ix.indrelid
    AND i.oid = ix.indexrelid
    AND a.attrelid = t.oid
    AND a.attnum = ANY(ix.indkey)
    AND t.relkind = 'r'
    AND t.relname NOT LIKE 'pg_%'
ORDER BY
    t.relname,
    i.relname;

All tracks in this mix are so-called CC-Music. They are released by different netlabels under a Creative-Commons (CC) licence. (Simplified) this means that you can copy and share this music legally without getting jailed by the evil music industry. Following the principals of Creative-Commons my mix is also CC licenced. You can use and change it. Redistribute it or copy it.

The Mix is recorded with Mixxx on Ubuntu Linux. Mixxx is a Open Source Digital DJ Software. It’s the best Open Source Software i discovered lately. Big thanks to the developers!

Details about the tracks:

#1 – Monomodal

• Artist: Segue
• Release: Nostalgia
• Download: http://www.silentseason.com/
• Netlabel: Silent Season from Canada

#2 – Steppa Stylee 2

• Artist: Hieronymus
• Release: [KY_D06]
• Download: http://www.archive.org/details/KY_D06
• Netlabel: Kyoto Digital from Denmark

#3 – Gydantis Lietus

• Artist: Giriu Dvasios
• Release: The Sound Of Nature 2
• Download: http://coldtear.com/the-sound-of-nature-2/
• Netlabel: Cold Tear Records from Lithuania

#4 – Decode

• Artist: Dublicator
• Release: Dublication
• Download: http://nnnl.hu/nnnl.07/nnnl07.html
• Netlabel: nonstopnonsense from Hungary

#5 – Floating

• Artist: Dominique Jacquinet
• Release: Floating
• Downlaod: http://www.this-side.net/releases/tup004
• Netlabel: This Side Music from Greece

It’s a common task in almost every application to show a table with a list of items and a detail view with one selected item of the table. RichFaces provides a data table component with a lot of sorting and ordering features called extendedDataTable. I will show how to implement the selection of one item of the table and display the item data in separate detail component. All action is done by AJAX requests without a page reload. You need a JSF application and RichFaces components to run this. To get started see the RichFaces Developer Guide.

In your JSF backing bean you need two properties holding your data, one for the list of items and one for the selected item. In the code sample they are called taskList and selectedTask. The list values are displayed in the extendedDataTable. If the user clicks one row the selected item is set as selectedTask in the bean. There are two more fields in the bean holding Richfaces data to implement the selection of table items: table and selection. You have to add them to your bean. Disadvantage is that your nice POJO now depends on RichFaces classes. Both are bind to extendedDataTable as you can see in the second code sample.

Loading of list items is done in loadTasks() which is called only once. Selecting of a item is done in method openTask() which is called when user clicks a table row.

public class TaskBean {
    
    List<ITask> taskList;
    ITask selectedTask;
    
    private HtmlExtendedDataTable table;
    private Selection selection = new SimpleSelection();
    
    public void openTask() {  
        Iterator<Object> iterator = getSelection().getKeys();
        while (iterator.hasNext()) {
            Object key = iterator.next();
            table.setRowKey(key);
            if (table.isRowAvailable()) {
                setSelectedTask( (ITask) table.getRowData());
            }
        }     
    }

    public List<ITask> loadTasks() {   
        return taskList = getTaskService().getTaskList();
    }

    public List<ITask> getTaskList() {
        if(this.taskList==null) {
            this.taskList = loadTasks();
        }
        return taskList;
    }
    public void setTaskList(List<ITask> taskList) {     
        this.taskList = taskList;
    }

    public ITask getSelectedTask() {
        return selectedTask;
    }
    public void setSelectedTask(ITask selectedTask) {
        this.selectedTask = selectedTask;
    }

    public HtmlExtendedDataTable getTable() {
        return table;
    }
    public void setTable(HtmlExtendedDataTable table) {
        this.table = table;
    }

    public Selection getSelection() {
        return selection;
    }
    public void setSelection(Selection selection) {
        this.selection = selection;
    }
    
    private ITaskService getTaskService() {
        return (ITaskService) VeriniceContext.get(VeriniceContext.TASK_SERVICE);
    }
}

In your template you have to add a rich:extendedDataTable. Several attributes are bind to the backing bean:

• value=“#{task.taskList}“ – The item list to dispaly in the table
• var=“item“ – Variable name used while iterating the list.
• binding=“#{task.table}“ – Richfaces class to hold table data, instance of org.richfaces.component.html.HtmlExtendedDataTable
• selection=“#{task.selection}“ – Richfaces class to hold table selection, instance of org.richfaces.model.selection.Selection

There is an important nested element inside extendedDataTable: a4j:support, which handles the selection of items. When user clicks on a table row it executes the openTask method in the bean and re-renders the detailPanel afterwards. In this example the detail panel only shows the tile of the selected item. Of course you add more attributes here or to show or edit the item.

<ui:composition xmlns="http://www.w3.org/1999/xhtml"
      xmlns:ui="http://java.sun.com/jsf/facelets"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core"
      xmlns:a4j="http://richfaces.org/a4j"
      xmlns:rich="http://richfaces.org/rich"
      template="/template.xhtml">
	<ui:define name="content">
		<a4j:outputPanel id="tablePanel">	     
			 <rich:extendedDataTable
			 	id="taskTable"
                value="#{task.taskList}" 
                var="item"
                binding="#{task.table}"
                selectionMode="single"
                selection="#{task.selection}"
                width="344">						                
                <rich:column id="colTitle"
					sortable="true" 
					sortBy="#{item.name}"
                    label="#{msgTask['title']}"
                    width="130">
                    <f:facet name="header">
                        <h:outputText value="#{msgTask['title']}" />
                    </f:facet>
                    <h:outputText value="#{item.name}"/>
                </rich:column>			                		                
                <rich:column id="colDate"
					sortable="true" 
					sortBy="#{item.createDate}"
                    label="bis"
                    width="84">
                    <f:facet name="header">
                        <h:outputText value="#{msgTask['createDate']}" />
                    </f:facet>
                    <h:outputText value="#{item.createDate}">
				    	<f:convertDateTime dateStyle="short" type="date" timeZone="#{task.timeZone}" />
				    </h:outputText>
                </rich:column>
                <a4j:support reRender="detailPanel"
	                    action="#{task.openTask}"
	                    event="onselectionchange" />					 
            </rich:extendedDataTable>				
		</a4j:outputPanel>
		<a4j:outputPanel id="detailPanel">
			<h:outputText value="#{task.selectedTask.name}"/>
		</a4j:outputPanel>				
	</ui:define>
</ui:composition>

Last week i noticed that you can easily inject one managed bean into another in your JSF configuration file faces-config.xml. Even if this not new to all of you i will write some configuration details.

The following code injects an instance of managed bean edit into an instance of bean task. Value #{edit} is referencing the managed-bean-name edit.

<faces-config>
   ..
    <managed-bean>
        <managed-bean-name>task</managed-bean-name>
        <managed-bean-class>sernet.verinice.web.TaskBean</managed-bean-class>
        <managed-bean-scope>session</managed-bean-scope>
        <managed-property>
            <property-name>editBean</property-name>
            <property-class>sernet.verinice.web.EditBean</property-class>
            <value>#{edit}</value>
        </managed-property>
    </managed-bean>
    <managed-bean>
        <managed-bean-name>edit</managed-bean-name>
        <managed-bean-class>sernet.verinice.web.EditBean</managed-bean-class>
        <managed-bean-scope>session</managed-bean-scope>
    </managed-bean>
   ..
</faces-config>

Class TaskBean needs a public getter and setter for EditBean:

public class TaskBean {

    private EditBean editBean;
    
    public EditBean getEditBean() {
        return editBean;
    }

    public void setEditBean(EditBean editBean) {
        this.editBean = editBean;
    }
}

The web container creates instances of TaskBean and EditBean for every user session. Without any „clue code“ the EditBean is set to the TaskBean instance by the container .

Using public-key cryptography anyone can encrypt messages using the public key, but only the holder of the paired private key can decrypt. Security depends on the secrecy of that private key.

This article describes the Java implementation of this approach based on the open source cryptography API for Java from Bouncy Castle.

Bouncy Castle provides a comprehensive but not easy to use API. I will show a utility class providing simple static methods for public-key encryption, which uses Bouncy Castle API internally. We use this class in verinice an open source Information security management system. You can download it from the verinice source code repository: SMIMEBasedEncryption.java. You also need classes from this package to compile SMIMEBasedEncryption.

Before using this class you have to enable unlimited strength encryption in the JRE. Go to the bottom of the JDK download page, download Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 6, and follow the instructioins in the archive.

Encrypt

SMIMEBasedEncryption has to methods to encrypt and decrypt data.
Static method encrypt:

• Param byte[] unencryptedByteData – The data to encrypt. You have to transform your String or File to a byte Array before
• Param File x509CertificateFile – Public key or certificate for encryption. I will describe below how to create this file with openssl.
• Returns the encrypted data as byte array.

Source:

public static byte[] encrypt(byte[] unencryptedByteData, File x509CertificateFile) 
  throws Exception {

  byte[] encryptedMimeData = new byte[] {};
  X509Certificate x509Certificate = CertificateUtils.loadX509CertificateFromFile(x509CertificateFile);
  try {
      SMIMEEnvelopedGenerator generator = new SMIMEEnvelopedGenerator();
      generator.addKeyTransRecipient(x509Certificate);
		
      // create Base64 encoded mime body
      unencryptedByteData = Base64.encode(unencryptedByteData);
      MimeBodyPart unencryptedContent = SMIMEUtil.toMimeBodyPart(unencryptedByteData);

      // Encrypt the byte data and make a MimeBodyPart from it
      MimeBodyPart encryptedMimeBodyPart = generator.generate(unencryptedContent, SMIMEEnvelopedGenerator.AES256_CBC, BouncyCastleProvider.PROVIDER_NAME);

      // Finally get the encoded bytes from the MimeMessage and return them
      ByteArrayOutputStream byteOutStream = new ByteArrayOutputStream();
      encryptedMimeBodyPart.writeTo(byteOutStream);
      encryptedMimeData = byteOutStream.toByteArray();
  } catch (Exception e) {
        throw new EncryptionException("There was a problem during the en- or decryption process. See the stacktrace for details.", e);
  }
  return encryptedMimeData;
}

Decrypt

Static method decrypt:

• Param byte[] encryptedByteData – The encrypted data. Reed this from a file or database before.
• Param File x509CertificateFile – Public key or certificate for decryption. I will describe below how to create this file with openssl.
• Param File privateKeyPemFile – Private key for decryption. I will describe below how to create this file with openssl.
• String privateKeyPassword – The password for the private key. This param is optional since not every private key is password protected. It might be null.
• Returns the decrypted data as byte array.

Source:

public static byte[] decrypt(
  byte[] encryptedByteData, 
  File x509CertificateFile, 
  File privateKeyPemFile, 
  final String privateKeyPassword) throws Exception {

  byte[] decryptedByteData = new byte[] {};
  // Get public key certificate
  X509Certificate x509Certificate = CertificateUtils.loadX509CertificateFromFile(x509CertificateFile);

  // The recipient of the S/MIME encrypted message
  RecipientId recipient = new RecipientId();
  recipient.setSerialNumber(x509Certificate.getSerialNumber());
  recipient.setIssuer(x509Certificate.getIssuerX500Principal());

  // The recipient's private key
  FileReader fileReader = new FileReader(privateKeyPemFile);
  PasswordFinder passwordFinder = new PasswordFinder() {
      @Override
      public char[] getPassword() {
          return (privateKeyPassword != null) ? privateKeyPassword.toCharArray() : null;
      }
  };
  PEMReader pemReader = null;
  if (passwordFinder.getPassword() != null && passwordFinder.getPassword().length > 0) {
      pemReader = new PEMReader(fileReader, passwordFinder);
  } else {
      pemReader = new PEMReader(fileReader);
  }
  KeyPair keyPair = (KeyPair) pemReader.readObject();
  PrivateKey privateKey = keyPair.getPrivate();

  try {
      MimeBodyPart encryptedMimeBodyPart = new MimeBodyPart(new ByteArrayInputStream(encryptedByteData));
      SMIMEEnveloped enveloped = new SMIMEEnveloped(encryptedMimeBodyPart);

      // look for our recipient identifier
      RecipientId recipientId = new RecipientId();

      recipientId.setSerialNumber(x509Certificate.getSerialNumber());
      recipientId.setIssuer(x509Certificate.getIssuerX500Principal());

      RecipientInformationStore recipients = enveloped.getRecipientInfos();
      RecipientInformation recipientInfo = recipients.get(recipientId);

      if (recipientInfo != null) {
          decryptedByteData = recipientInfo.getContent(privateKey, BouncyCastleProvider.PROVIDER_NAME);
      }
  } catch (Exception e) {
      throw new EncryptionException("There was an IO problem during the en- or decryption process. See the stacktrace for details.", e);
  } 

  decryptedByteData = Base64.decode(decryptedByteData);
  return decryptedByteData;
}

Create public and private key

You can create the public key (certificate) and private key files used in the methods with OpenSSL which is part of most Linux distributions. Just enter the following on command line:

openssl req \
  -x509 -nodes -days 365 \
  -newkey rsa:1024 -keyout key.pem -out cert.pem

OpenSSL asks several questions about the certificate and creates two file:

• cert.pem – public key or certificate
• key.pem – private key

Use this files as parameters in the encrypt and decrypt methods.

Eclipse enthält eine Rechtschreibprüfung. Leider kann man die Prüfung nicht einfach auf andere Sprachen umstellen, wie es trotzdem geht beschreibt dieser Artikel auf javathreads.de.

Benötigt wird eine einfache Textdatei mit möglichst vielen deutschen Wörter. In jeder Zeile muss genau ein Wort stehen. Ein solche Datei mit über 300.000 Wörtern lässt sich einfach mit aspell erzeugen.


sudo aptitude install aspell aspell-de
aspell dump master de_DE > eclipse_de_DE.txt


Download der Datei, für alle, denen das zu aufwendig ist : eclipse_de_DE.txt

Die Datei eclipse_de_DE.txt muss wie im Artikel auf javathreads.de beschrieben, in Eclipse importieren werden.

If you use Java resource bundles to add multi language support to your application you sometimes need to add parameter to you properties but resource bundles from the JDK itself does not support parameter substitution.

messages.properties:

...
itemservice.item.added = User {0} added new item {1} to group {2}
...


messages_de.properties (German):

...
itemservice.item.added = Das Objekt {1} wurde von Benutzer {0} zur Gruppe {2} hinzugef\u00FCgt.
...


As you can see parameter order differs in German property file. That’s why its hard to realize this example without parameters. To replace parameters by values, you have to use method java.text.MessageFormat.format(String text, Object … arguments). Add a small wrapper class to you project:


public class Messages {
    // property file is: package/name/messages.properties
    private static final String BUNDLE_NAME = "package.name.messages";
    private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle.getBundle(BUNDLE_NAME);
    private Messages() {
    }
    public static String getString(String key) {
        try {
            return RESOURCE_BUNDLE.getString(key);
        } catch (MissingResourceException e) {
            return '!' + key + '!';
        }
    }
    public static String getString(String key, Object... params  ) {
        try {
            return MessageFormat.format(RESOURCE_BUNDLE.getString(key), params);
        } catch (MissingResourceException e) {
            return '!' + key + '!';
        }
    }
}


You can now use the properties from the example above:

Messages.getString( "itemservice.item.added", user.getName(), item.getTitle(), group.getName());


I use a byte-array to persist a file in a database with hibernate. After converting file data to a byte-array i map the byte-array to a property of type BINARY:

Entity class:

public class Attachment implements Serializable {
  private byte[] fileData;
  public byte[] getFileData() {
    return fileData;
  }
  public void setFileData(byte[] fileData) {
    this.fileData = fileData;
  }
}

<hibernate-mapping package="sernet.verinice.hibernate.model">
<class name="AttachmentFile" table="attachment">
  ..
  <property name="fileData" type="binary" >
    <!-- 10 MB = 10485760 B -->
    <column name="fileData" length="10485760"/>
  </property>
  ..
  </class>
</hibernate-mapping>

I used PostgreSQL first and everything works fine. Hibernate maps binary-types in PostgreSQL to column type BYTEA.

After switching to Derby i noticed that hibernate tries to map the byte-array to a VARCHAR(255) which of course is to small for a normal file. You can fix this by extending the build in derby-dialect. In the extended dialect you map the binary type to a BLOB:

public class ByteArrayDerbyDialect extends org.hibernate.dialect.DerbyDialect {
  public ByteArrayDerbyDialect() {
    super();
    // override VARBINARY mapping to varchar($l) from DerbyDialect(DB2Dialect)
    registerColumnType( Types.VARBINARY, "blob($l)" );
  }
}

To use the new dialect you have to set hibernate property hibernate.dialect:

hibernate.dialect=your.package.ByteArrayDerbyDialect


Songbird ships with it’s own gstreamer codecs which conflict with the ones shipped with Karmic. All you need to do is to remove the gstreamer libs shipped with songbird:

cd /path/to/Songbird/lib/ && sudo rm -rf libgst*

Enjoy Songbird on Ubuntu 9.10!