wiredfool

We didn’t wind up getting the blueberries or grapes into their permanent places this weekend. The blueberries are going to be a bit larger than we had expected, so we needed more space for them, which lead to getting some old logs out of the way and taking down a couple of trees that I didn’t want to drop on new plantings.

The logs had been there since the house was built, just rotting and getting eaten by bugs. Well, except for the couple logs of really nice cedar. Only the outer inch of those was eaten, and one log was a good 5 feet long and 2 feet around. I didn’t realize it was nice dry cedar till I cut it up though. It did make a decent fire starter for the bonfire to burn all the other log pieces.

I can’t believe they just left it there to rot. And that it lasted 10 years with only minimal damage.

I’m a moderator on a really big flickr group, and we’ve been running out of human power to do the moderation. There’s just too much traffic. So, My mind goes to automation and whatnot, and I’m winding up building something to help.

It’s essentially a webapp, in python.

I’m reminded that while the names have changed, we’re really no better off than we were 4 years ago in the python webapp space. There are tons of frameworks, incorporating any number of competing templating engines, object-relational mappers, and other middleware. It’s just that they’re now a bit more rails influenced. I’d use my own templating and ORM, but it’s all work related now, and I don’t want that dependency now. This will wind up being open-sourced at some point soon. And it’s a good learning experience to work on one of the more modern packages for a while, even if it does make things harder in the short run.

And they still don’t deploy easily on commodity hosting. You’d think that the Rails Revolution would helped that part, as it’s pushed fcgi and proxying to places where id hasn’t gone before.

But really, if I write PHP, it just works on any webhost. You’d be hard pressed to find a webhost these days that can’t do a minimal php/mysql website. I farted with python for two evenings on Dreamhost, and kept running into strange problems that might be the framework, might be the web adapter, and might just be the shared environment. (fcgi must be group writable? really?) So far, I’m 5 evenings into it total. So 2 evenings is a pretty good setback in the scope of this project.

More to come on this project later.

To punish me for thinking it was spring, we had snow the day after the last post.

But. Back to better weather. Today I got this year’s fruit trees in the ground. We’ve also gotten 6 blueberry bushes and 6 grape vines, to be planted real soon now. They’re haning out in the compost pile till i get places for them and holes dug.

This is part of the first batch of Pain d Campagne that I made.

From the first batch of Pain de Campagne. This is the Epi style, or stalk of wheat. It is broken apart into rolls. This one was a bit over baked relative to the baguettes. But they were both really good, and will be repeated in the future.

Four fruit trees have been bought and stored at the nursery. A Jonagold apple (Tim’s tree, a birthday gift), a Frost Peach, Bartlett Pear, and an Asian pear of some variety that I don’t remember. I got one of the holes dug today, the others will happen soonish.

Seeds for the garden are ordered. Some of them can be planted this month, but the majority are for later in the spring.

It feels good to be back in the dirt.

For reasons that may be obvious, sometimes I want my servers to tell me something, and get my attention in a manner a bit more direct than via email or rss. (If I’m busy, I’m not checking my email. If I’m checking my rss, I’m not busy) And for reasons of geography, sms messages don’t work. Well, cells don’t work, so I don’t actually carry my cell, so. Well, It’s just not effective.

So, I need a couple levels of notification above trawling email or logs. One to interrupt me with bad but not fatal problems, and one to get my attention if I need to know now.

The lower level, interrupt me, for bugs that really shouldn’t exist, problems with important customers, or things that I need to be bothered about until I fix them. The more severe stuff is akin to the raid array losing a drive or deciding to take an impromptu vacation.

So. The best thing I’ve found for notification for things that I want to know is Growl. It pops up a little notification on screen, politely, and it can receive messages over the net. Unfortunately, it’s UDP, and there are a couple of NAT boxes between me and the servers. If it was TCP, it would be a simple matter of remote port forwarding with ssh. I always have a connection open, so it’s just a matter of adding yet another port through there. But it’s UDP, and ssh doesn’t forward UDP.

There are solutions out there using netcat (here and here and so on) all of which tie in a few netcat processes into the tunnel to listen on UDP, send TCP through the tunnel, Listen on TCP on the other end, and forward UDP to the end destination.

That should work, but what I was finding was that the netcat listener on the far end would listen for exactly one UDP connection, and then stop. Once the initial socket closed, nothing further would get through. A few hours of mucking around with this while dealing with other interrupting issues and I had enough. 10 minutes later, I had a pair of python servers that would do the UDP and TCP listening. So far they’ve been far more reliable than the netcat solution.

This runs on the far end:

#!/usr/bin/env python
import SocketServer
from socket import AF_INET, SOCK_DGRAM, SOCK_STREAM, socket
import sys

GROWL_PORT=9887
TCP_PORT=19887
DEST=’192.168.10.98′

class growl_udp_handler(SocketServer.DatagramRequestHandler):
def handle(self):
addr = (“localhost”, TCP_PORT)
s = socket(AF_INET,SOCK_STREAM)
s.connect(addr)
s.sendall(self.rfile.read())
s.close()

u = SocketServer.ThreadingUDPServer((‘0.0.0.0’,GROWL_PORT), growl_udp_handler)
u.serve_forever()

and this on the local side.

class growl_tcp_handler(SocketServer.StreamRequestHandler):
def handle(self):
addr = (DEST, GROWL_PORT)
s = socket(AF_INET,SOCK_DGRAM)
s.sendto(self.rfile.read(),addr)
s.close()

t = SocketServer.ThreadingTCPServer((‘0.0.0.0’,TCP_PORT), growl_tcp_handler)
t.serve_forever()
I’m hoping that this is reliable enough that I spend more time debugging the subject of the notifications rather than the notifications themselves.

In your end of the world, it might be Superbowl Sunday. But in my corner, it’s Chainsaw Sunday. This is the first weekend since the storms that’s been warm and mostly dry, so the neighbors and I were out dealing with the properties. Some cutting more wood, some dealing with nature’s contributions to the wood pile.

Yesterday I hacked up a few downed limbs, the biggest being a good 8 inch diameter. Also took down a few more alders and cut them up into little pieces so that they stack in a convenient woodpile. And today it was gathering some the waste wood from a milling operation, stacking it, and then cleaning up more alder. This alder went in the burn pile, then the burn pile got burned.

Today was also the first outdoor meal of the year, a candle light dinner by the fire.