code me self

http.async.client v0.3.0

2011-06-17T17:32:00.000+02:00

http.async.client v0.3.0 intorduces few changes.

Explicit client usage
with-client is gone
Preemptive authentication
Clojure 1.2.1 support
async-http-client v1.6.3

Explicit client usage

As it turned out, having implicit client management and default client started by itself, was not the smartest thing to do.

Since I have very little respect for code that is wrong, I've changed it.

Now client has to be managed explicitly, meaning you have to create and close it yourself.

All methods that issue requests now expect client as first argument.

This breaks API compatibility with anything prior to v0.3.0.

I repeat: you will have to create and close client yourself.

with-client is gone

with-client macro is gone now. It might have been useful with implicit client management, but with explicit situation it would be just a copy of with-open.

Please use with-open in connection with create-client.

Migration path from:

To:

Preemptive authentication

Thanks to xeqi for patch that provides means of controlling preemptive authentication both per request and global.

Clojure 1.2.1 support

Fixed cyclic dependency in http.async.client that was not reported in 1.2.0 but prevented you from been able to load it 1.2.1.

async-http-client v1.6.3

Underlying async-http-client library version has been upgraded to 1.6.3.

Announcing status-codes

2011-03-31T14:09:00.004+02:00

Announcing status-codes

status-codes is easy response status codes

It's easy status codes for compojure.
Not that status codes in compojure are particularly hard.
I just prefer in applications that I work with to use keywords for
status codes, rather than status codes as numbers.

(routes
(GET "/ok"           _ :ok)
(GET "/accepted"     _ :accepted)
(GET "/ok-map"       _ {:status :ok})
(GET "/accepted-map" _ {:status :accepted}))

Not much really, but it reads better than 200, 202 and so on.
In order to have this sugar in your routes pick status-codes from
clojars, and require/use status-codes:

(ns your.ns
(:use status-codes))

Enjoy.

Async HTTP Client 1.2.0

2010-10-07T23:13:00.005+02:00

Async HTTP Client 1.2.0

Intro

About month ago we released async-http-client 1.1.0.
During this month we received lots of contributions and user feedback.

We took all of this great feedback into consideration,

and here it is: lots of bug fixes and new features in async-http-client are ready to be released.

You can get it from Maven Central near you.

Highlights

To cut the long story short here are highlights of few new features.

JDK based provider

This release support a new AsyncHttpProvider based on JDK's URLConnection.
This provider can be used in environments that aren't supporting NIO.
AsyncHttpClient client = new AsyncHttpClient(new JDKAsyncHttpProvider(config));

Authentication

The library now support 3 authentication scheme: Basic, Digest and NTLM.

RequestBuilder r = client.prepareGet(url)
           .setRealm((new Realm.RealmBuilder())
                      .setScheme(AuthScheme)
                      .setPrincipal(user)
                      .setPassword(admin)
                      .setUsePreemptiveAuth(true).build());

AuthScheme can be BASIC, DIGEST or NTLM.

SSL Tunneling support

This release also adds support for SSL Tunneling.

AsyncHttpClientConfig.Builder b = new AsyncHttpClientConfig.Builder();
b.setFollowRedirects(true);

ProxyServer ps = new ProxyServer(ProxyServer.Protocol.HTTPS, "127.0.0.1", port1);
b.setProxyServer(ps);

AsyncHttpClientConfig config = b.build();
AsyncHttpClient asyncHttpClient = new AsyncHttpClient(config);

RequestBuilder rb = new RequestBuilder("GET").setUrl(url);
Future<Response> responseFuture = asyncHttpClient.executeRequest(rb.build(), new AsyncCompletionHandlerBase() {

public void onThrowable(Throwable t) {
    log.debug(t);
}

@Override
public Response onCompleted(Response response) throws Exception {
    return response;
}
});

WebDav

WebDav is now supported and can be used with two interfaces.

Low level

AsyncHttpClient c = new AsyncHttpClient();

Request mkcolRequest = new RequestBuilder("MKCOL").setUrl("http://127.0.0.1:8080/folder1").build();
Response response =  c.executeRequest(mkcolRequest).get();

Request putRequest = new RequestBuilder("PUT").setUrl("http://127.0.0.1:8080/folder1/Test.txt").setBody("this is a test").build();
response =  c.executeRequest(putRequest).get();

Request propFindRequest = new RequestBuilder("PROPFIND").setUrl("http://127.0.0.1:8080/folder1/Test.txt").build();
response =  c.executeRequest(propFindRequest).get();

// Check the response.
response.getStatusCode(); //Will return 207
response.getResponseBody().contains("<status>HTTP/1.1 200 OK</status>"));

High level

You can also use a special AsyncHandler which construct a response
based on the webdav response's code.

AsyncHttpClient c = new AsyncHttpClient();

Request mkcolRequest = new RequestBuilder("MKCOL").setUrl("http://127.0.0.1:8080/folder1").build();
Response response =  c.executeRequest(mkcolRequest).get();
assertEquals(response.getStatusCode(), 201);

Request propFindRequest = new RequestBuilder("PROPFIND").setUrl("http://127.0.0.1:8080/folder1/").build();
WebDavResponse webDavResponse =  c.executeRequest(propFindRequest, new WebDavCompletionHandlerBase<WebDavResponse>() {

@Override
public WebDavResponse onCompleted(WebDavResponse response) throws Exception {
    return response;
}
}).get();

webDavResponse.getStatusCode(); // will return 200.

Zero copy

Sometimes you need to just download some content, with out
copying/inspecting the bytes in memory, just download and store.

File file = new File(url.toURI());

File tmp = new File(System.getProperty("java.io.tmpdir") + File.separator + "zeroCopy.txt");
final FileOutputStream stream = new FileOutputStream(tmp);
// Upload a file using setBody(File);
Future<Response> f = client.preparePost("http://127.0.0.1:" + port1 + "/").setBody(file).execute(new AsyncHandler<Response>() {
public void onThrowable(Throwable t) {}

public STATE onBodyPartReceived(HttpResponseBodyPart bodyPart) throws Exception {
    bodyPart.writeTo(stream);
    // Copy the bytes directly to a File. In our case it is an FileInputStream
        return STATE.CONTINUE;
}

public STATE onStatusReceived(HttpResponseStatus responseStatus) throws Exception {
    return STATE.CONTINUE;
}

public STATE onHeadersReceived(HttpResponseHeaders headers) throws Exception {
    return STATE.CONTINUE;
}

public Response onCompleted() throws Exception {
    return null;
}
});

Response resp = f.get();
stream.close();

Automatic HTTPS redirects

Another new feature is we do support redirect from http to HTTPS automatically:

AsyncHttpClientConfig cg = new AsyncHttpClientConfig.Builder().setFollowRedirects(true).build();
AsyncHttpClient c = new AsyncHttpClient(cg);

Response response = c.preparePost(url).execute().get();

If the server redirect us to https, we will follow the new url
without any issue.

Changelog

Bug fixes
- Wrong import statement cause OSGi to fail
- Parameter encoding issue
  Test case by Martin Traverso.
- Connection Pool: Make sure the channel is still open
- NettyAsyncProvider optimization: avoid invoking onStatusReceived and onHeadersReceived multiple time per transaction
- Do not set a default Content-Type
- fix redirect loop issue
  Patch provided by Jenny Loomis.
- NettyAsyncHttpProvider.construct incorrectly appends default port to host header
- NettyAsyncHttpProvider.construct allows empty Request-URIs in Request-Line
- The current reaper may close connection event if they are active
- Escape from redirect loops & allow more urls
  Patch provided by Jenny Loomis.
- Http to Https redirect broken
- Mixing secure and not secure connections on a single client causes issues
- Support custom HTTP methods
- Configurable Connection Pool
- NettyAsyncHttpProvider.construct should default to using Accept: / header
- AsyncHttpClientConfig.Builder leaks executors
- onCompleted may get called twice
- Race condition when the remote server close the connection and ConnectionsPool is used
- Issue HTTPS tunneling when ProxyServer being set on the AsyncHttpConfig
- Infinite redirects on some server because ":80" is appended to host name
- Use full url (including host : port ) for request thru proxy
- Channel must be closed when idle timeout fires
- Per request follow redirects
  Patch provided by Erwan Loisant.
- MaximumConnectionsTotal doesn't work
- Fix Idle timeout
  Patch provided by felixtrepanier.

New features
- Add security support to ProxyServer
- Add support for zero-copy file upload
- Progress callbacks
- Add CONNECT support
- Add request timeout per request
- Add support for zero-copy bytes to ResponseBodyPart
- Make Response getter more robust, add helper
- Add support for preemptive authentication configuration
- Expose ByteBuffer in HttpResponseBodyPart to reduce byte copy
- Add support for AsyncProviderConfig object that can be used to configure proprietary properties
- SSL failure leaks channel
  Test case and a fix provided by Michael Pilquist.
- Repackage the providers/* to providers/netty
- Compile with 1.6+ and run with 1.5+
- Add NTLM authentication support
- Add WebDav support
- Add support for a JDK Provider

Asynchronous HTTP Client for Clojure and Twitter Streaming API

2010-09-10T10:45:00.002+02:00

http.async.client & Twitter Streaming API

http.async.client is a Clojure library based on Asynchronous Http Client for Java which runs on top of Netty Project.

So much for introduction, lets see some sample code that uses Twitter streaming api.

Importing:

(ns twitter-sample
 (:require [http.async.client :as c]
           [org.danlarkin.json :as j]))

Settings and helper to print twits as they fly by:

(def u "username")
(def p "password")

(defn print-user-and-text [s]
 (let [twit (j/decode-from-str s)
       user (:screen_name (:user twit))
       text (:text twit)]
   (println user "=>" text)))

Lets read statuses/sample:

(doseq [twit-str (c/string
                 (c/stream-seq :get "http://stream.twitter.com/1/statuses/sample.json"
                               :auth {:user u :password p}))]
 (print-user-and-text twit-str))

Or statuses/filter:

(doseq [twit-str (c/string
                  (c/stream-seq :post "http://stream.twitter.com/1/statuses/filter.json"
                                :body {"track" "basketball,football,baseball,footy,soccer"}
                                :auth {:user u :password p}))]
 (print-user-and-text twit-str))

Those two samples show also how to consume HTTP Streams as clojure.core/seq, a new feature that was introduced in v0.2.0.

You can also handle sequences via callbacks.

Requesting HTTP resources that are not streams is even simpler:

(let [response (c/GET "http://github.com/neotyk/http.async.client/")]
 (c/await response)
 (c/string response))

There is extensive documentation available on the github pages of the project, you can also find Changelog and API.

Big thanks go to Amsterdam Clojurians, this library received so much love and help from this group.
Kudos to Jeanfrancois Arcand for starting async-http-client recently reaching the 1.1.0 release.

I would love to hear from you what you think of this library.

clojure.core/lazy-seq makes sense

2010-06-07T12:30:00.001+02:00

clojure.core/lazy-seq makes sense

Few days ago on #clojure bartj asked about an infamous wiki entry.
I remember that while ago, when I tried to understand laziness in Clojure I stumbled upon this entry as well,
and it caused me only confusion, as it is totally outdated.
Let's try to shed some light on it.

Not lazy seq

When you construct a seq in non lazy way you should expect that all elements are realized at creation time.

(let [a (cons 1 (cons 2 nil))] (first a))
=> 1

Nothing special here. Let's introduce side effects to see what happens.

(let [a (cons
 (do (println "one") 1)
 (cons
  (do (println "two") 2)
  nil))]
(first a))
: one
: two
=> 1

As you expected all elements has been realized while constructing a, though we only needed the first element.
And that's exactly where laziness kicks in.

lazy-seq

First lets construct lazy seq with no side effects.

(let [a (lazy-seq (cons 1
           (lazy-seq (cons 2 nil))))]
(first a))
=> 1

So what is new? You have to type more and effect is the same. Why?
Adding side effects will help understanding it.

(let [a (lazy-seq (cons
           (do (println "one") 1)
           (lazy-seq (cons
                      (do (println "two") 2) nil))))]
(first a))
: one
=> 1

Now you should be able to see the benefit. Result is the same, except the whole sequence hasn't been realized,
except for the first element, as it was the only element that was needed.

Laziness is a very powerful tool:

you can construct infinite sequences,
have side effects create elements on demand, if seq construction is heavy, you might want to only issue creation of elements you'll use,
it has same interface as non-lazy seq, code using it does not have to care about it.

To sum it up

(let [a (cons
 (do (println "one") 1)
 (cons
  (do (println "two") 2) nil))])
: one
: two
=> nil

We didn't need even single element but the whole seq was realized.

(let [a (lazy-seq (cons
           (do (println "one") 1)
           (lazy-seq (cons
                           (do (println "two") 2) nil))))])
=> nil

If not even a single element is needed, than not even a single element will be realized.
So there you have it clojure.core/lazy-seq explained.

clojure.core/str makes sense now

2010-01-11T12:33:00.004+01:00

clojure.core/str makes sense

While reading excellent Programming Clojure by Stuart Halloway, instead just reading I started looking into how things are done by Clojure itself.
Yesterday it took me some time before I understood how things are done by clojure.core/str. This post is documentation of my findings.
Following modification of said function was very helpful in understanding how it works:
:tag metadata key is a symbol naming a class or a Class object that indicates the Java type of the object in the var, or its return value if the object is a fn..
Next are three parameters body pairs.

([] "")

No arguments (arity 0) will result in "" (empty string)

([#^Object x] (if (nil? x) "" (. x (toString))))

One argument call (arity 1) will call java.lang.Object.toString method.
#^Object is a Type Hint.
if should not need much explanation.

([x & ys] ((fn [#^StringBuilder sb more] (if more (recur (. sb (append (str (first more)))) (next more)) (str sb))) (new StringBuilder #^String (str x)) ys)))

This is where it starts to be interesting.
First unnamed function is defined that accepts StringBuilder sb and more params.
If more is true, that is not nil or false than call recursively self with new parameters

sb with appended result of calling str with first element of more,
more with elements after first.

If more is false, that in our context will happen only when more is nil, call sb's toString.
Next just defined function is getting called with new StringBuilder constructed from x as sb and ys as more.

It took me some time to realize that ys are turning into more.

So there you have it clojure.core/str explained.

Clojure Start Again

2009-12-26T00:55:00.005+01:00

Clojure start again

It's my other attempt to learn Clojure.
The landscape has changed a lot since last time I took a look.

Toolbox

Some tools that I used to play comfortably

Building and dependency tracking

Most popular is unfortunately Ant in building Clojure. I'm not looking forward to editing build.xml files again.
But there are two alternatives that keep track of dependencies, and do packaging.

Leiningen - build tool

Leiningen is a build tool for Clojure designed to not set your hair on fire.

That certainly sounds nice. Installation is straightforward as well, following Zefs instructions does the trick.
It boils down to this:

cd ~/bin
wget http://github.com/technomancy/leiningen/raw/stable/bin/lein
chmod +x lein
lein self-install

Leiningen is wrapping up Maven2 in nice Clojure syntax and gives you by default access not only to Maven Central Repository but also clojars.org.

clojure-maven-plugin - build tool

Another option is clojure-maven-plugin Maven2 plug-in to help you out with Clojure.
Adding following snippet should get you started:

<plugins>
<plugin>
<groupId>com.theoryinpractise</groupId>
<artifactId>clojure-maven-plugin</artifactId>
<version>1.3</version>
</plugin>
</plugins>

Clojuresque Third option

Responses I received after publishing this post showed third option that I've missed.
It is used by ClojureQL and certainly has supporters. It lacks a bit of documentation but ClojureQL - Where are we (going)? describes process quite well.

IDE

There is quite some options here, following one is most popular amongst Clojure developers.

Emacs + SLIME

Well normally I use VIM, but after watching Dynamic Interactive Webdevelopment I took for a spin Emacs, well Aquaemacs.
Following two posts were very helpful in setting up nice environment:

After some problems that got solved by setting up swank-clojure-classpath my new IDE was up.
And it welcomes me with message: Connected. Your hacking starts... NOW!

Lets get learning Clojure.

Grizzly Servlet Container at Devoxx 2009

2009-11-19T11:49:00.002+01:00

Yesterday me and @jfarcand presented
Grizzly Servlet Container at Devoxx.

Here are the slides and drop by Grizzly Users List.

Devoxx09 Grizzly Servlet Container: Chuck Norris loves it!

View more presentations from Hubert Iwaniuk.

Test your build with Maven 3

2009-10-21T21:12:00.004+02:00

Maven 3 is coming

This post is to show you how to get Maven 3.
Maven 3 is supposed to be drop in replacement of Maven 2.
So you should be able to build your Maven based build with Maven 3 with no problem.
So lets take Maven 3 for a spin.

Getting Maven 3

You can get Maven 3 binaries or build it by hand.

Getting binaries

You can grab binaries from Sonatypes Hudson grid.
Depending on your platform:

Linux: lastSuccessfulBuild from ubuntu
Windows: lastSuccessfulBuild from windows

And extract it to your new M2_HOME.

Building from source

Check it out, and build:

$ svn co http://svn.apache.org/repos/asf/maven/maven-3/trunk maven-3
$ cd maven-3
$ export M2_HOME=/your/new/m3/home/
$ ant

So you have your own build of Maven 3 at /your/new/m3/home/. Congratulations!

Add to path

Independently how you got your new Maven 3, you need to add M2_HOME/bin to your PATH environment variable.

Start using it

And that is it, you have Maven 3.
As verification step execute, end expect something similar:

$ mvn -version
Apache Maven 3.0-SNAPSHOT (r828135; 2009-10-21 20:46:19+0200)
...

You probably will see quite some warnings while building your projects that previously where unnoticed.
Following those instructions will improve your build.
Enjoy your new build tool!

MOP version 1.6

2009-07-08T23:04:00.005+02:00

It's been some time since I performed MOP release.

Quite a few things has changed in MOP:

Repository
Thanks to Sonatype MOP releases are pushed to Maven Central Repository.
Source code
Sources has been migrated to github

With new release 1.6 that can be found in Maven Central Repository new configuration option has been introduced.

Let me introduce you to showVersion option :-)

Securing Grizzly Web Server

2009-04-02T23:50:00.004+02:00

Running GrizzlyWebServer is very easy and lightweight. Serving HTTPS? The same.

It's just one more step to perform, provide Grizzly with SSL configuration.

But first thing first. Lets create GrizzlyWebServer telling it to serve secure content.
Just invoke this constructor:


/**
 * Create a WebServer that listen for secure tls/https requests
 * @param port The port opened
 * @param webResourcesPath the path to the web resource (ex: /var/www)
 * @param secure true if https needs to be used.
 */
public GrizzlyWebServer(int port, String webResourcesPath, boolean secure)

Say like this:

gws = new GrizzlyWebServer(PORT, ".", true);

If you would try start() now you get exception.
What is missing is SSL configuration.

Grizzly comes with SSLConfig helper class, that allows you to work with SSL configuration easily.

SSLConfig cfg = new SSLConfig();

This constructor fetches configuration from default properties locations, which are:

trust store - javax.net.ssl.trustStore
key store - javax.net.ssl.keyStore
trust store password - javax.net.ssl.trustStorePassword
key store password - javax.net.ssl.keyStorePassword
trust store type - javax.net.ssl.trustStoreType
key store type - javax.net.ssl.keyStoreType

If you need to override any configuration value, like key store location, just do:


URL resource = getClass().getClassLoader().getResource("test-keystore.jks");
if (resource != null) {
  cfg.setKeyStoreFile(new File(resource.toURI()).getAbsolutePath());
} else {
  // Couldn't find keystore, exit appropriately.
}

Once you have configuration ready give it to Grizzly:

gws.setSSLConfig(cfg);

And you are done, now do normal setup like providing GrizzlyAdapters and start().

Default configuration values are:

key store file - keystore.jks
key store type - JKS
key store algorithm - SunX509
key store pass - changeit
trust store file - truststore.jks
trust store type - JKS
trust store algorithm - SunX509
trust store pass - changeit

In case you want to authenticate your clients with certificates signed by your trusted CA you have to include CA public certificate in trust store.
Trust store configuration is as simple as key store configuration, methods just start with trust not key.

And that's how easy encryption with Grizzly is :-)

Grizzly OSGi Http Service Guide

2009-03-14T11:34:00.009+01:00

This post is an introduction to Grizzly OSGi Http Service.

Code for this post is available as Gitorial: http://github.com/neotyk/httpservice-gitorial/commits/master.

You'll find here:

how to use Grizzly OSGi Http Service
how to configure Grizzly OSGi Http Service
how to register servlet and resource
how to perform authentication on registered servlet or resource
what is currently implemented from spec and what is missing

Introduction

Grizzly

The Grizzly framework has been designed to help developers to take advantage of the Java™ NIO API. Grizzly goals is to help developers to build scalable and robust servers using NIO and we are also offering embeddable components supporting HTTP, Bayeux Protocol, Servlet (Partially) and Comet.

OSGi

OSGi is the powerful dynamic framework that underlies the Eclipse IDE and platform, but its use is not restricted to Eclipse. In fact it is used everywhere from mobile phone and vehicle entertainment systems to enterprise application servers. It is, essentially, the module system for Java.

It's lightweight and let's you escape JAR hell.

OSGi Http Service

The Http Service allows other bundles in the OSGi environment to dynamically register resources and servlets into the URI namespace of Http Service. A bundle may later unregister its resources or servlets.

Usage

Grizzly OSGi Http Service is available in two versions one with it's all dependencies and one by itself.
For version with dependencies you'll need to depend on:

For version without dependencies you'll need:

And examine its pom.xml to see dependencies that you'll need to satisfy.
Workspace with specified dependency on -bundle version is here.
Remember that even if you are using -bundle version you'll need to specify dependencies on org.osgi.core and org.osgi.compendium.
Next you'll need to configure bundle packaging as shown here.
Now you can configure your project to use maven-pax-plugin as specified here so you can do mvn pax:provision for easy startup of OSGi with your bundle and its dependencies provisioned.

Configuration

If you've tried mvn pax:provision from previous step you probably have seen exception that Grizzly OSGi Http Service couldn't bind to port 80.
Binding to port <1024 on most platforms requires special permissions.
Grizzly OSGi Http Service tried to bind to port 80 because it has not been configured to do otherwise, this is specified by spec as default.
To configure port that OSGi Http Service binds to you'll need to configure org.osgi.service.http.port property.
This configuration change is shown here.

Registration

In OSGi Http Service to expose something via http you have to register it.
But before you do it lets configure Declarative Services and Dependencies, this will allow much easier integration with OSGi Http Service.
Checkout this commit to see how to enable it.
Now that we have made our life easier lets get to registering Servlet and Resources.

Registering Servlet

To register a servlet you need to call HttpService.registerServlet method. Last two parameters (initparams and context) can be null for now.
alias is name in the URI namespace at which the servlet is registered,
servlet is servlet to register.
To see changes been done already, click.

Registering Resources

Registering resources is way to expose static content in OSGi Http Service.
To register resources you need to call HttpService.registerResources method. Last parameter context is optional and can be null for now.
alias is name in the URI namespace at which the resources are registered,
name is the base name of the resources that will be registered.
For working example go here.

Authentication

So far registering dynamic and static content has been described, that is nice but what if you would like to secure it?
Sure thing, you just need to provide last parameter (context) to resource/servlet registration.
If you don't provide context default context is used and this one is allowing all access.
Your authentication have to be implemented in HttpContext.handleSecurity.
This method is called by OSGi Http Service before request is handled. If your implementation returns true the request should be serviced, false if the request should not be serviced and Http Service will send the response back to the client.
And you probably saw it coming, here is a code for it.

Status

Not all specification has been implemented.
Things not implemented yet are:

SSL support,
Security as described in 102.8 Security

Those things will get implemented if users will be interested in it.
Rest was implemented as specification requested.

Enjoy working with Grizzly OSGi Http Service and make sure to report issues as well as success stories to Grizzly Users List.

Clojure?

2009-02-26T23:43:00.005+01:00

Just finished watching Clojure for Java Programmers.
Second part is much more interesting.

If you like Clojure you might want to take a look at Clojure on Grizzly.

Grizzly OSGi HttpService Status

2009-02-03T01:38:00.006+01:00

Soon Grizzly is going to be available as OSGi HttpService.

For now here is a status of ongoing work.

Maven Archetype Automation 1

2009-01-12T00:15:00.006+01:00

In my need for automation I found another place for improvements in Maven2.

Here is a situation: you have sample project showing how to use something.

And you want to be nice to your users so you would like to offer them this sample project as archetype via archetype-catalog.xml.

Here is a bit longer version of above:

ArchetypeNG seems like possible solution, have to research this one.

Grizzly OSGi Archetype

2008-12-24T09:47:00.001+01:00

This is take 2 of Grizzly on OSGi platform (take 1).

Previous problems running this configuration has been solved by Grizzly Devs, awesome feedback.

So if you want a Quick Start for Grizzly on OSGi jump to your console and execute following:

mvn archetype:generate -DarchetypeCatalog=http://kungfoo-m2.googlecode.com/svn/trunk/archetype-catalog.xml

This should allow you to choose grizzly-osgi-startup project and provide all necessary project details.
Next thing you do is to cd to newly created project and execute:

mvn clean install pax:provision

Now you should have Felix (default for Pax, you can choose other platform providers) running your bundle that uses Grizzly and is listening on localhost:8282.

Have fun Grizzling in OSGi.

Grizzly Dependency Overview

2008-12-19T11:42:00.000+01:00

You probably could see it comming :)

Here is maven-overview-plugin applied to The Monster.

From code me self

Grizzly OSGi

2008-12-19T11:26:00.000+01:00

As a side effect of working on Grizzly Proxy simple project showing how to use Grizzly in OSGi environment popped up.

Links:

Source Tree

Hope to have archetype available soon, will keep you posted.

Grizzly proxy

2008-12-19T11:11:00.000+01:00

After Devoxx I finnaly started working on Grizzly Proxy Server.

Project page and sources tree are available.

For now proxy is not functional.

Initialy I used commons-httpclient to make connections to target server.

This turned out to be not really nice since httpclient is blocking.

My current focus is to change it to use HttpCore and especially I'm interested in NIO Extensions Module.

This will allow much better scaling, but still will relly on two difrent APIs, and I'm dont think I like having it done like that.

Once Grizzly team releases thair HTTP Client I'm going to switch to it.

So don't expect g-http-proxy to be usable right now, but keep an eye on it, and fill free to contribute.

g-http-proxy is OSGi bundle :)

Thanks for listening and stay tuned.

Super Helpful Integration Testing ThingY

2008-07-07T23:10:00.000+02:00

Maven plug-in integration testing.

After walking around integration tests for Overview I finally set down and made it happen.

Most helpful integration testing solution I found is called SHITTY http://mojo.codehaus.org/shitty-maven-plugin/.

It is very easy to use.

As sane developer would expect, you'll have to put your integration tests somewhere in src (src/it).

Integration test is:

yes you are right, pom.xml,
than goals.txt - defining goals to execute,
optional setup and validation Groovy scripts.
some additional stuff that wasn't needed for me.

You can find sample usage here.

Big thanks to Jason Dillon for creating Super Helpful Integration Testing ThingY.

Maven2 Landskape - Developers view

2008-02-12T21:53:00.001+01:00

So Maven Dependency Overview Plugin has been created.
Maven has it's ups and downs as any project.

Here is a list of things that made it harder than needed to create a report plugin:

Documentation is hard to get.
Try searching Maven2 Plugin Development. You can find some basic information but soon you'll run into undocumented features.
Most of a time while viewing documentation I felt like someone wrote it because he/she was forced to do it.
Most valuable resource for me where:

Poor API documentation.
There is a plugin (maven-docck-plugin) designed to force proper documentation, unfortunately some plugins even one shipped with Maven are not using it.
Unstable API.
take a look at dependencies of maven-reporting-impl. It depends on doxia-core and doxia-site-renderer both are version 1.0-alpha-7, not documented.

Good luck developing Maven plugins, you'll need it, but it's rewarding.

I'll try to write integration test for Maven Dependency Overview Plugin, hope it is going to be as much fun as developing plugin by itself.

I'll keep you posted.

Maven Dependency Overview

2008-02-08T17:24:00.000+01:00

Maven Dependency Overview

Since I started working with Maven2 I always wanted to have a plug-in that would graph dependency.

For last few days I've been spending part of my free time on maven-overview-plugin.

And here it is in quite usable state.

You can include report with Dependency Overview, you can use it from command line, you can do some basic configuration.

To prove that it is actually useful I wrote short story of it's use: DependencyCleanUpShortStory.

Feel free to use it it is OS Licence.

Maven2 cargo plugin and integration test

2007-11-07T17:08:00.000+01:00

So I was facing a problem of creating Maven2 project that would:

Create domain based on JBoss default server configuration,
Copy to this newly created domain configuration file and datasource configuration,
Start container with domain that was result of #2.

I thought that cargo-maven2-plugin will do the job.
Unfortunately it didn't.

My initial approach was:

Attach cargo:configure (undocumented goal :-/) to generate-test-sources phase, using standalone type, so configuration gets generated from scratch based on default,
Attach antrun:run to generate-test-resources phase to copy .properties to conf, and -ds.xml to deploy,
Attach cargo:start to pre-integration-test phase, using existing type, so configuration from #2 is read-only used, and *should* not be overwritten.

In theory it seems all great and already working.
But I couldn't convince cargo to work like that.
Started executing maven with -X to discover that maven configures mojos properly, not a big surprise, especially if you take a look at CI of cargo, you would suspect cargo of errors.
At the end of a day I created this ugly but working configuration:

<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>your.group.id</groupId>
<artifactId>itest</artifactId>
<version>0.1-SNAPSHOT</version>
<name>Integration Tests</name>
<description>This module provides a collection of integration tests.</description>
<packaging>jar</packaging>
<dependencies>
  <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>3.8.1</version>
   <scope>test</scope>
  </dependency>
  <dependency>
   <groupId>your.group.id</groupId>
   <artifactId>your-ear</artifactId>
   <type>ear</type>
   <version>${project.version}</version>
  </dependency>
  <dependency>
   <groupId>org.codehaus.cargo</groupId>
   <artifactId>cargo-ant</artifactId>
   <version>0.9</version>
   <scope>test</scope>
  </dependency>
  <dependency>
   <groupId>org.codehaus.cargo</groupId>
   <artifactId>cargo-core-uberjar</artifactId>
   <version>0.9</version>
   <scope>test</scope>
  </dependency>
</dependencies>
<build>
  <plugins>
   <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <executions>
     <execution>
      <phase>integration-test</phase>
      <goals>
       <goal>test</goal>
      </goals>
     </execution>
    </executions>
   </plugin>
   <plugin>
    <artifactId>maven-antrun-plugin</artifactId>
    <version>1.1</version>
    <executions>
     <execution>
      <id>tune-deployment</id>
      <phase>generate-test-resources</phase>
      <goals>
       <goal>run</goal>
      </goals>
      <configuration>
       <tasks>
        <copy todir="${basedir}/target/jboss4x" overwrite="true">
         <fileset dir="${basedir}/src/jboss4x"/>
        </copy>
       </tasks>
      </configuration>
     </execution>
     
     <execution>
      <id>start-container</id>
      <phase>pre-integration-test</phase>
      <goals>
       <goal>run</goal>
      </goals>
      <configuration>
       <tasks>
        <taskdef resource="cargo.tasks">
         <classpath refid="maven.test.classpath"/>
        </taskdef>
        <echo message="Starting Cargo..."/>
        <cargo containerId="jboss4x"
            home="${jboss4x.home}"
            output="${project.build.directory}/container.log"
            append="true"
            log="${project.build.directory}/cargo.log"
            action="start"
            wait="false">
         <configuration type="existing" home="${project.build.directory}/jboss4x">
          <property name="cargo.servlet.port" value="8982"/>
         </configuration>
        </cargo>
       </tasks>
      </configuration>
     </execution>
    </executions>
   </plugin>
   <plugin>
    <groupId>org.codehaus.cargo</groupId>
    <artifactId>cargo-maven2-plugin</artifactId>
    <configuration>
     <wait>false</wait>
     <container>
      <containerId>jboss4x</containerId>
      <home>${jboss4x.home}</home>
      <output>${project.build.directory}/container.log</output>
      <append>true</append>
      <log>${project.build.directory}/cargo.log</log>
     </container>
     <configuration>
      <type>existing</type>
      <home>${project.build.directory}/jboss4x</home>
      <properties>
       <cargo.logging>high</cargo.logging>
      </properties>
     </configuration>
    </configuration>
    <executions>
     <execution>
      <id>stop-container</id>
      <phase>post-integration-test</phase>
      <goals>
       <goal>stop</goal>
      </goals>
     </execution>
     <execution>
      <id>create-deployment</id>
      <phase>generate-test-sources</phase>
      <goals>
       <goal>configure</goal>
      </goals>
      <configuration>
       <container>
        <containerId>jboss4x</containerId>
        <home>${jboss4x.home}</home>
        <output>${project.build.directory}/container.log</output>
        <append>true</append>
        <log>${project.build.directory}/cargo.log</log>
       </container>
       <configuration>
        <type>standalone</type>
        <home>${project.build.directory}/jboss4x</home>
        <properties>
         <cargo.jvmargs>
          -Xdebug -Xnoagent
          -Xrunjdwp:transport=dt_socket,address=8787,server=y,suspend=n
         </cargo.jvmargs>
         <cargo.logging>high</cargo.logging>
         <cargo.servlet.port>8982</cargo.servlet.port>
        </properties>
        <deployables>
         <deployable>
          <groupId>your.group.id</groupId>
          <artifactId>your-ear</artifactId>
          <type>ear</type>
         </deployable>
        </deployables>
       </configuration>
      </configuration>
     </execution>
    </executions>
   </plugin>
  </plugins>
</build>
</project>

DBUnit and RDMS with special types

2007-02-26T17:26:00.001+01:00

If you are using DBUnit for testing your data access layer, and your scheme uses some unusual data types, you need to use data type factories but it won't work if you are about to use at the same time FlatXmlDataSet.
You are going to get errors like:

WARNING - table_name.column_name data type (1111, ëbití) not recognized and will be ignored. See FAQ for more information.

Here is solution that I haven't found on google:
Override default implementation of protected IDatabaseTester newDatabaseTester() throws Exception from DBTestCase to something like this:


   protected IDatabaseTester newDatabaseTester() throws Exception {
       return new PropertiesBasedJdbcDatabaseTester() {
           public IDatabaseConnection getConnection() throws Exception {
               IDatabaseConnection databaseConnection = super.getConnection();
               DatabaseConfig databaseConfig = databaseConnection.getConfig();
               databaseConfig.setProperty(DatabaseConfig.PROPERTY_DATATYPE_FACTORY, new MySqlDataTypeFactory());
               return databaseConnection;
           }
       };
   }

Where you should use suitable for your database DataTypeFactory.