We have a class that needs to limit the number of logged messages to avoid DDOSes. But this particular piece of software is still using JULI (yes, I know, not my decision though). Since JULI doesn’t support NDC or MDC, we needed to get creative to test this logging limit.

You probably create a static logger for your class, something like

public class LoggingClass {
    private static Logger logger = Logger.getLogger(LoggingClass.class.getName());
    ...
}

or the equivalent with SLF4J’s LoggerFactory.

PowerMock can help you mock this logger. Yes, its that powerful. First, add it as a Maven dependency (shocker). Your pom.xml might look something like this:

    <dependency>
      <groupId>org.powermock</groupId>
      <artifactId>powermock-module-junit4</artifactId>
      <version>1.4.8</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.powermock</groupId>
      <artifactId>powermock-api-easymock</artifactId>
      <version>1.4.8</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.easymock</groupId>
      <artifactId>easymock</artifactId>
      <version>3.0</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.8.1</version>
      <scope>test</scope>
    </dependency>

Now, in order to mock this Logger, we must suppress static initialization for the LoggingClass and then set the value of this static field using the PowerMock API.

import java.util.logging.Logger;
 
import org.junit.Before;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.core.classloader.annotations.SuppressStaticInitializationFor;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
 
@RunWith(PowerMockRunner.class)
@SuppressStaticInitializationFor("com.example.LoggingClass")
@PrepareForTest({LoggingClass.class})
public class LoggingClassTest extends EasyMockSupport {
 
    private Logger logger;
 
    @Before public void setUp () {
        logger = createMock(Logger.class);
        Whitebox.setInternalState(LoggingClass.class, logger);
    }
 
    ...
}

Now you just use logger like any other mock.

This approach should work for mocking other logging frameworks as well, but YMMV. You’ll need to make some PowerMock API changes since you’d be mocking a non-system class (any other 3rd party logging library). This could be as simple as using something like @PrepareForTest(LoggerFactory.class) in place of the one above (for SLF4J’s LoggerFactory). Or it might be much more difficult. I haven’t tried it.

After a number of years away, my love of reading (non-textbooks) has returned. In the last two months, I’ve finished 6 or 7 books. Last one was probably five years before. Ok, maybe an exaggeration, but you get the picture.

One of the books that got me back into fiction was Forging Truth, by Raymond Masters. (disclaimers below)

Although I expected Forging Truth to be a typical fantasy/sci-fi piece, it ended up being a big mystery as well. It was this aspect that hooked me from the end of Chapter 2. The protagonist (and the reader) go through a journey of discovery, trying to recover his lost memories that are key to solving a crime against humanity. The book twisted and turned til the end, feeding you just enough information and back-story to keep you intrigued but not so much that the next pages were obvious.

Situated in present-day America, the novel was centered around subjects normally reserved for other (usually more medieval) contexts. This juxtaposition made for a very interesting read. Given this modern context, the language was easy and the approach to magic was “light” (i.e., unrestricted, not manna-based, etc.). However, the actual content/subject matter was a bit darker in nature, with some moderately graphic scenes. Action-packed til the end, this book left me hanging for more. Can’t wait to read the second book!

disclaimers: the links above are Amazon-affiliate links and the author is my uncle.

Today, Google highlighted Muybridge’s The Horse in Motion for his 182nd birthday. This early motion picture was created using a device Muybridge created called a zoopraxiscope that paved the way for modern cinematography. I’d like to follow it with another cool early animation device called the zoetrope that I learned about in my recent trip to California. The following clip uses the characters familiar from Toy Story, one of Pixar’s earliest hit animations.

Watch this video on YouTube.

The audio narration (in the voice of Woody) explains how the Zoetrope works, using a quickly-flashing strobe light and a rotating display. Pretty sweet, I think.

A week ago, I posted a quick fix to a bug in the Sharebox tutorial. The next day, it appears that the site hosting this tutorial expired, and its content could be lost. Never fear! Google’s cached version is here. To make it easier for you, I’ve posted the source code developed through the tutorial to my Github and you can see Sharebox in action on heroku. Lastly, I’m also hosting a cached copy of the tutorial for safekeeping, in the event its lost overwritten in Google’s cache.

• Sharebox source code on Github
• Sharebox demo on Heroku
• Sharebox tutorial (hosted cached copy)

Hope this helps!

While going through the (quite good) ShareBox Tutorial that teaches you to build a Dropbox-like sharing app, I stumbled on a nasty bug. The tutorial wisely uses the paperclip gem for file attachments, but after moving from local hosting to Amazon’s S3, I started getting an exception in the AssetsController create action.

  ActiveRecord::UnknownAttributeError in AssetsController#create
  unknown attribute: uploaded_file
  app/controllers/assets_controller:17:in `create'

At the time, Googling the error didn’t help (gasp!), so here are all the pieces together to help any wary travelers who may stumble here looking for the same answer. Turns out, the error doesn’t indicate the real problem at all. Fortunately, however, the fix is simple.

1. In the asset model file, asset.rb, change the path to :s3_credentials from using RAILS_ROOT to Rails.root.
2. In the Gemfile, replace 'aws-s3' with 'awk-sdk'. Don’t forget to bundle install

That’s all!

Credits go to

• Sikachu for pointing out the Rails_ROOT problem in this issue
• Paperclip‘s rubydocs for S3 Storage for the new dependency tip

Tried to install pyyaml today but got a couple nasty errors.

$ sudo easy_install  pyyaml
Searching for pyyaml
Reading http://pypi.python.org/simple/pyyaml/
Reading http://pyyaml.org/wiki/PyYAML
Best match: PyYAML 3.10
Downloading http://pyyaml.org/download/pyyaml/PyYAML-3.10.zip
Processing PyYAML-3.10.zip
Running PyYAML-3.10/setup.py -q bdist_egg --dist-dir /tmp/easy_install-8Co0C6/PyYAML-3.10/egg-dist-tmp-FYdiLy
build/temp.macosx-10.7-intel-2.7/check_libyaml.c:2:18: error: yaml.h: No such file or directory
build/temp.macosx-10.7-intel-2.7/check_libyaml.c: In function ‘main’:
build/temp.macosx-10.7-intel-2.7/check_libyaml.c:5: error: ‘yaml_parser_t’ undeclared (first use in this function)
...
lipo: can't open input file: /var/tmp//ccxDQipT.out (No such file or directory)

and

libyaml is not found or a compiler error: forcing --without-libyaml
(if libyaml is installed correctly, you may need to
 specify the option --include-dirs or uncomment and
 modify the parameter include_dirs in setup.cfg)

Fortunately, after piecing together a couple posts, the fix is easy. Use the following command to install PyYAML.

sudo python -m easy_install pyyaml

We must install this way because the problem is a bug in an Python’s setuptools. Its been fixed in later versions, but for now this did the trick for me.

Resources

• http://pyyaml.org/ticket/186
• http://pyyaml.org/ticket/94
• http://andreasjacobsen.com/2008/10/10/using-python-setuptools-on-the-mac/

Today, I was working from my parent’s home in Arkansas where we don’t have broadband, so my Mac was offline. I tried to start Eclipse and it just popped a dialog mentioning a log file with no other message.

After a bit of searching the errors in the log, Stack Overflow came to the rescue.

just add an alias for localhost to the network interface:

sudo ifconfig en0 alias 127.0.0.1

That’s all you have to do, really.

About a week ago, I lost my Kindle. This makes me sad. After tracking it on security cameras until it left the film of vision (left in cart at grocery store), I’ve devised a last ditch effort. Remember that convenience method of emailing documents to your kindle? Well, I’ve just created a PDF pleading for its return, including my contact info. Will it work? Maybe not, but it can’t hurt either. You can do this yourself.

1. Write a “please return my Kindle” note in MS Word. I used size 20 font, all caps, and short sentences. After my first pleading sentences
   PLEASE RETURN MY KINDLE. I MISS IT. ☹
   I included my address, phone, and email to maximize the opportunity for contact. (I live in a building with card access and the building manager’s office by the entry, so I’m not overly concerned with security here.) I even listed a location next to the grocery store it was left in as a potential drop off location. Lastly, I offered a small finders fee if it helps to incentivize them.
2. Save as (or print-to) PDF with filename “PLEASE RETURN MY KINDLE.” My assumption is that this will be the title as it appears in the Kindle itself.
3. Email to your name@free.kindle.com with the subject “convert”. This will convert it to Kindle format for easier reading, i.e., no need to do zoom/positioning to get the best view of the text. Make it as easy as possible for them to return, if they have any intention of doing so.

I’ll let you know if it works. In the meantime, if you try this, let me know the results (if any).

I’m learning so many new things at BrightTag! Among them, I’m helping develop a new service in node.js. After piecing together a few articles online about using node for asynchronous testing of REST services, I thought I’d share the testing setup I’d settled on, in case it can help you. The setup is written for vowsjs and can easily be tailored to your situation. I’ve tried to make heavy use of asynchronization, macros, and contextualized requests. In the case below, I was integration-testing an oauth security middleware (simplified here for, well, simplicity).

var vows = require('vows'),
    assert = require('assert'),
    should = require('should'),
    tobi = require('tobi'),
    http = require('http');
 
var HOST = 'localhost',
    PORT = 8087;
 
var suite = vows.describe('My API Security'),
    browser = tobi.createBrowser(PORT, HOST);
 
var client = {
  get: function(path, header, callback) {
    browser.get(path, { headers: header }, callback)
  },
  post: function(path, data, header, callback) {
    browser.post(path, { body: JSON.stringify(data), headers: header }, callback)
  }
}
 
//
//Send a request and check the response status.
//
function respondsWith(res) {
  var context = {
    topic: function () {
      // Get the current context's name, such as "POST / access_token"
      // and split it at the spaces.
      var req    = this.context.name.split(/ +/), // ["POST", "/", "access_token"]
          method = req[0].toLowerCase(),          // "post"
          path   = req[1];                        // "/"
          token  = req[2];                        // "access_token"
 
      var header = { 'Authorization': 'Bearer ' + token };
 
      // Perform the contextual client request,
      // with the above method and path.
      client[method](path, header, this.callback);
    }
  };
 
  // Create and assign the vows to the context.
 
  context['should respond with a ' + status + ' '
         + http.STATUS_CODES[status]] = assertStatus(res.status);
 
  errorMessage = (error == undefined) ? 'out errors' : ' an "'+error+'" error';
  context['should respond with' + errorMessage] = assertHeaders(res.error, res.errorDescription);
 
  return context;
}
 
function assertStatus(code) {
  return function (res, $) {
    res.should.have.status(code)
  }
}
 
function assertHeaders(error, errorDescription) {
  return function (res, $) {
    if (error || errorDescription) {
      res.should.have.header('www-authenticate');
      header = oauth.parseAuthenticationHeader(res.headers['www-authenticate']);
      if (error) error.should.equal(header.error);
      if (errorDescription) errorDescription.should.equal(header.error_description);
    } else {
      res.should.not.have.property('www-authenticate');
    }
  }
}
 
suite.addBatch({
  'GET /resource/1 authorized': respondsWith({ status: 200 }),
  'GET /resource/1 un@vth0riz3d': respondsWith({ status: 401, error: 'invalid_token', errorDescription: 'The access token is invalid' }),
  'GET /resource/1 expired': respondsWith({ status: 401, error: 'invalid_token', errorDescription: 'The access token is expired' }),
  'GET /resource/1 insufficient': respondsWith({ status: 403, error: 'insufficient_scope' })
})
 
suite.export(module)

This pattern is nice because adding new tests is a real piece of cake now that we have the contextualized request macro, and this macro pattern is easy to tailor to your situation. It also demonstrates how to set two contexts, which was left “to the reader” on the vows guide. You can even imagine adding more vows and assertions, such as one that checks the body content, into the macro, as I’ve done in the real case.

Can you refactor or modify this to make it cleaner still? Let me know in the comments.

Today, I had to remove 650 instances of a line matching a certain pattern scattered across 145 different XML files. Not a pleasant task. (If you’re wondering, I’m deprecating a field in the XML DTD and wished to remove all current instances).

Just to save you all the searching and debugging, here is the final form and my notes.

egrep -rl '^<pattern>$' * | xargs sed -i .bak '/^<pattern>$/d'

Note a difference in the regex as used in grep and sed: in sed, the parenthesis are escaped, like \(.*\), as are forward slashes which delimit the regex, like \/. However, since you’re just deleted an entire line, parenthesis probably shouldn’t be needed.

For bonus points, you can count the number of instances of a pattern scattered across a number of files using

egrep -rc '^<pattern>$' * | awk -F: '{print $2}' | awk '{sum += $1} END {print sum}'

And to finish it off, here’s a real live example!

egrep -rl '^.*<length>(.*)</length>\w*$' * | xargs sed -i .bak '/^.*<length>\([0-9]*\)<\/length>\w*$/d'
 
egrep -rc '^.*<length>(.*)</length>\w*$' * | awk -F: '{print $2}' | awk '{sum += $1} END {print sum}'