Blog Archives

org.glassfish.embeddable.GlassFishException: PlainTextActionReporterFAILURENo configuration found for server.network-config.network-listeners.network-listener.http-listener

Overview

When I upgrade the Glassfish Server to be a version 3.1.2 from  here, the Glassfish Embedded Server should be upgraded as well. Anyhow when I perform the unit test, it is failed as

org.glassfish.embeddable.GlassFishException: PlainTextActionReporterFAILURENo configuration found for server.network-config.network-listeners.network-listener.http-listener

Investigation

I’ve put the whole exception mentioned above to sear via Google and found the useful information at Glassfish Jira issue #18452 . They mention about the configuration at the domain.xml is not completed. I’ve been noticed that the Glassfish Embeded Server has some limitation about the HTTP listener port and need to be applied the additional configuration as it is mentioned here.

The Root Cause

The root cause is I’ve configured the HTTP port explicitly as

props.put("org.glassfish.ejb.embedded.glassfish.web.http.port", 14080);
ejbContainer = EJBContainer.createEJBContainer(props);

The Solution

It is a very easy step by removing the explicitly configured HTTP port. Anyhow, the domain.xml should be configured for all related ports properly. We can download the starter domain.xml from here and start configure all related ports and/or further jdbc/datasource resources as well.

 

Java GUI implementation with Eclipse SWT, Eclipse Visual Editor Project and Maven: Part 3

Overview

This post will introduce you the end-to-end development with the Maven by using the very simple traditional, the Hello World ! So that you may apply to your own requirement.

The SWT Hello World !

Firstly we need the empty Maven project. All required dependency artifacts which have been mentioned at the previous post should be set at the project POM file as well.

After that we will create the SWT: Shell Visual Class at which you will see File –> New –> Other — > Java –> SWT –> Shell Visual Class. Here is the simple Hello World source which is generated by the visual editor. Please note, it is not a time to make a source code to be beautiful. We just need to see only the big picture.

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

public class HelloWorldSWT {

    private Shell sShell = null;
    private Text textName = null;
    private Label labelMessage = null;
    private Button buttonSubmit = null;
    private Button buttonCancel = null;
    private Label labelName = null;

    /**
     * This method initializes sShell
     */
    private void createSShell() {
        final GridData gridData = new GridData();
        gridData.horizontalSpan = 2;
        final GridLayout gridLayout = new GridLayout();
        gridLayout.numColumns = 2;
        this.sShell = new Shell();
        this.sShell.setText("Shell");
        this.sShell.setLayout(gridLayout);
        this.sShell.setSize(new Point(300, 200));
        this.labelName = new Label(this.sShell, SWT.NONE);
        this.labelName.setText("Name:");
        this.textName = new Text(this.sShell, SWT.BORDER);
        this.labelMessage = new Label(this.sShell, SWT.NONE);
        this.labelMessage.setText("I'm waiting for you.");
        this.labelMessage.setLayoutData(gridData);
        this.buttonSubmit = new Button(this.sShell, SWT.NONE);
        this.buttonSubmit.setText("Submit");
        this.buttonSubmit.addMouseListener(
                new org.eclipse.swt.events.MouseAdapter() {
                    static final String MESSAGE = "Hello ";
                    @Override
                    public void mouseDown(
                            final org.eclipse.swt.events.MouseEvent e) {
                        final String name = HelloWorldSWT.this.textName.getText();
                        HelloWorldSWT.this.labelMessage.setText(MESSAGE + name);
                    }
                });
        this.buttonCancel = new Button(this.sShell, SWT.NONE);
        this.buttonCancel.setText("Cancel");

        this.buttonCancel.addMouseListener(
            new org.eclipse.swt.events.MouseAdapter() {
                @Override
                public void mouseDown(
                        final org.eclipse.swt.events.MouseEvent e) {
                    HelloWorldSWT.this.labelMessage.setText("");
                    HelloWorldSWT.this.textName.setText("");
                }
            });

        Display display = null;
        display = Display.getDefault();
        this.sShell.pack();
        this.sShell.open();
        while (!this.sShell.isDisposed()) {
            if (!display.readAndDispatch()) {
                display.sleep();
            }
        }
        display.dispose();
    }

    public static void main(final String[] args) {
        final HelloWorldSWT main = new HelloWorldSWT();
        main.createSShell();
    }
}

The Unit Testing with SWTBot

Normally, we should test all possible scenarios such as the following:-

Table 1: Test case scenario

# Scenario Expected Result
1 When the user enter the name and click submit. The label should displays “Hello <NAME>”.
2 When the user enter the name as an empty String

and click submit.

The label should displays “Hello ”. (There is a space.)
3 When the user enter the name and click cancel. The text and label should be cleared.
Etc. Etc.

I will show you only one case, the case #1. It just create a simple JUnit4 class and put the SWTBot related statements as the following: -

import junit.framework.Assert;

import org.apache.log4j.Logger;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.finders.ControlFinder;
import org.eclipse.swtbot.swt.finder.finders.MenuFinder;
import org.eclipse.swtbot.swt.finder.utils.SWTUtils;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotLabel;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotText;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import com.scc.biometric.poc.mock.swt.HelloWorldSWT;

public class HelloWorldSWTTest {
    private static final Logger LOGGER;
    static {
        LOGGER = Logger.getLogger(HelloWorldSWTTest.class);
    }

    private SWTBot bot;

    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
    }

    @AfterClass
    public static void tearDownAfterClass() throws Exception {
    }

    @Before
    public void setUp() throws Exception {
        this.initSWTApplication();
    }

    @After
    public void tearDown() throws Exception {

    }

    static {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    HelloWorldSWT.main(new String[] {});
                } catch (final Exception e) {
                    HelloWorldSWTTest.
                       LOGGER.
                          fatal("Cannot instantiate the Hello.", e);
                }
            }
        }).start();
    }

    @Test
    public void whenSay() {
        this.say("Charlee");
    }

    private void initSWTApplication() {
        this.waitForDisplayToAppear(5000);
        this.initSWTBot();
    }

    private void waitForDisplayToAppear(final long time) {
        long    endTime = -1;
        Display display = null;
        try {
            endTime = System.currentTimeMillis() + time;
            while (System.currentTimeMillis() < endTime) { // wait until timeout
                try {
                    display = SWTUtils.display();
                    if (display != null) {
                        HelloWorldSWTTest.LOGGER.info("The display is found.");
                        return;
                    }
                } catch (final Exception e) {
                    HelloWorldSWTTest.
                       LOGGER.
                          warn("Cannot find display, keep waiting.");
                }
                try {
                    Thread.sleep(100);
                } catch (final InterruptedException e) {
                    HelloWorldSWTTest.LOGGER.warn("The thread is interrupted", e);
                } // sleep for a while and try again
            }
        } finally {
            display = null;
        }
    }

    private void initSWTBot() {
        ControlFinder cf = null;
        MenuFinder    mf = null;
        try {
            cf       = new ControlFinder();
            mf       = new MenuFinder();
            this.bot = new SWTBot(cf, mf);
        } finally {
            cf = null;
            mf = null;
        }
    }

    private void say(final String name) {
        SWTBotLabel  swtBotLabel  = null;
        SWTBotButton swtBotButton = null;
        SWTBotText   swtBotText   = null;
        String       saidMessage  = null;
        try {
            swtBotText   = this.bot.
                              textWithLabel("Name:");
            Assert.assertNotNull("Cannot find the textName.", swtBotText);
            swtBotText.setText(name);

            swtBotButton = this.bot.button("Submit");
            Assert.assertNotNull("Cannot find the buttonSubmit.", swtBotButton);
            swtBotButton.click();

            saidMessage  = "Hello ";

            if (name != null) {
                saidMessage += name;
            } else {
                saidMessage += "null";
            }


            swtBotLabel  = this.bot.label(saidMessage);

            Assert.assertNotNull("Cannot find the said lable.", swtBotLabel);


        } catch (final Exception e) {
            HelloWorldSWTTest.LOGGER.fatal("This is an unexpected error", e);
            throw new RuntimeException(e);
        } finally {
            swtBotLabel  = null;
            swtBotButton = null;
            swtBotText   = null;
        }
    }
}

Test It !!!

There are 2 way for performing the testing, first is either via the JUnit within the Eclipse IDE or via the command line as “mvn test”.

Summary

We have created the big picture, end-to-end classic traditional Hello World SWT application, including with the unit testing with SWTBot inside the Maven environment. The next step is fulfilling the test case so that it covers all the possible scenarios as a good practice.

Since we always be the Maven, then our application can be expanded to the other infrastructure more simply and easily. e.g Maven report, Maven Site, Code quality, Code Coverage, Continuous Integration server and so on. Most of them not only support the Maven project and but also provide120% compatible and cross platform.

Please take note, I’m on the Windows x86 Vista and develop the Maven project. My infrastructure is on the Linux: CentOS x86_64. The CI Server can build and perform the unit testing successfully. I have achieved the cross platform already.

Java GUI implementation with Eclipse SWT, Eclipse Visual Editor Project and Maven: Part 2

Overview

Regarding to my previous post, There are three required artifacts which should be installed before we move further, i.e. The Eclipse Visual Editor, The Eclipse SWT runtime and the Eclipse SWTBot. After we have finished installing, then we should deploy the required dependency artifacts to the local repository or the local repository manager, since there is no any internet Maven repository which provides the latest version.

Please note, the assumption is we already have an Eclipse, including Maven and other related artifacts, including with the system software. Anyhow all of them has been posted at my blog as well, you may refer to the series of Java Development with NetBeans and Maven. Please do not worry, since we are in the Maven world, the tools / IDE does not the issue. It is transparent so that you can build them without the IDE, via the command line. It’s a strongest point. I’m loving it.

The Required Artifacts

The Eclipse Visual Editor

Installation

It can be installed remotely via the Eclipse update site or offline via the All-In-One Update Site. Please note, I’ve face some difficult due the remotely and only achieve via the offline installation.

Even the required artifacts has been installed at your ECLIPSE_HOME, it is only for your platform. For me, I’m at a Windows, then there is only a WIN32-x86 runtime.

The Eclipse Standard Widget Toolkit (SWT) Runtime

Overview

As we have known, there is an OS dependency for the GUI development so that we need to have a specific and correct runtime for each platform. The Eclipse SWT provides us the runtime for every OS already.

Installation

You can download them here. You may choose only your decided platform, But I have downloaded all of them.

Deploy the dependency to the Maven

After you have finished installing, you should extract the downloaded artifact and deploy the swt.jar to your local repository or local repository manager. As you have known, I prefer the local repository manager, the Artifactory. Please note, you may deploy the source code for further reference as the src.jar.

The Eclipse SWTBot

Installation

You can install them remotely via the Eclipse Update Site. It is a platform independent artifacts.

Deploy the dependency to the Maven

After you have finished installing, the required artifact also have been installed at your ECLIPSE_HOME. You can search them by using the wildcard as “*swtbot*.jar” and deploy them to the Maven repository. The artifacts is as following: -

Table 1: The SWTBot Runtime

# Artifact
1 org.eclipse.swtbot.ant.optional.junit3_2.0.4.20110304_0338-e5aff47-dev-e36.jar
2 org.eclipse.swtbot.ant.optional.junit4_2.0.4.20110304_0338-e5aff47-dev-e36.jar
3 org.eclipse.swtbot.eclipse.core_2.0.4.20110304_0338-e5aff47-dev-e36.jar
4 org.eclipse.swtbot.eclipse.finder_2.0.4.20110304_0338-e5aff47-dev-e36.jar
5 org.eclipse.swtbot.eclipse.gef.finder_2.0.4.20110304_0338-e5aff47-dev-e36.jar
6 org.eclipse.swtbot.eclipse.spy_2.0.4.20110304_0338-e5aff47-dev-e36.jar
7 org.eclipse.swtbot.eclipse.ui_2.0.4.20110304_0338-e5aff47-dev-e36.jar
8 org.eclipse.swtbot.forms.finder_2.0.4.20110304_0338-e5aff47-dev-e36.jar
9 org.eclipse.swtbot.go_2.0.4.20110304_0338-e5aff47-dev-e36.jar
10 org.eclipse.swtbot.junit4_x_2.0.4.20110304_0338-e5aff47-dev-e36.jar
11 org.eclipse.swtbot.swt.finder_2.0.4.20110304_0338-e5aff47-dev-e36.jar

Summary

At the moment we already have all required artifact and ready to start the development.

The next post we will see the big picture, end-to-end development with Maven. Please stay tuned as always.

Java Development with NetBeans and Maven: Part 5

Overview

I hope we are well prepared for moving further to the very powerful “Maven” features, which we have known before, the “site”, especially the “report” integration to the outer world. There are many powerful “Maven Plug-in” provided by the “Maven” itself. You can see further information here. From now on, I will introduce you the “Reporting Plug-ins”.

The Report Plug-ins

Regarding the “Maven Plug-inhere, you may be noticed that there are two plug in which we used before. Guess what? The “project-info-reports”, the “mvn site” command itself and the “surefire-report”, the testing report for our previous JUnit. You already know how easy it is. The rest plug in also be same for sure. One picture can give us a thousand words. Here is my tested template “Project POM File” (pom.xml). Please feel free to modify it so that it is fit for your environment.


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.scc.maven.java</groupId>
    <artifactId>MavenJavaPrj01</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>MavenJavaPrj01</name>
    <url>The Project web site URL</url>
    <description>The SDLC Learning</description>

    <licenses>
        <license>
            <name>Apache 2</name>
            <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
            <distribution>repo</distribution>
            <comments>A business-friendly OSS license</comments>
        </license>
    </licenses>

    <organization>
        <name>The Organization Name</name>
        <url>The Organization web site URL</url>
    </organization>

    <developers>
        <developer>
            <id>The developer id</id>
            <name>The developer name</name>
            <email>The developer email</email>
            <url>The developer web site URL</url>
            <organization>The developer organization</organization>
            <organizationUrl>The organization web site url</organizationUrl>
            <roles>
                <role>Role #1</role>
                <role>Role #2</role>
            </roles>
            <timezone>+7</timezone>
            <properties>
                <picUrl>The developer picture URL</picUrl>
            </properties>
        </developer>
    </developers>

    <issueManagement>
        <system>The issue management system, e.g. Bugzilla, TestTrack, ClearQuest, etc</system>
        <url>The issue management system web site URL</url>
    </issueManagement>

    <ciManagement>
        <system>The CI management system, e.g. Hudson,continuum, etc</system>
        <url>The CI web site URL</url>
        <notifiers>
            <notifier>
                <type>mail</type>
                <sendOnError>true</sendOnError>
                <sendOnFailure>true</sendOnFailure>
                <sendOnSuccess>false</sendOnSuccess>
                <sendOnWarning>false</sendOnWarning>
                <configuration>
                    <address>The sender email address</address>
                </configuration>
            </notifier>
        </notifiers>
    </ciManagement>

    <scm>
        <connection>scm:svn:Path/To/Repository</connection>
        <developerConnection>scm:svn:Path/To/Repository</developerConnection>
        <tag>HEAD</tag>
        <url>The SCM web site URL</url>
    </scm>

    <prerequisites>
        <maven>2.2.1</maven>
    </prerequisites>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.0.2</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <encoding>${project.build.sourceEncoding}</encoding>
                    <includes>
                        <include>
                            **/*TestSuite*.java
                        </include>
                    </includes>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-site-plugin</artifactId>
                <version>2.1.1</version>
                <configuration>
                    <locales>en</locales>
                </configuration>
            </plugin>
        </plugins>
        <resources>
            <resource>
                <directory>${basedir}/src/main/java</directory>
                <includes>
                    <include>log4j.dtd</include>
                    <include>log4j.xml</include>
                </includes>
            </resource>
        </resources>
    </build>
    <reporting>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-project-info-reports-plugin</artifactId>
                <version>2.2</version>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-report-plugin</artifactId>
                <version>2.6</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-changelog-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <username>${svnUser}</username>
                    <password>${svnPassword}</password>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-checkstyle-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <configLocation>config/sun_checks.xml</configLocation>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-javadoc-plugin</artifactId>
                <version>2.7</version>
                <configuration>
                    <stylesheetfile>${basedir}/src/main/javadoc/stylesheet.css</stylesheetfile>
                    <show>private</show>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jxr-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <linkXref>true</linkXref>
                    <sourceEncoding>utf-8</sourceEncoding>
                    <minimumTokens>100</minimumTokens>
                    <targetJdk>1.5</targetJdk>
                    <excludes>
                        <exclude>**/*Bean.java</exclude>
                        <exclude>**/generated/*.java</exclude>
                    </excludes>
                    <excludeRoots>
                        <excludeRoot>target/generated-sources/stubs</excludeRoot>
                    </excludeRoots>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-pmd-plugin</artifactId>
                <version>2.5</version>
            </plugin>

        </plugins>
    </reporting>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.8.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.16</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
</project>

How the report is created.

It is simple by using the “mvn site” command, please refer to my previous post.

Are there any outer world plug in?

Yes, sure. Why not? Maven also mentioned in their plug in page as well. Please travel to the lower part of that page you will see the outer world for sure. I hope we are enjoy traveling.

Summary

We have finished preparing our development environment so that we can ensure that there should not be any surprise during the integration with the very powerful “Maven” features, the “site”, especially the “report”. As I’ve mentioned, This is a final article for my first series.

The well preparing will help us to reduce the defect, on the other hand, if the defect is less, the working time is less, too. That mean we will have more time to do other things in my life. For me is writing this blog. Next I will move further to the detailed “Java/JavaEE” development with “Maven” and will do my best to post for sure. Please stay tuned as always.

Java Development with NetBeans and Maven: Part 4

Overview

We have configured our environment so that we can declare our own information outside the “Project POM File” (pom.xml) such as the “Subversion” user id and password, the “Issue Tracker” user id and password. But it is only the “Maven” universe. We live in the bigger one, the integration universe. That means we need to know the other integrated system universe. Even we configure our credential / personal information with purpose to let “Maven” to use them when it connect to each sever. It is just our credential / personal information. Since “Maven” acts as a client, it should provide credential / personal information itself, too. Normally these communication is done via the “SSL”, especially via the “HTTPS”. There are some good practice to which I would like share.

The HTTPS Good Practice For The Client

Most of integration universe has been configured and deployed under the “Apache HTTP” umbrella. As I’ve mentioned before, the “HTTPS” is preferred. This means the “Maven” will connect to them via the “HTTPS”, too. The “Maven” acts as a client, they act as a server for sure. What is the issues? Well, It is a very well known issue.

The Certificate Management For The Client

Normally the server provides its “certificate” to the client for initiating the “SSL” connection. The client will determine if this “certificate” can be trusted. If yes, the conversation will be initiated.

If not the connection will be dropped. We may face a trouble like we cannot connect to server system shows me something about “no trusted certificate found” or other close to this.

The HTTPS Client Configuration Good Practice

I am informing you about the good practice for the client side who would like to connect to the server via “HTTPS”. If the client is a “Java” environment, the “Server Certificate” should be injected to the “truststore”.

The “Server Certificate” is not only limited to the server certificate itself, but also the “Signer Certificate”, too. Please note the “Signer Certificate” is a certificate of the trusted authority who sign the “Server Certificate”. The signer also not be limited at one level, it can be more. It is called “Certificate Chain”. During the checking & verifying If any of “Certificate” inside this “Certificate Chain” is trusted, It will be determined as trusted. This means if we have 3 levels “Certificate Chain”.

The checking step is as following: -

  1. If the level 3rd is trusted, it is determined as trusted. The checking stop here.
  2. If the level 2nd is trusted, it is determined as trusted. The checking stop here.
  3. If the level 1st is trusted, it is determined as trusted. If not the system may show us as “no trusted certificate found”.

For me, I have 2 levels which are created by the “openssl”. Anyhow it can be a 1 level as a self-signed as well.

By default the “truststore” is as following:-

Table 1: The default truststore for JRE

Default Trustsore for JRE

 

<JRE_HOME>/lib/security/cacerts

 

Example: C:/Java.Application/Sun/Java/jre1.6.0_21/lib/security/cacerts

Table 2: The default truststore for JDK

Default Trustsore for JDK

 

<JDK_HOME>/jre/lib/security/cacerts

 

Example: C:/Java.Application/Sun/Java/jdk1.6.0_21/jre/lib/security/cacerts

The injecting certificate command is as following: -

Table 3: The injecting certificate command

The injecting certificate command

 

keytool -importcert -trustcacerts -alias <MY_ALIAS> -file <Certificate> -keystore <Truststore>

 

Example: keytool -importcert -trustcacerts -alias myserver -file server.cer -keystore cacerts

Please note: you may be prompted to enter the password, the default password is changeit”.

Some of them are not default.

Some of them may have their own configuration environment instead, especially the “Subversion Client”. There are 2 types as global for whole client and per-user.

The server-wide

Unix:

/etc/subversion/servers

/etc/subversion/config

/etc/subversion/hairstyles

Windows:

%ALLUSERSPROFILE%\Application Data\Subversion\servers

%ALLUSERSPROFILE%\Application Data\Subversion\config

%ALLUSERSPROFILE%\Application Data\Subversion\hairstyles

REGISTRY:HKLM\Software\Tigris.org\Subversion\Servers

REGISTRY:HKLM\Software\Tigris.org\Subversion\Config

REGISTRY:HKLM\Software\Tigris.org\Subversion\Hairstyles

The per-user

Unix:

~/.subversion/servers

~/.subversion/config

~/.subversion/hairstyles

Windows:

%APPDATA%\Subversion\servers

%APPDATA%\Subversion\config

%APPDATA%\Subversion\hairstyles

REGISTRY:HKCU\Software\Tigris.org\Subversion\Servers

REGISTRY:HKCU\Software\Tigris.org\Subversion\Config

REGISTRY:HKCU\Software\Tigris.org\Subversion\Hairstyles

I prefer to use the per-user instead. Please note, I’m a “Windows Vista”, my configuration home for “Subversion Client” is “C:\Users\Charlee.Ch\AppData\Roaming\Subversion”. Normally the per-user configuration is created automatically by the “Subversion Client”. If the “Subversion Client” does not trust the “Server Certificate”, you may face the message like this, “Server certificate verification failed: issuer is not trusted”. It can be configured easily by using the “Subversion Client” command via a command line, for me it is a dos prompt, as the following:

Table 4: Configure subversion client to trust the server certificate

Configure subversion client to trust the server certificate

 

svn list https://<YOUR_DOMAIN/svn/path/to/repository

 

Example: svn list https://www.mydomain.com/svn/myproject/trunk

During executing this command, you will be prompted about the “Server Certificate”. Please press “p”, for accepting this certificate permanently. Anyhow the system may prompt you to provide the credential, please enter it properly. The top most certificate for the “Server Certificate Chain” will be stored at your local as the following: -

Table 5: The stored server certificate folder

The stored server certificate folder

 

<SVN_CLIENT_HOME>/auth/svn.ssl.server

 

Example: C:\Users\Charlee.Ch\AppData\Roaming\Subversion\auth\svn.ssl.server

Summary

At the moment, we understand that not only our credential / personal information should be configured, but also the “Maven” credential / personal information for itself should be configured, too. This will help us to achieve further integrating more simple and avoid the well know issues, such as the “HTTPS Client Configuration”. We are well prepared and ready for the next step, “Maven” integration with “Subversion” and “Issue Tracker”. I will post it soon, please stay tuned as always.

Follow

Get every new post delivered to your Inbox.

Join 119 other followers

%d bloggers like this: