A couple of other interesting things I found on the Digitizor website.  Installing Chrome on Ubuntu and GIMP to be removed from next release of Ubuntu. I’ve also been playing with Chrome this week; it seems fine and fast. My “Wifi-based” Internet provider has so much latency, that it is hard to really hard to test “fast”.  I have been a fan of GIMP for quite a while and have only figured out the most simplistic functions to support my blogging; I guess I will have to give F-Spot a try in the future!

Presumably, in a attempt to create another income stream, Ubuntu created https://one.ubuntu.com, personal storage in the cloud. I have been recommending DropBox to my friends, as it has worked very well for heterogeneous environments, supporting all of the major platforms.

There are numerous technical advancements, but my primary motivation is to have a usable development box, one that delivers me a user experience similar to the expensive options and provides all of tools I need (database, Servlet container, web server, etc).  I have been using the 64-bit version of Ubuntu for over a year, it has never been as “issue free” as the 32-bit version I run on my old laptop. However, it is getting much better. I finally have Flash integrated perfectly, this has been a persistent issue for me… I recently tried to get the new Hulu desktop working, but I think it wanted the real Adobe Flash Player. I had been using one of the alternative, non-Adobe implementations and it was quite flaky and unreliable. I finally did a clean install of the Adobe plug-in and am seeing much better rendering; I have not had success with the Hulu Desktop yet, but Google Analytics, YouTube, Hulu, Pandora, WordPress, all web sites that rely on Flash, work perfectly for me now.

So far so good with my upgrade, I’m much happier with this release. Hopefully, your upgrade is as smooth! WorksWithU was an interesting site I found this morning, it seemed to have a lot of information on the upgrade and Ubuntu in general, give it a look!

This problem was actually related to my previous blog on Implementing Custom Scopes in Spring. Because I implemented some beans using the session scope, I kind of created a catch-22 scenario;  I have tried to capture the problem in bullet form:

• Each jUnit test needs the ability to specify the specific test user (role, user info, etc.) that is relevant for that individual test
• The test user profiles are configured and controlled by a Spring managed bean
• All beans are lazy-init = true and injected into the unit test using the @Resource annotation
• The session scope beans need to have the SecurityContextHolder configured with the appropriate principal (test user), before they are created
• So, the problem is: How do you specify the test user, before the session scope beans are created and injected into the unit test class?

In a normal execution environment, using the Spring Security filters and a Servlet, the SecurityContextHolder would have been assigned using the authenticated principal, before creating any Spring dependencies. Because I created my own custom scopes for unit testing, the SecurityContextHolder was null and the session scope beans constructor was failing an assertion (principal != null). I could have easily fixed this by adding a pre-authenticated user to the SecurityContextHolder, using some static method approach,. However, because my mechanism for handling test users was itself a Spring bean, I had no possible way of specifying before the beans were injected into my unit test.

When jUnit 4.0 was released, it added several new constructs that make some very elegant solutions. I don’t think most developer’s ever look beyond the base jUnit functionality; fortunately it seems to solve 99% of the typical test scenarios. The new constructs are actually specified via annotations, they are the @RunWith and @TestExecutionListeners. My example code, can probably be made a little cleaner, but my main goal was to get the unit tests working. Because you don’t directly create any of these objects, you have to be aware of the timing; implement your customizations at  the correct point in the lifecycle. Another interesting problem, is that you don’t actually create the Spring Context, but you can interact with it via listeners.

First, we need a class which extends DependencyInjectionTestExecutionListener. This base class is required when using Spring and provides several override-able methods. I needed to configure the SecurityContextHolder, before any beans were injected into the unit test; I could accomplish this by utilizing the injectDependencies method. To support my testing needs, I added two (2) properties to the sub-class (this could have been cleaner); one to specify a user from a “user provider” factory, and a simpler one that used the user id of the person running the test. As you can see from the code, before an beans are injected into the unit test, I have access to the Spring context. This allows me to request the “user provider” factory and then request a specific test user. At this point, I can now assign the user to the SecurityContextHolder; all before any of the session scope beans are created.

public class AuthorizedTestExecutionListener extends DependencyInjectionTestExecutionListener {

    private TestUserAuthorization defaultAuthorization;
    private String                junitAuthorization;

    public void setJunitAuthorization(final String junitAuthorization) {
       this.junitAuthorization = junitAuthorization;
    }

    public void setDefaultAuthorization(final TestUserAuthorizationdefaultAuthorization) {
       this.defaultAuthorization = defaultAuthorization;
    }

    @Override
    @SuppressWarnings("PMD.SignatureDeclareThrowsException")
    protected voidinjectDependencies(final TestContext testContext) throws Exception {
       if (StringUtils.isNotBlank(junitAuthorization)) {
           final Authentication login = new UnitTestAuthenticationToken(this.getClass().getSimpleName());
           SecurityContextHolder.getContext().setAuthentication(login);
       }
       else if (defaultAuthorization != null) {
           finalTestUserModuleManager manager = (TestUserModuleManager) testContext.getApplicationContext()
                    .getBean(defaultAuthorization.testUserManager());
           final SecureUserInterface user = manager.find(defaultAuthorization.principal());
           final Authentication login = new UnitTestAuthenticationToken(user);
            SecurityContextHolder.getContext().setAuthentication(login);
        }

       super.injectDependencies(testContext);
    }
}

Next, we need to extend SpringJUnit4ClassRunner. This class is responsible for for creating the Spring test context and  DI listener class.  By over-ridding the  createTestContextManager, you have the opportunity to configure the test execution listeners.  I  also created two custom annotations, TestUserAuthentication and  JUnitAuthentication.  Using either one of these annotations, I could provide run-time meta-data  to my  custom AuthorizedSpringjUnit4ClassRunner; the meta data was then used to configure my custom  AuthorizedTestExecutionListner.

public class AuthorizedSpringjUnit4ClassRunner extends SpringJUnit4ClassRunner {

    public AuthorizedSpringjUnit4ClassRunner(final Class<?> clazz) throws InitializationError {
       super(clazz);
    }

    @Override
    @SuppressWarnings("PMD.ConfusingTernary")

    protected TestContextManager createTestContextManager(final Class<?> clazz) {

       final TestUserAuthorization defaultUser = clazz.getAnnotation(TestUserAuthorization.class);
       final JUnitAuthorization jUnitUser = clazz.getAnnotation(JUnitAuthorization.class);

       final TestContextManager context = super.createTestContextManager(clazz);

       for (final TestExecutionListener l : context.getTestExecutionListeners()) {
           if(AuthorizedTestExecutionListener.class.isAssignableFrom(l.getClass())) {
               if (defaultUser !=null) {
                    ((AuthorizedTestExecutionListener) l).setDefaultAuthorization(defaultUser);
                }
               else if (jUnitUser != null) {
                    ((AuthorizedTestExecutionListener) l).setJunitAuthorization(clazz.getSimpleName());
                }
            }
        }
       return context;
    }
}

Once you understand what all of the pieces do, they are super easy to customize to provide enhanced behavior. I think my solution provided a very clean, elegant solution for providing test specific user profiles, on a test by test basis.

@RunWith(AuthorizedSpringjUnit4ClassRunner.class)
@TestExecutionListeners(AuthorizedTestExecutionListener.class)
@ContextConfiguration(locations = {//
"/com/beilers/resources/spring/contexts/jUnitContext.xml" //
})

public class UnitTestHelper {
...
}

I found an old 40GB Quantum Fireball drive in the basement and did a clean install. You have to give the Ubuntu team credit (even though I was pretty mad about my upgrade problem); the install was really quick and everything was auto configured after the install. I was super happy! The clean install actually fixed my NVIDIA driver issue; one of the 8.xx patches toasted my video settings about a month ago. I lost my advanced desktop effects, screen savers, and Avant Window Manager (dock). This actually ticked me off too, I hate when things don’t work like they are supposed too!  One thing that was really surprised me was how slow that old IDE drive was verses the new SATA technology. I have to get that drive out of my box, ASAP!

It was pretty easy to recover MySQL and WordPress. I never took the time to figure out how to backup MySQL, so I was a little worried about losing my blog data; I guess that will now be my number one priority.  The restore was as simple as copying all of the files from /var/lib/mysql and /var/www from my old drive to the new drive. I just had to change the file owners and groups, restart MySQL, and my blog was back, up and running. Not too bad!

Not that it would have helped, but my trusty NAS storage seems to have bit the dust last week; great timing!  I have been using a Buffalo Technology LinkStation for several years as my off-site backup, it is out in the barn! It has always worked perfectly, other than a noisy fan, which has been fixed in the new models.

I’m going to stop locally hosting my blog and sign up with bluehost. I think this will fix several issues for me; I won’t have to run my computer 24×7, upgrades won’t be such a risk, and maybe using them as an off-site backup.  I also plan to move my wife’s web site, she has an interior design business, over to bluehost as well; then I can setup a real site for her, rather than some simple web pages.

If you are planning to install a log analyzer, I would definitely give AWStats a try, it turned out to be pretty easy to setup and looks great. Now, I just have to work on my tomcat logs, apparently AWStats can be used for tomcat logs as well, I’m sure that will be another interesting exercise!

I was really looking forward to OpenOffice 3.0 with the upgrade, unfortunately it was not ready to be included in the release. I did not want to do the manual installation, so I’ve been waiting. Tonight I Googled and found a super easy upgrade path. The upgrade seems to have worked like a champ. My machine completely rocks, especially when compared to my work computer!!! The OpenOffice applications launch in what seems like 2 seconds! And it is not even cached!

One other bummer, not related to this upgrade is Adobe Air. It still is not working on the 64-bit machine. At least it installs normally now, but there seems to a serious network problem. All of the Air applications run, but do not connect to any of the back-end services. My 32-bit installation works fine…

sudo apt-get install compizconfig-settings-manager