Hoteia Blog

Host your website pages on GitHub

2012-11-16T11:08:00.002+01:00

Français
Anglais

Héberger vos pages web (static) sur GitHub

Quelques étapes pour héberger votre contenu web sur GitHub. Prenons notre exemple, Qalingo.com

1) Nous avons créé notre organisation sur GitHub: Qalingo

2) Nous créons notre projet, et le transférons vers l'organisation. Le projet associé doit être absolument de type yourName.github.com : qalingo.github.com

3) Règles DNS pour notre nom de domaine : qalingo.com

Par habitude, nous créons 4 redirections utiles:

qalingo.com vers www.qalingo.com
w.qalingo.com vers www.qalingo.com
ww.qalingo.com vers www.qalingo.com
wwww.qalingo.com vers www.qalingo.com

Puis 2 lignes de règles DNS

qalingo.github.com 10800 IN A 204.232.175.78
www 10800 IN CNAME qalingo.github.com.

Attendre que les règles soient diffusées.
Vous pouvez tester de temps en temps par la commande :

host -t a domainName

Soit pour nous

host -t a www.qalingo.com

qui dans notre exemple doit afficher :

www.qalingo.com is an alias for qalingo.github.com.
qalingo.github.com has address 204.232.175.78

Il ne vous reste plus qu'à déposer votre projet web static sur votre repos GitHub (clone, add, commit, push, ...).

Enjoy.

Références

GitHub pages
GitHub: User, Organization and Project Pages
GitHub: Set up Git
Git, what's that ?

Host your (static) website pages on GitHub

Few steps to host your web content on GitHub. Consider our example, Qalingo.com

1) We have create our organization on GitHub: Qalingo

2) We create our project, and transfer to the organization. The project name must be absolutely like yourName.github.com: qalingo.github.com

3) Rules for our DNS domain name: qalingo.com

As many times, we create four helpful redirects:

qalingo.com vers www.qalingo.com
w.qalingo.com vers www.qalingo.com
ww.qalingo.com vers www.qalingo.com
wwww.qalingo.com vers www.qalingo.com

Then 2 lines of DNS rules

qalingo.github.com 10800 IN A 204.232.175.78
www 10800 IN CNAME qalingo.github.com.

Wait until the rules are diffused.
Some time, you can test with the command

host -t a domainName

in our case, looks like

host -t a www.qalingo.com

which in our example will display:

www.qalingo.com is an alias for qalingo.github.com.
qalingo.github.com has address 204.232.175.78

Just drop your static web project on your rest GitHub (clone, add, commit, push, ...).

Enjoy.

References

GitHub pages
GitHub: User, Organization and Project Pages
GitHub: Set up Git
Git, what's that ?

Qalingo: Opensource Java eCommerce draft

2012-11-05T18:32:00.002+01:00

Opensource Java eCommerce (POC version, Qalingo)

Français
Anglais

Opensource Java eCommerce (POC version, Qalingo)

Après une longue expérience sur un eCommerce pour une marque française, j'ai souhaité démarrer un projet opensource Java par opposition aux nombreux projets PHP trop plébiscités à mon goût et malgré la présence d'initiatives très respectables comme Broadleaf Commerce, JadaSite, Shopizer ou KonaKart.

Je partage donc une première version écrite ces dernières semaines. Cette étape permettra de prendre du recul et d'en discuter.
Cette version est un Proof Of Concept, où je n'ai rien optimisé, la cible étant d'écrire un premier jet rapide.
Les puristes s'agaçeront sur bien des couches et je m'en excuse, c'est un draft ;)

Le repository est sur GitHub : GitHub Qalingo
La Licence opensource est à définir, actuellement en Apache License Version 2.0 (le monde des licences opensource est bien compliqué)

Ce projet se présente comme une boite à outils composée de modules Maven :

Qalingo : B2C Engine

- qalingo-apis : Les APIs Core qui composeront le moteur eCommerce
- qalingo-misc : Les modules tiers pour import/export, SQL, traductions

*Qalingo : B2C Engine on GitHub

Qalingo : B2C Web Batch Synchronization

qalingo-qalingo-webapp-applications : Les applications tiers type Spring-Batch dédiées à synchroniser le eCommerce vers le CRM/CMS/ERP etc...

*Qalingo : B2C Web Batch Synchronization on GitHub

Qalingo : B2C Web classic Frontoffice & Backoffice

- qalingo-theme-assets : Les ressources type "page" et js/css/img etc...
- qalingo-webapp-backoffices : Les backs, divisés en 3 : "business", "reporting", "technical"
- qalingo-webapp-frontoffices : Les fronts "prehome", "mcommerce"

*Qalingo : B2C Web classic Frontoffice & Backoffice on GitHub

Qalingo : B2C Web Remote

- qalingo-webapp-remotes : Les fronts "remote" Rest/Webservices (pour les Apps mobile)

*Qalingo : B2C Web Remote on GitHub

D'un point de vue métier, la cible de ce premier jet :

Gestion d'un catalogue customisable par marché. Il y a donc une definition sur 3 niveaux d'objets pour s'adapter à une marque qui aurait un catalogue monde, une surcharge par marché, avec une ensemble de traductions pour chacun de ces marchés (MarketPlace>Market>MarketArea>Localization).
Gestion des thèmes par marché et par device via le filtre de l'API Wurlf
URLs réécrites
Sécurité via Spring-security
Simple gestion des cutomers
Gestion d'attributs complémentaires pour les objets Customer/ProductCategory/ProductMarketing/ProductSku/PaymentGateway/Store
Simple Tunnel d'achat
Wishlist customer
Gestion de régles métier Via Drools
Gestion de la recherche via SOLR
Génération des traductions depuis une feuille Excel dédiée aux équipes métier
Pré Home dédiée à la redirection vers les n marchés
OpenStreetMap pour la liste des points de vente

Votre support, votre aide, vos critiques, remarques, conseils seront les bienvenus.

Prochaine étapes, mettre en place une alpha début décembre, une beta début 2013, une 1.0 printemps 2013 (suivant les retours) :

Nettoyer le code
Optimiser le code
Ecrire les test unitaires
Definir tous les types d'Exception et les logs associés
Conception des backoffices.
Conception du "remote" Rest pour les apps mobile
Brancher le eCommerce vers un CMS de type Alfresco via la norme CMIS (open CMIS) pour synchroniser en Rest les deux environnements
Ecriture des règles Drools
Réflexion sur les "bundles"
Réflexion sur les "changesets"
Exports/Imports ?
Réflexion pour permettre des "hooks/plugins" autrement qu'en surchargeant les beans Spring
portlet Liferay connecté sur la webapp "remote" Rest ?
Une longue liste de chose à faire, même pour un simple ecommerce...

La stack actuelle des frameworks :

Spring	3.1.2.RELEASE
Hibernate	4.1.7.Final
ehcache	2.6.0
Velocity	1.7
JQuery	1.7.2
Spring-Batch	2.1.9.RELEASE
Spring-WS	2.1.0.RELEASE
Spring-Security	3.1.2.RELEASE
Boostrap	2.2.1
Wurlf/ScientiaMobile	1.4.2
SOLR	4.0.0-BETA
DROOLS	5.4.0.Final
logback	1.0.6

Les outils :

Maven	3.0
MySql (server)	5.1.51
MySql (driver)	5.1.9
Apache-tomcat	7.0.22
Apache	2.2
Java	1.6.0_22

Malgré le fait que j'apprécie beaucoup ce framework, j'ai abandonné Vaadin, pour ne pas avoir trop de frameworks différents. De ce fait les backoffices sont en velocity avec un theme Bootstrap/Font Awesome comme les frontoffices.

Je vais continuer de commiter, et publier en parallèle sur le blog des zooms sur chaques parties.

To Be Continued...

Références

Repository Maven Hoteia
Site web Qalingo
GitHub Qalingo
Demo Qalingo

Opensource Java eCommerce (POC version, Qalingo)

After a long experience on an eCommerce for a French brand, I wanted to start an opensource project Java despite the presence of very respectable initiatives as Broadleaf Commerce, JadaSite, or Shopizer KonaKart and versus PHP projectsversus PHP projects (too acclaimed for my taste).

I share a first version written in recent weeks. This step will be the good time to get feedback and discuss.
This version is a proof of concept, where nothing is realy optimized. The target was to write a first draft quickly.
The purists will be warm concerning many layers and i'm sorry, this is a draft;)

The repository is on GitHub: GitHub Qalingo
The License opensource is to define, current version is on Apache License Version 2.0 (the world of open source licenses is realy complicated)

This project looks like a toolbox consisting of modules Maven:

Qalingo : B2C Engine

- qalingo-apis : The Core APIs that make up the engine eCommerce
- qalingo-misc : The third party modules for import / export, SQL translations

*Qalingo : B2C Engine on GitHub

Qalingo : B2C Web Batch Synchronization

qalingo-qalingo-webapp-applications : Applications such third-Spring Batch dedicated to eCommerce to synchronize CRM / CMS / ERP etc...

*Qalingo : B2C Web Batch Synchronization on GitHub

Qalingo : B2C Web classic Frontoffice & Backoffice

- qalingo-theme-assets : resources type "page" and js / css / img etc...
- qalingo-webapp-backoffices : The backs were divided into three projects "business", "reporting", "technical"
- qalingo-webapp-frontoffices : Fronts "prehome", "mCommerce"

*Qalingo : B2C Web classic Frontoffice & Backoffice on GitHub

Qalingo : B2C Web Remote

- qalingo-webapp-remotes : Fronts "remote" Rest / Webservices (for mobile apps)

*Qalingo : B2C Web Remote on GitHub

Business perspective, the target of the first draft:

Catalog management customizable by market. So there is a definition of three levels of Market objects and the last one for the localization. Marketplace> Market> MarketArea> Localization.
Theme by market and using the filter device API Wurlf
Rewritten URLs
Security via Spring-security
Simple management cutomers
Attributes object Management for Customer / ProductCategory / ProductMarketing / ProductSku / PaymentGateway / Store
Simple Tunnel
Customer Wishlist
Management of business rules via Drools
Research via SOLR
Generation of translations from an Excel sheet dedicated to business teams
PreHome dedicated to redirect to the n markets
OpenStreetMap for a list of outlets

Your support, your help, comments and advice are welcome.

Next steps, alpha version on December, a beta in early 2013, a 1.0 spring 2013 (after returns):

Clean code
Optimize the code
Write the unit test
Define all types of Exception and associated logs
Backoffices design
Design "remote" Rest for mobile apps
Connect the ecommerce project to a CMS like Alfresco by CMIS standard (open CMIS/Rest) to synchronize the two environments
Writing Drools rules
Brainstorming on "bundles"
Brainstorming on "changesets"
Exports/Imports ?
Brainstorming to allow "hooks/plugins" other than overloading the Spring beans
Liferay portlet webapp connected to the "remote" Rest?
A long list of things to do, even for a simple ecommerce ...

Frameworks stack:

Spring	3.1.2.RELEASE
Hibernate	4.1.7.Final
ehcache	2.6.0
Velocity	1.7
JQuery	1.7.2
Spring-Batch	2.1.9.RELEASE
Spring-WS	2.1.0.RELEASE
Spring-Security	3.1.2.RELEASE
Boostrap	2.2.1
Wurlf/ScientiaMobile	1.4.2
SOLR	4.0.0-BETA
DROOLS	5.4.0.Final
logback	1.0.6

Tools:

Maven	3.0
MySql (server)	5.1.51
MySql (driver)	5.1.9
Apache-tomcat	7.0.22
Apache	2.2
Java	1.6.0_22

Although I appreciate this framework and not wishing too much different frameworks, i abandoned Vaadin. Backoffices are build with Bootstrap theme / Font Awesome as frontoffices.

I will continue to commit on github, and publish more documentations on the blog.

To Be Continued...

References

Repository Maven Hoteia
Site web Qalingo
GitHub Qalingo
Demo Qalingo

Quick tip, svn files clean your project with Dos command

2012-04-25T23:50:00.002+02:00

Français
English

Un rapide post, pour partager une commande que je me surprends encore à utiliser au demarrage d'un projet composé de copier/coller ou d'autre projets.
La commande Dos supprime de manière récursive l'ensemble des fichiers SVN :

for /f "usebackq" %d in (`"dir *.svn /ad/b/s"`) do rd /s/q "%d"

... et bien utile vu que tout n'est pas encore sous Git ;)

A quick post to share a tip. I'm suprise to using an old command to clean a project after somes copy/paste or build from others projects.
This Dos command recursively deletes all files SVN:

for /f "usebackq" %d in (`"dir *.svn /ad/b/s"`) do rd /s/q "%d"

...and very useful because not everything is still under Git ;)

Sql Server JDBC driver fail with sdk 1.6.0.29

2012-03-03T10:32:00.002+01:00

Français
English

Si vous utilisez un SQL Server avec le driver JDBC de Microsoft et le SQK 1.6.0.29 d'Oracle, sachez que celà ne fonctionnera probablement pas.
En effet vous riquez de perdre comme moi quelques heures précieuses. Il faut manquer de chance pour tomber sur ce problème de version mais il exite.
Aucune log ne met bien en exergue le problème. La solution reste cependant assez simple puisqu'il s'agit juste de changer de SDK.

Un lien qui m'a confirmé ce problème sur le forum d'Oracle

If you use a SQL Server with the JDBC driver from Microsoft and Oracle SQK 1.6.0.29, know that it probably will not work.
Indeed, you risk losing a few precious hours like me. It is be unlucky to come across this version problem.
No log is strongly underlines the problem. The solution is quite simple, just to change the SDK.

A link who confirmed this problem on the Oracle forum

Spring-security @ Autowired is null if the element <debug/> is present

2012-02-21T13:22:00.001+01:00

Français
English

Si vous avez des valeurs "null" au niveau d'injections qui devraient fonctionner, donc déclarées par un scan, voici peut-être une piste.
J'ai perdu un peu de temps sur le fait que l'élément <debug/> corrompait les injections Spring. Faute de recherche et d'infos sur cela, j'ai trouvé de façon empirique.
Je vous invite à vérifier votre applicationContext dédié à spring-security et à commenter cet élément pour tester et vérifier qu'il est bien la cause du problème.

L'élément <debug/> est déclaré dans spring-security 3.1 xsd

If you have any null values with Autowired injections that should work, so declared by a scan, maybe the following info is the solution.
I lost a little time on the fact that the element <debug/> corrupted Spring injections. I didn't find info on this, I found step by step.
I invite you to check your applicationContext dedicated to spring-security and comment this element to test and verify that it is causing the problem.

This élément <debug/> is declared in the spring-security 3.1 xsd

Maven repository with Android Google Maps libs

2011-06-11T22:07:00.010+02:00

Français
English

Les librairies Android Google Maps sont mises à jour sur notre repository maven http://nexus.hoteia.com
com.google.android.maps r3_3 4_r2 7_r1 8_r2 9_r2 10_r2 11_r1 12_r1

<dependency>
        <groupid>com.google.android.maps</groupId>
        <artifactid>maps</artifactId>
        <version>12_r1</version>
        <scope>provided</scope>
    </dependency>

à suivre...

Android Google Maps libs are uploaded on our Maven repository http://nexus.hoteia.com
com.google.android.maps r3_3 4_r2 7_r1 8_r2 9_r2 10_r2 11_r1 12_r1

<dependency>
        <groupid>com.google.android.maps</groupId>
        <artifactid>maps</artifactId>
        <version>12_r1</version>
        <scope>provided</scope>
    </dependency>

To be continued...

Hoteia open a public maven repository with Maven

2011-03-17T12:07:00.008+01:00

Français
Anglais

Comment utiliser notre repository Maven ?

Pour utiliser notre repository Maven et profiter de nos ajouts de librairies tel que celles qui peuvent manquer à l'utilisation de Maven avec Appengine, voici un exemple de configuration.

Vous trouverez l'interface de consultation sur http://nexus.hoteia.com/index.htm. Si la configuration de notre repository vous pose problème ou si vous souhaiteriez que nous ajoutions d'autres librairies, contactez-nous www.hoteia.com.

Pour plus d'informations sur la configuration de maven, nous vous invitons à consulter cette section du site officiel de Maven http://maven.apache.org/settings.html

<settings>

    <servers>
    </servers>

    <mirrors>
        <mirror>
            <id>hoteia-all</id>
            <name>Hoteia.com</name>
            <mirrorOf>central,apache, google code, jahia.org, java.net, springsource</mirrorOf>
            <url>http://nexus.hoteia.com/content/groups/public</url>
        </mirror>
    </mirrors>
    <profiles>
        <profile>
            <id>nexus</id>
            <repositories>
                <repository>
                    <id>central</id>
                    <url>http://central</url>
                    <releases>
                        <enabled>true</enabled>
                    </releases>
                    <snapshots>
                        <enabled>false</enabled>
                    </snapshots>
                </repository>
                <repository>
                    <id>hoteia-releases</id>
                    <url>http://nexus.hoteia.com/content/repositories/releases</url>
                    <releases>
                        <enabled>true</enabled>
                    </releases>
                    <snapshots>
                        <enabled>false</enabled>
                    </snapshots>
                </repository>
            </repositories>
            <pluginRepositories>
                <pluginRepository>
                    <id>central</id>
                    <url>http://central</url>
                    <releases>
                        <enabled>true</enabled>
                    </releases>
                    <snapshots>
                        <enabled>false</enabled>
                    </snapshots>
                </pluginRepository>
            </pluginRepositories>
        </profile>
    </profiles>

    <activeProfiles>
        <activeProfile>nexus</activeProfile>
    </activeProfiles>

</settings>

Références

nexus.hoteia.com
http://nexus.sonatype.org
http://maven.apache.org

How to use our Maven repository?

To use our Maven repository and enjoy our additions to libraries such as those that may miss the use of Maven with AppEngine, here is a sample configuration.

You find the interface of consultation on http://nexus.hoteia.com/index. htm . If you have problems with the configuration of our repository or if you would like us to add other libraries, please contact us www.hoteia.com .

For more information about configuring maven, please consult this section of the official site Maven http://maven.apache.org/settings.html

<settings>

    <servers>
    </servers>

    <mirrors>
        <mirror>
            <id>hoteia-all</id>
            <name>Hoteia.com</name>
            <mirrorOf>central,apache, google code, jahia.org, java.net, springsource</mirrorOf>
            <url>http://nexus.hoteia.com/content/groups/public</url>
        </mirror>
    </mirrors>
    <profiles>
        <profile>
            <id>nexus</id>
            <repositories>
                <repository>
                    <id>central</id>
                    <url>http://central</url>
                    <releases>
                        <enabled>true</enabled>
                    </releases>
                    <snapshots>
                        <enabled>false</enabled>
                    </snapshots>
                </repository>
                <repository>
                    <id>hoteia-releases</id>
                    <url>http://nexus.hoteia.com/content/repositories/releases</url>
                    <releases>
                        <enabled>true</enabled>
                    </releases>
                    <snapshots>
                        <enabled>false</enabled>
                    </snapshots>
                </repository>
            </repositories>
            <pluginRepositories>
                <pluginRepository>
                    <id>central</id>
                    <url>http://central</url>
                    <releases>
                        <enabled>true</enabled>
                    </releases>
                    <snapshots>
                        <enabled>false</enabled>
                    </snapshots>
                </pluginRepository>
            </pluginRepositories>
        </profile>
    </profiles>

    <activeProfiles>
        <activeProfile>nexus</activeProfile>
    </activeProfiles>

</settings>

References

nexus.hoteia.com
http://nexus.sonatype.org
http://maven.apache.org

Spring Webservice 2.0 with JaxB (Maven, Hibernate, Tomcat)

2011-01-18T16:26:00.004+01:00

Français

Pré-requis

Pour ce tutorial, nous travaillons avec Maven 3.0, Spring 3.0, Spring WS 2.0, JaxB 2.1, Hibernate 3.4, Tomcat 6.0.29, JDK 1.6.0.17.
L'ensemble de cette architecture est disponible dans le zip hoteia-howto-spring-ws-jaxb-full.
Un second fichier, hoteia-howto-spring-ws-jaxb-project, ne contient que le workspace.

Mise en place du core, Service & DAO

Création de l'entité Person, de son DAO et de son service tel que :

Person.java

package com.hoteia.howto.spring.domain;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.persistence.Version;

@Entity
@Table(name = "hoteia_person")
@NamedQueries({
 @NamedQuery(name="person.personByLastname", query="FROM Person person WHERE person.lastname = :lastname")
})
public class Person implements Serializable {

 /**
  * Generated UID
  */
 private static final long serialVersionUID = 5907376955767500978L;

 @Id
 @GeneratedValue(strategy = GenerationType.AUTO)
 private Long id;
 
 @Version
 private int version;
 
 private String title;
 private String lastname;
 private String firstname;

 public Long getId() {
  return id;
 }

 public void setId(Long id) {
  this.id = id;
 }
 
 public int getVersion() {
  return version;
 }

 public void setVersion(int version) {
  this.version = version;
 }

 public String getTitle() {
  return title;
 }

 public void setTitle(String title) {
  this.title = title;
 }

 public String getLastname() {
  return lastname;
 }
 
 public void setLastname(String lastname) {
  this.lastname = lastname;
 }
 
 public String getFirstname() {
  return firstname;
 }
 
 public void setFirstname(String firstname) {
  this.firstname = firstname;
 }

 @Override
 public String toString() {
  return "Person [id=" + id + ", version=" + version + ", title=" + title
    + ", lastname=" + lastname + ", firstname=" + firstname + "]";
 }

 @Override
 public int hashCode() {
  final int prime = 31;
  int result = 1;
  result = prime * result
    + ((firstname == null) ? 0 : firstname.hashCode());
  result = prime * result + ((id == null) ? 0 : id.hashCode());
  result = prime * result
    + ((lastname == null) ? 0 : lastname.hashCode());
  result = prime * result + ((title == null) ? 0 : title.hashCode());
  result = prime * result + version;
  return result;
 }

 @Override
 public boolean equals(Object obj) {
  if (this == obj)
   return true;
  if (obj == null)
   return false;
  if (getClass() != obj.getClass())
   return false;
  Person other = (Person) obj;
  if (firstname == null) {
   if (other.firstname != null)
    return false;
  } else if (!firstname.equals(other.firstname))
   return false;
  if (id == null) {
   if (other.id != null)
    return false;
  } else if (!id.equals(other.id))
   return false;
  if (lastname == null) {
   if (other.lastname != null)
    return false;
  } else if (!lastname.equals(other.lastname))
   return false;
  if (title == null) {
   if (other.title != null)
    return false;
  } else if (!title.equals(other.title))
   return false;
  if (version != other.version)
   return false;
  return true;
 }
 
}

PersonDaoImpl.java

package com.hoteia.howto.spring.dao.impl;

import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import com.hoteia.howto.spring.dao.PersonDao;
import com.hoteia.howto.spring.domain.Person;

@Repository("personDao")
@Transactional
@Scope("prototype")
public class PersonDaoImpl extends BaseDaoImpl implements PersonDao {

 protected final Log logger = LogFactory.getLog(getClass());
 
 public Person getPersonById(String personId) {
  return hibernateTemplate.get(Person.class, new Long(personId));
 }

 @SuppressWarnings("unchecked")
 public Person getPersonByLastname(String lastname) {
  String[] parameterNames = new String[] { "lastname" };
  String[] parameterValues = new String[] { lastname };
  List<Person> persons = hibernateTemplate.findByNamedQueryAndNamedParam("person.personByLastname", parameterNames, parameterValues);
  if(persons != null
    && persons.size() > 1){
   return persons.get(0);
  } else {
   return null;
  }
 }
 
 @SuppressWarnings("unchecked")
 public List<Person> findAllPerson(Person person) {
  return (List<Person>) hibernateTemplate.find("from " + Person.class.getName());
 }

 @Transactional(readOnly = false)
 public void savePerson(Person person) {
  hibernateTemplate.saveOrUpdate(person);
 }

 @Transactional(readOnly = false)
 public void deletePerson(Person person) {
  hibernateTemplate.delete(person);

 }

}

hoteia-howto-spring-dao.xml, context des DAOs, qui sera packagé dans le jar pour être importé dans le context de la webapp.

<?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:p="http://www.springframework.org/schema/p"
     xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
     ">

 <context:component-scan base-package="com.hoteia.howto"/>
 
</beans>

PersonServiceImpl.java

package com.hoteia.howto.spring.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import com.hoteia.howto.spring.dao.PersonDao;
import com.hoteia.howto.spring.domain.Person;
import com.hoteia.howto.spring.service.PersonService;

@Repository("personService")
public class PersonServiceImpl implements PersonService {
 
 @Autowired
 private PersonDao personDao;

 public Person getPersonById(String personId) {
  return personDao.getPersonById(personId);
 }
 
 public Person getPersonByLastname(String lastname) {
  return personDao.getPersonByLastname(lastname);
 }

 public List<Person> findAllPerson(Person person) {
  return personDao.findAllPerson(person);
 }
 
 public void savePerson(Person person) {
  personDao.savePerson(person);
 }

 public void deletePerson(Person person) {
  personDao.deletePerson(person);
 }

}

hoteia-howto-spring-service.xml, context des Services, qui sera packagé dans le jar pour être importé dans le context de la webapp.

<?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:p="http://www.springframework.org/schema/p"
     xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
     ">

 <context:component-scan base-package="com.hoteia.howto"/>

</beans>

Références

Hibernate

Mise en place du client/server ws

person.xsd

<?xml version="1.0" encoding="UTF-8"?>
                    
<xsd:schema xmlns="http://localhost:8280/ws-in/ws/services/person/schemas"
            targetNamespace="http://localhost:8280/ws-in/ws/services/person/schemas"
            xmlns:xsd="http://www.w3.org/2001/XMLSchema">

    <xsd:element name="save-persons-request">
        <xsd:complexType>
            <xsd:sequence>
                <xsd:element name="person" type="person" minOccurs="0" maxOccurs="unbounded" />
            </xsd:sequence>
        </xsd:complexType>
    </xsd:element> 
    
    <xsd:element name="save-persons-response">
        <xsd:complexType>
            <xsd:sequence>
                <xsd:element name="response" type="response" minOccurs="0" maxOccurs="1" />
            </xsd:sequence>
        </xsd:complexType>
    </xsd:element>

    <xsd:complexType name="person">
        <xsd:sequence>
            <xsd:element name="id" type="xsd:string" />
            <xsd:element name="lastname" type="xsd:string" />
            <xsd:element name="firstname" type="xsd:string" />
        </xsd:sequence>
    </xsd:complexType>

    <xsd:complexType name="response">
        <xsd:sequence>
            <xsd:element name="message" type="xsd:string" />
            <xsd:element name="code" type="xsd:string" />
            <xsd:element name="status" type="xsd:string" />
        </xsd:sequence>
    </xsd:complexType>
 
</xsd:schema>

PersonEndpoint.java

package com.hoteia.howto.spring.ws;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ws.server.endpoint.annotation.Endpoint;
import org.springframework.ws.server.endpoint.annotation.PayloadRoot;

import com.hoteia.howto.spring.Constants;
import com.hoteia.howto.spring.ws.jaxb.pojo.ObjectFactory;
import com.hoteia.howto.spring.ws.jaxb.pojo.SavePersonsRequest;
import com.hoteia.howto.spring.ws.jaxb.pojo.SavePersonsResponse;
import com.hoteia.howto.spring.ws.service.PersonEndPointService;

/**
 * Person Web service endpoint. Uses a PersonService to create a response string.
 *
 */
@Endpoint
public class PersonEndpoint {

 protected final Log logger = LogFactory.getLog(getClass());
 
    /**
     * The local name of the expected request.
     */
    public static final String PERSON_REQUEST_LOCAL_NAME = "save-persons-request";

    /**
     * The local name of the created response.
     */
    public static final String PERSON_RESPONSE_LOCAL_NAME = "save-persons-response";

    @Autowired
 private PersonEndPointService personEndPointService;

    /**
     * Reads the given requestElement, and sends a the response back.
     *
     * @param requestElement the contents of the SOAP message as DOM elements
     * @return the response element
     */
    @PayloadRoot(localPart = PERSON_REQUEST_LOCAL_NAME, namespace = Constants.NAMESPACE_URI)
    public SavePersonsResponse handleSavePersonsResponseRequest(SavePersonsRequest savePersonsRequest) {
     
  ObjectFactory objFactory = new ObjectFactory();
  SavePersonsResponse savePersonsResponse = objFactory.createSavePersonsResponse();
  personEndPointService.savePersons(savePersonsRequest, savePersonsResponse);
   
        return savePersonsResponse;
    }
    
}

PersonEndPointServiceImpl.java

package com.hoteia.howto.spring.ws.service.impl;

import java.util.Iterator;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.hoteia.howto.spring.domain.Person;
import com.hoteia.howto.spring.service.PersonService;
import com.hoteia.howto.spring.ws.jaxb.pojo.ObjectFactory;
import com.hoteia.howto.spring.ws.jaxb.pojo.Response;
import com.hoteia.howto.spring.ws.jaxb.pojo.SavePersonsRequest;
import com.hoteia.howto.spring.ws.jaxb.pojo.SavePersonsResponse;
import com.hoteia.howto.spring.ws.service.PersonEndPointService;

/**
* Default implementation of PersonEndPointService.
*
*/
public class PersonEndPointServiceImpl implements PersonEndPointService {

protected final Log logger = LogFactory.getLog(getClass());

private PersonService personService;

public void setPersonService(PersonService personService) {
this.personService = personService;
}

public void savePersons(SavePersonsRequest savePersonsRequest, SavePersonsResponse savePersonsResponse) {
try {

for (Iterator<com.hoteia.howto.spring.ws.jaxb.pojo.Person> iterator = savePersonsRequest.getPerson().iterator(); iterator.hasNext();) {
com.hoteia.howto.spring.ws.jaxb.pojo.Person personPojo = (com.hoteia.howto.spring.ws.jaxb.pojo.Person) iterator.next();

Person person = new Person();
if(StringUtils.isNotEmpty(personPojo.getId())){
person = personService.getPersonById(personPojo.getId());
}
person.setLastname(personPojo.getLastname());
person.setFirstname(personPojo.getFirstname());

personService.savePerson(person);

}

ObjectFactory objFactory = new ObjectFactory();
Response response = objFactory.createResponse();
response.setCode("SUCCESS");
response.setMessage("SUCCESS");
response.setStatus("SUCCESS");

savePersonsResponse.setResponse(response);

} catch (Exception e) {
logger.error("Error during the save of the persons", e);

ObjectFactory objFactory = new ObjectFactory();
Response response = objFactory.createResponse();
response.setCode("ERROR");
response.setMessage("ERROR");
response.setStatus("ERROR");

savePersonsResponse.setResponse(response);
}

}
}

PersonClient.java

package com.hoteia.howto.spring.ws.client;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.ws.client.core.support.WebServiceGatewaySupport;

import com.hoteia.howto.spring.ws.jaxb.pojo.SavePersonsRequest;
import com.hoteia.howto.spring.ws.jaxb.pojo.SavePersonsResponse;

public class PersonClient extends WebServiceGatewaySupport {

 protected final Log logger = LogFactory.getLog(PersonClient.class.getName());

    public void savePersons(SavePersonsRequest savePersonsRequest) throws Exception {
        SavePersonsResponse savePersonsResponse = (SavePersonsResponse) getWebServiceTemplate().marshalSendAndReceive(savePersonsRequest);
  
        if(savePersonsResponse.getResponse().getCode().equals("ERROR")){
   logger.error("something is wrong with the person ws response");
  }

    }
}

Nous découpons les contexts Spring en 3 fichiers common, server, client, afin de pouvoir les importer depuis le même jar sans contrainte.

spring-ws-common.xml

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

    <bean id="xsdSchema" class="org.springframework.xml.xsd.SimpleXsdSchema">
        <description>
            This bean definition contains the XSD schema.
        </description>
        <property name="xsd" ref="xsd"/>
    </bean>
 
 <bean id="marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
        <description>
            The JAXB 2 Marshaller is used by the endpoints.
        </description>
  <property name="contextPath" value="com.hoteia.howto.spring.ws.jaxb.pojo"/>
        <property name="schema" ref="xsd"/>
    </bean>
 
    <bean class="org.springframework.ws.server.endpoint.adapter.GenericMarshallingMethodEndpointAdapter">
        <description>
            This adapter allows for methods that need and returns marshalled objects. The MarshallingEndpoint
            uses JAXB 2 objects.
        </description>
        <constructor-arg ref="marshaller"/>
    </bean>

 <bean id="xsd" class="java.lang.String">
     <constructor-arg type="String" value="classpath:/person.xsd"/>
    </bean>
</beans>

spring-ws-server.xml

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

    <description>
        This web application context contains Spring-WS beans. The beans defined in this context are automatically
        detected by Spring-WS, similar to the way Controllers are picked up in Spring Web MVC.
    </description>

    <import resource="spring-ws-common.xml" />
 
    <bean id="personEndPointService" class="com.hoteia.howto.spring.ws.service.impl.PersonEndPointServiceImpl">
        <description>
            This bean is the person service.
        </description>
        <property name="personService" ref="personService"/>
    </bean>
 
    <bean id="payloadMapping" class="org.springframework.ws.server.endpoint.mapping.PayloadRootAnnotationMethodEndpointMapping">
        <description>
            This endpoint mapping uses the qualified name of the payload (body contents) to determine the endpoint for
            an incoming message. Every message is passed to the default endpoint. Additionally, messages are logged
            using the logging interceptor.
        </description>
        <property name="interceptors">
            <list>
                <ref local="validatingInterceptor"/>
                <ref local="loggingInterceptor"/>
            </list>
        </property>
    </bean>

    <bean id="validatingInterceptor"
          class="org.springframework.ws.soap.server.endpoint.interceptor.PayloadValidatingInterceptor">
        <description>
            This interceptor validates both incoming and outgoing message contents according to the 'person.xsd' XML
            Schema file.
        </description>
        <property name="xsdSchema" ref="xsdSchema"/>
        <property name="validateRequest" value="true"/>
        <property name="validateResponse" value="true"/>
    </bean>

    <bean class="org.springframework.ws.server.endpoint.adapter.DefaultMethodEndpointAdapter"/>

    <bean id="loggingInterceptor" class="org.springframework.ws.server.endpoint.interceptor.PayloadLoggingInterceptor">
        <description>
            This interceptor logs the message payload.
        </description>
    </bean>

    <bean id="person" class="org.springframework.ws.wsdl.wsdl11.DefaultWsdl11Definition">
        <description>
            This bean definition represents a WSDL definition that is generated at runtime. It can be retrieved by
            going to http://localhost:8280/ws-in/ws/services/person/person.wsdl (i.e. the bean name corresponds to the filename).
        </description>
        <property name="schema" ref="xsdSchema"/>
        <property name="portTypeName" value="Person"/>
        <property name="locationUri" value="http://localhost:8280/ws-in/ws/services/person"/>
        <property name="targetNamespace" value="http://localhost:8280/ws-in/ws/services/person/schemas"/>
    </bean>
 


</beans>

spring-ws-client.xml

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

    <import resource="spring-ws-common.xml" />

    <bean id="personClient" class="com.hoteia.howto.spring.ws.client.PersonClient">
        <property name="defaultUri" value="http://localhost:8280/ws-in/ws/services/person"/>
        <property name="marshaller" ref="marshaller"/>
        <property name="unmarshaller" ref="marshaller"/>
    </bean>

</beans>

Références

Jaxb

Spring 2.0

Mise en place d'un front pour la sortie (envoi) Webservice

Nous utiliserons uniquement un controleur pour constuire n "Persons", et les envoyer via le webservice distant.

PersonController.java

package com.hoteia.howto.spring.mvc.controller;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import com.hoteia.howto.spring.ws.client.PersonClient;
import com.hoteia.howto.spring.ws.jaxb.pojo.ObjectFactory;
import com.hoteia.howto.spring.ws.jaxb.pojo.Person;
import com.hoteia.howto.spring.ws.jaxb.pojo.SavePersonsRequest;

@Controller
@RequestMapping("/sendPersons")
public class PersonController {

 protected final Log logger = LogFactory.getLog(getClass());

 @Autowired
 private PersonClient personClient;
 
 @RequestMapping(method = RequestMethod.GET)
 public ModelAndView parse(){
  if(logger.isDebugEnabled()){
   logger.debug("sendPersons");
  }
  
  try {
   ObjectFactory objFactory = new ObjectFactory();
   
   SavePersonsRequest savePersonsRequest = objFactory.createSavePersonsRequest();
   
   Map<String, Person> persons = buildPersonDetails();

   int poolSize = 50;
   int count = 1;
         for (Iterator<Person> iterator = persons.values().iterator(); iterator.hasNext();) {

          Person person = (Person) iterator.next();
    savePersonsRequest.getPerson().add(person);

    if(count == poolSize
      || count == persons.size()){
     personClient.savePersons(savePersonsRequest);
     savePersonsRequest = objFactory.createSavePersonsRequest();
     count = 1;
    }

    count++;
    
         }
   
  } catch (Exception e) {
   logger.error("Error on the parse controller", e);
  }

  ModelAndView model = new ModelAndView("sendPersons-view");
 
  return model;
 }
 
 private Map<String, Person> buildPersonDetails(){
  if(logger.isDebugEnabled()){
   logger.debug("start to build person Map");
  }

  Map<String, Person> persons = new HashMap<String, Person>();
  
  Person person = new Person();
  person.setId("");
  person.setLastname("Bar");
  person.setFirstname("Foo");
  persons.put(person.getLastname() + "-" + person.getFirstname(), person);
  
  if(logger.isDebugEnabled()){
   logger.debug("stop to build person Map");
  }
  
  return persons;
 }
}

dispatcher-servlet.xml

<?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:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="
  http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">

 <!-- Scans the classpath of this application for @Components to deploy as beans -->
 <context:component-scan base-package="com.hoteia.howto.spring.mvc" />

 <!-- Application Message Bundle -->
 <bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
  <property name="basename" value="/WEB-INF/classes/ApplicationResources" />
  <property name="cacheSeconds" value="0" />
 </bean>

 <!-- Configures Spring WS Client -->
 <import resource="classpath*:spring-ws-client.xml" />

 <!-- Configures Spring MVC -->
 <import resource="mvc-config.xml" />

</beans>

mvc-config.xml

<?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:mvc="http://www.springframework.org/schema/mvc"
 xsi:schemaLocation="
  http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

 <!-- Configures the @Controller programming model -->
 <mvc:annotation-driven />

 <!-- Forwards requests to the "/" resource to the "welcome" view -->
 <mvc:view-controller path="/" view-name="welcome"/>

 <!-- Configures Handler Interceptors --> 
 <mvc:interceptors>
  <!-- Changes the locale when a 'locale' request parameter is sent; e.g. /?locale=de -->
  <bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor" />
 </mvc:interceptors>

 <!-- Saves a locale change using a cookie -->
 <bean id="localeResolver" class="org.springframework.web.servlet.i18n.CookieLocaleResolver" />

 <!-- Resolves view names to protected .jsp resources within the /WEB-INF/views directory -->
 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  <property name="prefix" value="/WEB-INF/views/"/>
  <property name="suffix" value=".jsp"/>
 </bean>

</beans>

Références

Spring Source

Mise en place d'un front pour l'entrée (réception) Webservice

dispatcher-servlet.xml

<?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:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="
  http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">

 <!-- Scans the classpath of this application for @Components to deploy as beans -->
 <context:component-scan base-package="com.hoteia.howto.spring.mvc" />
 
 <!-- Configures Spring MVC -->
 <import resource="mvc-config.xml" />
 
 <!-- Application Message Bundle -->
 <bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
  <property name="basename" value="/WEB-INF/classes/ApplicationResources" />
  <property name="cacheSeconds" value="0" />
 </bean>

</beans>

mvc-config.xml

<?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:mvc="http://www.springframework.org/schema/mvc"
 xsi:schemaLocation="
  http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

 <!-- Configures the @Controller programming model -->
 <mvc:annotation-driven />

 <!-- Forwards requests to the "/" resource to the "welcome" view -->
 <mvc:view-controller path="/" view-name="welcome"/>

 <!-- Configures Handler Interceptors --> 
 <mvc:interceptors>
  <!-- Changes the locale when a 'locale' request parameter is sent; e.g. /?locale=de -->
  <bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor" />
 </mvc:interceptors>

 <!-- Saves a locale change using a cookie -->
 <bean id="localeResolver" class="org.springframework.web.servlet.i18n.CookieLocaleResolver" />

 <!-- Resolves view names to protected .jsp resources within the /WEB-INF/views directory -->
 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  <property name="prefix" value="/WEB-INF/views/"/>
  <property name="suffix" value=".jsp"/>
 </bean>

</beans>

db-config.xml

<?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:p="http://www.springframework.org/schema/p"
     xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
     ">

 <context:component-scan base-package="com.hoteia.howto"/>
  
 <!-- Configures Spring WS Server -->
 <import resource="classpath*:spring-ws-server.xml" />

    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource">
            <ref bean="dataSource" />
        </property>
        <property name="packagesToScan" value="com.hoteia.howto.spring.domain" />
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.hbm2ddl.auto">create</prop>
                <prop key="hibernate.show_sql">false</prop>
            </props>
        </property>
    </bean>

    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory">
            <ref bean="sessionFactory" />
        </property>
    </bean>
 
    <bean id="propertyConfigurer"
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:jdbc.properties</value>
            </list>
        </property>
    </bean>
 
 <!-- JNDI DataSource for J2EE environments -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="maxActive" value="100"/>
        <property name="maxWait" value="1000"/>
        <property name="poolPreparedStatements" value="true"/>
        <property name="defaultAutoCommit" value="true"/>
    </bean>
 
</beans>

Références

Spring Source

Git over https by Apache 2 & Apache Directory (Ubuntu)

2010-12-04T20:04:00.003+01:00

Français

Pré-requis

Pour ce tutorial, nous travaillons avec une version d'Ubuntu 10.10 server, JDK 1.6.0_22.
Nous commencerons par installer Apache Directory, Git et Apache 2.

Apache Directory

Download d'Apache Directory 1.5.X depuis http://directory.apache.org/apacheds/1.5/download/download-linux-bin.html.

1) cd /opt
2) mkdir dl
3) cd dl
4) wget http://mirror.ibcp.fr/pub/apache//directory/apacheds/unstable/1.5/1.5.7/apacheds-1.5.7-x86_64.bin
5) chmod a+x apacheds-1.5.7-x86_64.bin
6) ./apacheds-1.5.7-x86_64.bin

Where do you want to install Apache DS? [Default: /opt/apacheds-1.5.7]
we have keep the default folder
Where do you want to install Apache DS instances? [Default: /var/lib/apacheds-1.5.7]
we have keep the default folder
What name do you want for the default instance? [Default: default]
we have use the name of the company
Where do you want to install the startup script? [Default: /etc/init.d]
we have keep the default folder
Which user do you want to run the server with (if not already existing, the specified user will be created)? [Default: apacheds]
we have keep the default name

Rapel des commandes :

/etc/init.d/apacheds-1.5.7-company-name start
/etc/init.d/apacheds-1.5.7-company-name restart
/etc/init.d/apacheds-1.5.7-company-name stop

Pour manipuler la configuration et l'utilisation de votre server LDAP Apache Directory, il est fortement conseillé d'utiliser Apache Directory Studio :
http://directory.apache.org/studio/

Votre LDAP étant probablement ouvert sur le net, pensez à changer le mot de passe par défaut qui est :

uid=admin,ou=system

password=secret

Références Apache Directory

Change the admin password

Create a user

Git

Installation rapide de Git.

sudo apt-get install git-core gitweb

- The git repository will be here : /var/cache/git

Création du repository avec le nom que vous souhaitez.

cd /var/cache/git
mkdir your-company.git
cd your-company.git

Nous changerons les droits plus tard pour le user d'Apache.

Création du repository avec le nom que vous souhaitez.

cd /var/cache/git/your-company.git
git init
créer un lien sympolique si besoin

Testons rapidement la connexion depuis Eclipse et son plugin (qui ATTENTION ne fonctionnera pas en http/https avec la version testée).

Check http://www.eclipse.org/egit/

ssh://git@your-ip-or-domain/your-repository-path

On observe :

Branches

Tags

Symbolic References

Remotes

Working directory (branch master)

Références Git

http://progit.org/book/
http://www.eclipse.org/resources/resource.php?id=528

Apache 2

Dernière étape :)

sudo apt-get install apache2
cd /etc/apache2/
a2enmod ssl
a2enmod authnz_ldap

Les commandes habituelles pour mémoire :

/etc/init.d/apache2 start
/etc/init.d/apache2 restart
/etc/init.d/apache2 stop

Création de votre fichier de conf VirtualHost :

nano /etc/apache2/sites-available/yourcompany-ssl

Exemple de configuration :

SetEnv GIT_PROJECT_ROOT /var/cache/git
SetEnv GIT_HTTP_EXPORT_ALL

NameVirtualHost git.yourdomain.com:443

<VirtualHost git.yourdomain.com:443>
    DocumentRoot /var/cache/git
    ServerName git.yourdomain.com
    ErrorLog /var/log/apache2/git.error.log
    LogLevel warn
    CustomLog /var/log/apache2/git.access.log combined
    ServerSignature On
    Options Indexes FollowSymLinks MultiViews
    SSLEngine On
    SSLOptions +FakeBasicAuth +ExportCertData +StrictRequire
    SSLCertificateFile /etc/ssl/certs/yourdomain.crt
    SSLCertificateKeyFile /etc/ssl/private/yourdomain.key

    ScriptAlias / /usr/lib64/git-core/git-http-backend/

    <Location "/">
        AuthBasicProvider ldap
        AuthType Basic
        AuthzLDAPAuthoritative on
        AuthName "Git server"
        AuthLDAPURL "ldap://ldap.yourdomain.com:10389/ou=users,ou=system" NONE
        AuthLDAPBindDN "uid=yourUserGitName,ou=users,ou=system"
        AuthLDAPBindPassword yourUserPassword
        require valid-user
        Order deny,allow
    </Location>

</VirtualHost>

Attention, si comme nous, vous travaillez avec des changements de configuration sur votre nom de domaine, il peut être utile de modifier votre host.

Check if your address is up

ERROR : (EAI 2)Name or service not known: Could not resolve host name

nano /etc/hosts
add the line
91.121.143.131 git.your-domain.com

Activer votre configuration et donnez les droits à Apache pour qu'il puisse par la suite manipuler le repository.

cd /etc/apache2/
a2ensite yourcompany-ssl
chown -R www-data.www-data /var/cache/git/

Création de vos certificat/clé.

cd /etc/ssl/private/
openssl genrsa -out your-company.key 1024

cd /etc/ssl/certs/
openssl req -new -key ../private/your-company.key -out your-company.csr
openssl x509 -req -days 365 -in your-company.csr -signkey ../private/your-company.key -out your-company.crt

Redémarrer ou recharger votre server SSH.
Rapel des commandes :

sudo /etc/init.d/ssh reload

sudo /etc/init.d/ssh restart

sudo /etc/init.d/ssh start

sudo /etc/init.d/ssh stop

Références Apache & Git

http://blog.courtine.org/2010/11/19/git-et-ldap-en-entreprise/

http://www.jeremyskinner.co.uk/2010/07/31/hosting-a-git-server-under-apache-on-windows/

Fin de la configuration entre Git et Apache

Vous aller maintenant pouvoir récuperer votre projet depuis votre server git via https.

Votre URL pour manipuler Git sera de la forme :

https://yourUserGitName:yourUserPassword@git.your-domain.com/your-git-repository/

Pour simplifier les choses, désactivons la verification SSL.

git config --global http.sslverify "false"

Récupération du projet depuis votre repo en ligne. Cette commande va créer un projet du même nom que votre repo (sans le .git).

git clone https://yourUserGitName:yourUserPassword:@git.your-domain.com/your-git-repository/

Depuis Eclipse, importer ce projet comme projet Java, ou créer un projet Java pointant sur ce projet checkouté.
La version d'Egit 0.9.3 ne m'a pas permis de travailler en http ou https.

Commance ici, l'utilisation de Git en mode commande. On vous laisse découvrir la doc ou d'autres blogs traitant du sujet.
Vous pouvez déjà créer dans votre nouveau projet un fichier text pour vérifier que votre server Apache possède les droits afin de manipuler le repository Git.

git add your-test-file
git commit
you had just commit on your local repository, so now you will push to your remote project on the git server
git push

Here we are...

2010-11-30T17:48:00.005+01:00

Français
English

Comme beaucoup d'experts JEE et de passionnés de technologies, à notre tour, nous allons partager avec vous notre quotidien, nos réactions, nos conseils, nos tutoriaux.

à suivre...

As many experts and enthusiasts JEE technologies in our turn, we will share with you our lives, our reactions, our advices, our tutorials.

To be continued...