Now, let’s say you have an ActiveX component and you want to see the keys it would create when self-registering, but for some reason you don’t want to actually install it on your computer. Visual Studio has a tool that is extremely convenient for this. It is called Registry Capture (regcap.exe). You can launch it on your dll component in order to generate a reg file containing the registry keys:

regcap /O output_file.reg activex.dll

First you need to boot your fresh installation. In order to do this, you can use any valid Debian bootable media, like for example the media you have used to do your installation. In the boot menu, you should select ‘Advanced Options’ and then the ‘Rescue Mode’. This will launch a recovery shell as root user (be careful). In the following screens, select the root partition where Debian is installed in order to mount it (mountpoint /).

The first thing to do now is to make sure the network is started and accessible. You can try a ‘ping debian.org‘.

Next, use vi to modify the /etc/apt/sources.list file. Make sure the installation media (CD, DVD, USB, etc.) is commented out and replace ‘wheezy’ by ‘squeeze’ in the lines where the networked mirrors are specified (lines starting with deb and deb-src followed by a URL, do not modify the ones that contain the URL for the security patches). Save, quit the editor and update aptitude in order to apply the changes: ‘aptitude update‘. Now you can download the grub-pc package from the Squeeze mirrors: ‘aptitude install grub-pc‘. During the install process, you will be asked the partition where you want to get it installed. When this is finished, run ‘update-grub‘ in order to be sure the configuration files are correctly generated. This last step is probably not necessary, but let’s play it on the safe way just in case.

Now, you can remove your bootable media and cleanly reboot the computer: ‘shutdown now -r‘. It should restart fine.

The next thing to do, as root, is to modify back the /etc/apt/sources.list file with ‘wheezy’ instead of ‘squeeze’ and launch again the command ‘aptitude update‘ to apply the change.

I introduce here a recipe that has been tested with the Oracle jdbc driver 11.2.0.2 and with Spring Roo 1.1.4 and 1.1.5. It is susceptible to work with other versions too, however I can’t offer any guarantee of result (anyway I’m convinced you’re an adventurer and, as such, you don’t need guarantees ). I’m also purposely verbose in the explanation of the process in order to give more chances to make it reproducible with other versions.

1. Download the driver from Oracle.

2. Install the driver in your local maven repository.

Maven command:
mvn install:install-file -Dfile=filename.jar -DgroupId=groupid -DartifactId=artifactId -Dversion=version -Dpackaging=jar

Example:
mvn install:install-file -Dfile=ojdbc5-11.2.0.2.jar -DgroupId=com.oracle -DartifactId=ojdbc5 -Dversion=11.2.0.2 -Dpackaging=jar

3. Create a new folder and “cd” into it. I use “C:\eclipse_workspaces\roo\osgi\” below.

4. Launch the Roo shell.

5. Create an addon wrapper for your jar. The addon wrapper command will create a maven project (pom.xml) that will be used to transform your normal driver into an OSGI driver.

Make sure the parameters match with the ones used to install the driver in your local maven repository (step 2).

Roo command:
addon create wrapper --topLevelPackage com.oracle.roo.JDBC --groupId groupid --artifactId artifactId --version version --vendorName Oracle --licenseUrl http://www.oracle.com

Example:
addon create wrapper --topLevelPackage com.oracle.roo.JDBC --groupId com.oracle --artifactId ojdbc5 --version 11.2.0.2 --vendorName Oracle --licenseUrl http://www.oracle.com

6. Quit the Roo shell and launch the maven goal mvn bundle:bundle. This command will generate the OSGI version of the driver under the target directory. Alternatively if you don’t want to quit the roo shell, you can also execute: perform command --mavenCommand bundle:bundle

7. Install the OSGI driver in Spring Roo. Run one of the following equivalent commands in the roo shell:

osgi install --url file:///C:\eclipse_workspaces\roo\osgi\target\com.oracle.roo.jdbc..jar

or

osgi start--url file:///C:\eclipse_workspaces\roo\osgi\target\com.oracle.roo.jdbc..jar

Example:
osgi install --url file:///C:\eclipse_workspaces\roo\osgi\target\com.oracle.roo.jdbc.ojdbc5-11.2.0.2.0001.jar

On successful completion, the command will return a Bundle ID that corresponds to the location of the OSGI file in the “Apache Felix” OSGI repository embedded by Spring Roo.

This is not the end yet, as you’ll probably get a strange error message when using it. So, please, keep on reading…

8. Try this new driver with Roo on an existing Oracle database:

database reverse engineer --shema xxx

If you get an error message of the style “Unresolved contraint in bundle com.springsource.oracle.jdbc”, that means your OSGI bundle has a dependency on another bundle:

Example 1:

[com.springsource.oracle.jdbc [66]] FrameworkEvent ERROR
org.apache.felix.log.LogException: org.osgi.framework.BundleException: Unresolved constraint in bundle com.springsource.oracle.jdb
c [66]: Unable to resolve 66.0: missing requirement [66.0] package; (&(package=javax.resource)(version>=1.5.0)(!(version>=2.0.0)))
at org.apache.felix.framework.Felix.resolveBundle(Felix.java:3409)
at org.apache.felix.framework.Felix.loadBundleClass(Felix.java:1594)
at org.apache.felix.framework.BundleImpl.loadClass(BundleImpl.java:904)
[... cont.]

In this first case, the bundle has an unsatisfied dependency on javax.resource

Example 2:

[com.oracle.roo.jdbc.ojdbc5 [66]] FrameworkEvent ERROR
org.apache.felix.log.LogException: org.osgi.framework.BundleException: Unresolved constraint in bundle com.oracle.roo.jdbc.ojdbc5
[66]: Unable to resolve 66.0: missing requirement [66.0] package; (package=com.sun.security.auth.module)
at org.apache.felix.framework.Felix.resolveBundle(Felix.java:3409)
at org.apache.felix.framework.Felix.loadBundleClass(Felix.java:1594)
at org.apache.felix.framework.BundleImpl.loadClass(BundleImpl.java:904)
[... cont.]

In this second case, the bundle has an unsatisfied dependency on com.sun.security.auth.module

9. Go to the SpringSource Enterprise Bundle Repository website and search for your missing dependencies. Input the full package name of the missing dependency to do the search (in our example “javax.resource” and “com.sun.security.auth.module”; the second won’t give any result so keep on reading).

10. If you find the dependency, download it and install it as an OSGI bundle in Spring Roo (see 7). If you don’t find it, try to remove the dependency from the Imports entries in the Manifest: most of the times the Manifest generated from the “addon create wrapper” command is too verbose. It is the aggregated result of the inspection of the import statements and method signatures in all the classes of the provided jar that needs to be OSGIfied.

11. Remove the faulty OSGI driver from the Felix repository:
- Use “osgi ps” to retrieve the ID of the OSGI bundle to remove.
- Use “osgi headers” to get the Bundle-SymbolicName of the corresponding OSGI bundle. Probably “com.oracle.roo.jdbc.ojdbc5″ or “com.oracle.roo.jdbc.ojdbc6″.
- Use “osgi uninstall –bundleSymbolicName com.oracle.roo.jdbc.ojdbcx“

Atfer removing the faulty OSGI driver, repeat steps 7, 8, 9, 10 and 11 until it works.

After having answered this question for Linux/Unix, I have encountered the same need for Windows. This is what I have found.

Since Windows Server 2003 (including Vista and Windows 7), you can use the “where” command. Before Windows Server 2003 and since Win 98, this command can be installed via the various “Windows Resource Kit” packages.

If you have the excellent, albeit sometimes complex, Windows Powershell installed on your computer, you can also execute the “get-command” or its shorter “gcm” alias.

My colleague, Christian Baumann (@chrissbaumann), pointed me to a third option: it exists a native port of some GNU utilities to Windows, and it includes the “which” command: http://unxutils.sourceforge.net. However, the project doesn’t seem to be alive after 2003 and some commands in the package have issues, so while it’s a perfectly valid solution, in particular for Windows 2000/XP, I would caution a little bit its usage.

• How to locate the binary, source and/or man page files for a command?

$ whereis command

‘whereis’ has some options you can specify in order to limit the places to look at, or the type of files (binary, source, man page file, …etc).

The ‘whereis’ command returns all the places where the command can be found, looking into typical Unix locations. But, more frequently, you are just interested in finding where the commands you type on the command line are located on the filesystem, according to the $PATH variable.

• How to show the path of a command?

$ which command

Without parameter, it stops on the first command found in the path. If you want to list all the locations of the command in the path, you can call it with the -a option.

I encourage you to browse the man pages if you want a detailed description of these commands.

• How to aggregate your pom?

Sometimes, the need arises to debug a pom file and then you want to have a clear idea of what Maven really executes. This command shows your pom file after the inheritance, profiles and variable substitutions have been applied.

mvn help:effective-pom

• How to aggregate your settings?

There is a similar command for the settings.xml file.

mvn help:effective-settings

• How to list the profiles that are activated?

mvn help:active-profiles

This command is particularly useful to check the profiles activated by default, when using the -P option, when using an environment variable, or any combination of these like in the following example:

mvn -Denv_variable=value help:active-profiles -P profileToActivate

This is a repost of the original text in case it would disappear from Pen.io

The Destructive Programming Manifesto

We are programmers. We strive to write good code.
We acknowledge that efficient code is often locally unclear.
We cannot stand writing more comments than code to document our hacks. We would rather not have to fix code we wrote ages ago.
We are sick of trying to decipher code others wrote.

Hence, this is how we work:
We write code as small self-contained blocks with well-defined interfaces.
Sometimes, we use software techniques to enforce them.
When a block is inefficient or behaves incorrectly, we do not read its code.
We re-implement it. Because it’s faster. And because it gives us fewer headaches.

• How to display the dependencies in your project as a list?
  

mvn dependency:resolve

• How to display the dependencies in your project as a tree?
  

mvn dependency:tree

• How to download the source code for the dependencies in your pom?
  

mvn dependency:sources

• How to download the javadoc for the dependencies in your pom?
  

mvn dependency:resolve -Dclassifier=javadoc -Dtype=jar

I am, for many years, an active reader of the Manning serie called “in Action“. I probably bought half of the collection in printed edition. Not only because I’m pretty convinced some of them will become collectors (for example, the first version of “Struts in Action” for which I also own the accompanying T-Shirt) , but also because I really enjoy the style of the collection and the way the chapters are structured. However, don’t believe I’m writing this review with a biaised opinion, because I have also been disappointed occasionally by some offsprings of the Manning family.

Please, note this review is based on one of the latests MEAP -Manning Early Access Program- edition offered in order to allow the avid readers to access the content of the book while it is being edited. This version should however be very similar to the printed edition.

Before we dive into the real content, let me introduce the authors. The book is written by three different persons, what in my opinion seems to be the maximum number of authors in order to ensure a consistent quality. However, in the case of “ActiveMQ In Action“, the CVs are pretty amazing:

• Bruce Snyder is perhaps the most famous one of the three (at least I knew his name before reading his book ). To name just a few things, he’s a member of the Apache Software Foundation and he works for SpringSource as Senior Engineer. He is also one of the developers for ActiveMQ. Additionally, he has already coauthored a few books: “Maven, the definitive guide“, “Beginning Spring framework 2” and ”Professional Apache Geronimo“; and he has participated in the Expert Groups for JSR 243 “JDO 2.0“, JSR 221 “JDBC 4.0” and JSR 291 “Dynamic Component Support for Java SE“.
• Dejan Bosanac is a Senior Software Engineer at FuseSource, a Progress Software company. He is an active committer on ActiveMQ, the author of “Scripting in Java: Languages, Frameworks, and Patterns” and he has also participated in the Expert Group for JSR 223 ”Scripting for the Java Platform“.
• Rob Davies is Chief Technology Officer at FuseSource. He is a founder of the Apache ActiveMQ, ServiceMix (Open Source ESB) and Camel projects. He has more than twenty years of experience in project management, software design and development with banking and telecom companies.

Now about the book! It is divided into four sections:

1. An introduction to Messaging and ActiveMQ that starts with a quick but very concrete overview of the subject (in the typical “In Action” style), and continues with a detailed explanation of the concepts of Message Oriented Middleware and JMS in order to lay down the necessary background knowledge.

The first chapter is a clear and concise quick start guide to ActiveMQ. It gives a high level picture of the subject, detailing the concepts of asynchronicity and of loose coupling and citing straightforward cases of usage. Then, it explains how to download, install and start it and how to run one of the examples provided with the MOM. I like the brevity of this chapter and how it goes directly to the subject: you can get a running ActiveMQ server in less than five minutes, at least if you already know a little bit about ANT. If you don’t know ANT, don’t worry: it’s not very difficult and basically you’ll just have to install it. This is probably the ultimate test to identify if you should be reading the book or not ;-)

I remember I was feeling a bit disappointed when reading this chapter because I was expecting a JMS version of “Hello World” right at the start, and instead it was “just” the execution of a prebuilt example. But I’m too much used to the “In Action” books and browsing the second chapter I have realized that was coming soon.

The second chapter is a tutorial about JMS. It’s there just in case you have never used JMS before, or you haven’t used it for a long time. It’s a good refresher on the subject because it explains really a lot in just a few pages. However, don’t expect to find all in details: this is a book about ActiveMQ, not a book about JMS. You’ll find an explanation of the base principles (the types of jms messages, the jms domains: queueing and publish/subscribe), a description of the java classes and interfaces in the JMS specification, and an example of a simple application (the long awaited “hello world”) for each type of JMS domain. You won’t be a JMS expert after reading this chapter, but you will have all the ingredients in your hands to start using it and eventually become one.

The third chapter, that also closes the first section of the book, lays down the two example applications that will be used to introduce the many features of ActiveMQ through the rest of the book. These two examples are classical choices that are correctly balanced in difficulty and in openess to change; in order to be able to adapt to many usage scenarios. They are presented with sufficient details, including the download and installation of Maven, how to launch them and an extract of the expected results.

In this first section, I just regret not finding a quick comparison of ActiveMQ to a few other open-source solutions (RabbitMQ, OpenMQ, HornetQ…), or even non open-source ones (WebsphereMQ, SonicMQ, MuleMQ…). However I can understand this would have been a very difficult exercise. So maybe getting an overview of the features that make ActiveMQ a better choice in the crowd of JMS solutions would have been really nice instead. Next edition?

2. The second section dives you directly into the bowels of the beast with the exposition of the most important aspects of the MOM server: the connectors, the security and the options for the storage of messages.

The fourth chapter is about the configuration of the connectors, both the transport connectors used by the clients in order to connect to the message brokers, and the network connectors used in order to interconnect the broker servers. This chapter starts first with a presentation of the unified format of URLs used by ActiveMQ in order to configure and to reference the different types of connector. Then, after a brief overview of all the connectors, it goes into more details explaining for each one the pros and cons, when you should consider using it, and how to set it up (with a reference to the detailed documentation for the more advanced settings). This rather lengthy chapter is organized more like a reference material. I suggest, as the authors do, that you skip few subsections and come back when you actually need it. Just make sure you understand at least one example of connector in each category: transport and network.

Chapters 5 and 6 are very important for a good mastering of the subject.  With chapter 5, you really start to understand the power of ActiveMQ because it talks about the storage systems (for persistent and non-persistent messages), details the differences for queues and topics and exposes deeply the four different storage systems that you can use with ActiveMQ. It then focuses on the caching strategies that you can deploy in order to speed up the retrieval of messages.

Chapter 6 is about securing the destinations using simple or JAAS mechanisms (for authentication and authorization) going into the details of implementing JAAS login modules. Then it elaborates on message level authorization, on building a plugin in order to implement custom authentication and authorization, and on integration of ActiveMQ with certificates based security. This closes the second section.

3. The third section is more about the integration of ActiveMQ into you own environment.

Chapter 7 focuses on the integration in Java and Spring environments, explaining with great details the different strategies for embedding the broker in your Java applications and the various configuration options that are offered when you use it with Spring. This chapter is really polished, because it also includes the development of clients using Spring and it talks about the important topic of implementing the request-reply mechanisms using JMS.

Chapter 8 shows, with an example application, how to integrate with different servlet containers or application servers. It is demonstrated using Tomcat, Jetty, JBoss and Apache Geronimo. I regret there is not more examples with other application servers like Glassfish or Weblogic, but I suspect the goal of the authors was more to show the mechanism in details with various types of platform so you can help yourself after by searching a bit on the web if necessary. This would make sense because this chapter is probably going to be outdated very fast.

The next chapter is about the usage of ActiveMQ from other languages. The scripting languages are detailed first, with the usage of the STOMP protocol for Ruby, Python, PHP and Perl; .NET/C# and C++ are detailed next. Then the chapter cleverly elaborates on SOA and RESTful access to the broker for WebServices, and also on the access using Ajax.

4. The last section concerns the advanced usage of the broker in your entreprise. I won’t develop further here because of the diversity and complexity of the topics covered. But -to name just a few subjects- this section covers clustering, scaling and load balancing, high availability, network and storage topologies, multicasting, logging, monitoring and statistics, administration of the broker, usage of wildcard and multiple destinations, system notifications and the virtual messaging, …the list continues and it is really long.

Conclusion

The overall writing quality is excellent. The text is very comprehensive. This is an important point for me as I am not a native english speaker and I don’t always manage to find a lot of time to read. I could however spot a few (actually, very few) typos, but nothing serious. The style is direct and concise and the subject is treated very seriously. Though I would have appreciated to find a few funny quotes, because I feel they help to relax a bit while reading and so help to memorize better. But this is more of a personal taste, maybe not shared with everyone who could rather see this as a distraction.

In conclusion, a must read book for anyone interested into the subject.