I was responsible for moving the GnuCash CVS repository over to Subversion, which was an interesting experience.

The basics are covered in all the applicable documentation, though there’s are some things I distilled out, primarily around cvs2svn.

cvs2svn is seperately available from http://cvs2svn.tigris.org/ but has not-quite-direct docs about how to do what I’d imagine is a pretty straightforward thing: dump multiple CVS modules into seperate top-level SVN directories following the recommended “module/{trunk,branches,tags}/” convention. It turns out, from the cvs2svn FAQ, the incantations are:

• ~/cvs2svn-1.3.0/cvs2svn [options below] --dump-only --dumpfile=moduleA.dump /path/to/cvs/repo/moduleA
• svn mkdir file:///path/to/svn/repo/moduleA
• svnadmin --parent-dir moduleA load /path/to/svn/repo < moduleA.dump

There were two sets of options that we needed to add: the first around symbol renaming, and the second dealing with binary files.

The list of symbol transform arguments to cvs2svn to do branch- and tag-renaming was:

–symbol-transform=’gnucash-([0-9]+)-([0-9]+)-branch:\1.\2′ –symbol-transform=’gnucash-docs-([0-9]+)-([0-9]+)-branch:\1.\2′ –symbol-transform=’gnucash-([0-9]+)-([0-9]+)-([0-9]+)-rc:\1.\2.\3-rc’ –symbol-transform=’gnucash-([0-9]+)-([0-9]+)-([0-9]+[a-z]+?):\1.\2.\3′ –symbol-transform=’gnucash-([0-9]+)-([0-9]+)-(.*):\1.\2.\3′ –symbol-transform=’gnucash-docs-([0-9]+)-([0-9]+)-([0-9]+):\1.\2.\3′ –symbol-transform=’root-of-gnucash-([0-9]+)-([0-9]+):\1.\2-root’

Turns out some of the historical CVS gnucash files aren’t appropriately tagged binary, and for some reason cvs2svn or svn itself wasn’t really doing the right thing. As such, I needed to override the mime-types and eol-handling with the options:

–no-default-eol –eol-from-mime-type –mime-types=/root/test.mime.types

It turns out that you just have to use all these options together, basically. /root/test.mime.types was cobbled together by grepping the image/* types out from the normal mime.types, then extending the application/octet-stream entry for some gnucash-specific extensions. Specifically:

application/octet-stream bin dms lha lzh exe class so dll xac gmo

Apart from that, cvs2svn does all the work, here. After running the svnadmin import, the dumpfile for moduleA will be imported into the directory ‘moduleA’ in the SVN repo, and Bob’s your uncle.

From time to time at work I use a little swing Jython shell to do various and sundry interactive tasks against our system … either poking at vm-local code in development or against one of the runtime development or staging instances. It’s quite useful when it is.

One thing I often find myself doing is processing some chunk of data, which sometimes can take either a good chunk of — or unknown amount of — time. The simple implementation of my little jython shell blocks the UI while the python is processing, which is less than ideal for long-running jobs. I’ve done various ad-hoc threaded solutions for this before, but finally generalized it today.

AsyncMap functions like map, but asynchronously. As it applies the given function to the elements of the given list, it will update a JLabel with its position in the list, as well as the last- and average-times taken processing the elements.

The one potential dependence on my scenario it has is that the global win is expected to contain the JFrame of the UI; but if you supply it another JLabel already placed in the UI appropriately, &c., it’ll happily use that.

from java.lang import Runnable class AsyncMap (Runnable): ”’asynchronous map; reporting position and time-stats to given ui label.”’ def init(self, fn, inList, label = None): from javax.swing import JLabel from java.lang import Thread self.fn = fn self.inList = inList self.outList = [] self.errs = [] if not label: label = JLabel(’— uninit —’) win.contentPane.add(label) win.pack() self.label = label self.thread = Thread(self) def start(self): self.thread.start() def run(self): from java.lang import System totalTime = 0 self.label.text = ‘0/%d’ % (len(self.inList)) for idx,item in [(i,self.inList[i]) for i in range(len(self.inList))]: start = System.currentTimeMillis() res = None try: res = self.fn(item) except: self.errs.append(”error at %d” % (idx)) end = System.currentTimeMillis() self.outList.append(res) time = end-start totalTime = totalTime + time avgTime = totalTime / (idx+1) self.label.text = ‘%d / %d - last: %f, avg: %f’ % (idx+1, len(self.inList), time, avgTime) self.label.text = ‘DONE: %s’ % (self.label.text)

I’ve found an ant task and java utility code for hotswapping code into a JVM using the JPDA debugging interface.

Though it requires a pretty recent version of ant, it does work really well … within some constraints of the JVM/JPDA interface itself. Specifically, you apparently cannot add, remove or change the signature of methods via said interface … so whole-sale changes to the program code aren’t going to work. But, for a wide variety of minor changes and tweaks, hotswap.jar is incredibly useful.

Nevermind the bits about constructing timestamps in his instructions … touch a sentinel file to keep track of load-times, and use ant’s built-in depend mechanism. For example, with a server in server/ depending on shared utility code in common/ and per-module build-output going into server/build/java, common/build/java, &c…

It’s really frustruating to write software, sometimes. Computers are exceedingly literal, and true abstraction is quite hard to come by. Adding documentation, written by wonderfully-silly humans,doesn’t always help, either.

For instance, Struts has a nifty feature for “map-based form properties”. Basically, if you write in your page:

<input type=”text” name=”nameMap(foo)” value=”bar” />

And when submitted, form.setNameMap("foo", "bar") will be called. Quite nice when you have a lot of dynamic content in the page and you’re trying to figure out how it needs to be related at form-submit time…

In fact most of Struts’ handling of forms is simple bean-addressing strings… you can create “nested” paths with ‘.’ (e.g., “person.name.first“), and do indexed properties with ‘[]’ (e.g., “names[42]”).

So, what happens when you want to use

<input type=”text” name=”nameMap( [ :name "joe bob"; :email "root@127.0.0.1" ] )” />

…? That’s an expression repressenting a single mapped-property call, with a string argument, right?

Ha Ha, no.

Turns out that the simplest thing that could possibly work here is to do String.indexOf() calls with the various delimiters. So the first thing that hits is the ‘.’ in the email address. Should that not have been there, the ‘[’ would be next up. Of course, neither are at all right. And, of course, in traditional programmer style, the documentation is perfectly willing to make believe that the expression syntax is robust and well-behaved.

A request to other programmers: any time your “parser” is based around calls to indexOf, then you need a big “THIS IS A HACK PARSER” disclaimer in your documentation, so people will give it this distance it deserves.

Update, a few minutes later:

It also does not help that the entire error you get when you make this mistake is…

HTTP ERROR: 500 BeanUtils%2Epopulate

RequestURI=/secure/dedup/un-c11n.spoke

…in the browser, and the misleading…

Caused by: java.lang.NoSuchMethodException: Property ‘namePerson’ has no setter method

…in the exception. Thanks, BeanUtils, for perhaps having the worst error messages evar.

I wrote a while ago about my stint of using IntelliJ and returning to emacs. More recently, I got an email from Suraj Acharya, saying that I should try jde-usages, which provides a set of extended functionality around method-usages and -overriding, and detecting the callers of a particular method. It also provides a jde-open-class-source-with-completion function, which is awesome — very close to IntelliJ’s behavior. It’s my new binding for C-c n.

After my efforts Friday to get jython working in swing, I set upon my real goal: HTTP/HTML access to a server-side jython session. The idea is that the jython session runs in the app-server container, and thus has access to the full runtime configuration and capability of the system. It is exposed to the user[s] in a durable yet dynamic manner.

I’ve packaged up the results as jyWebShell 1.0. At 5MB, it’s a bit larger than a traditional .war file since it contains the full Jetty distribution, as well as Struts and jython.

I use the XMLHttpRequest object in the UI, which submits just the current python command, and updates the page in-place with the result of that evaluation; however, if the XMLHttpRequest doesn’t exist, a normal POST is done, and will work just fine.

I’ve also got a short Flash demo [read: “screencast”] of it in action; no audio, unfortunately … a project for another weekend.