Cybso.

JasperReports is a library which can be used to fill reports from Java applications or just create simple PDFs. It allows you to not only use static output strings but also Groovy expressions. Sadly, this is restricted to simple expressions that result in a value and don’t generate multiple class files at compile time.

For example, you could use the following expression to print different values depending if your document has more or less than 10 pages:

$V{PAGE_COUNT} < 10 ? "foo" : "bar"

But when you have to loop over values you’ll face a problem as you have no possibility to define own methods. Even the usage of closures (Groovy) or anonymous inner classes (Java) is prohibited as Jasper expects every expression to result in one single class file.

Of course you could extend the class path or use Scriptlets for this, but this requires you to ship the compiled class together with the report library.

Using the power of groovy there is a way to work around this: compile your expression at runtime! The following code will calculate the faculty of the number of pages:

new GroovyClassLoader().parseClass('''
    def static fac(x) {
        def res = 1;
        1.upto(x) {
            res *= it
        }
        return res
    }
''').fac($V{PAGE_COUNT})

The first line creates a new instance of the GroovyClassLoader, parses the code given in the following multiline string expression and executes the method “fac(x)” defined statically before.

To prove the power of this method the following code will embed a recursive listing of your home directory in your report:

new GroovyClassLoader().parseClass('''
    def static list(path, prefix) {
        String result = ""
        path.listFiles().each() {
            result += prefix + it.name + "\\n"
            result += list(it, prefix + "  ")
        }
        return result
    }
''').list(new File(System.getProperty("user.home")), "")

Remember that you have to double-escape backslashes as the first escape will be handles by the Jasper compiler.

Another possibility (and the reason why I researched at this topic) is that this method allows you to generate images at runtime and use the full power of the JFreeChart library used by Jasper itself.

JTextPane and his ancestors JEditorPane and JTextComponent won’t respect the color defined with setBackground(Color) since they display a “styled document” and expect the background color to be defined in the content. You’ll always see a white background.

To change the background color (without modifying the content) you have to define attributes for the document:

    JTextPane textPane = new JTextPane();
    textPane.setContentType("text/html"); // or any other styled content type
    textPane.setText("White text on a red background");

    textPane.setForeground(Color.white); // Works as expected
    textPane.setBackground(Color.red); // Obsolete, no affect

    // Define a default background color attribute
    Color backgroundColor = Color.red;
    SimpleAttributeSet background = new SimpleAttributeSet();
    StyleConstants.setBackground(background, backgroundColor);
    textPane.getStyledDocument().setParagraphAttributes(0,
            textPane.getDocument().getLength(), background, false);

    // And remove default (white) margin
    textPane.setBorder(BorderFactory.createEmptyBorder());

    // Alternative: Leave a 2px border but draw it in the same color
    textPane.setBorder(BorderFactory.createLineBorder(backgroundColor, 2));

Soeben habe ich die neuen 2TB-Festplatten in den Media-PC eingebaut und mich dazu entschieden, dieses mal dem neuen Linux-Dateisystem btrfs eine Chance zu geben. Im Gegensatz zum klassischen ext beherscht dieses nämlich von Haus aus RAID-Funktionalitäten (Level 0, 1 und 10) sowie Snapshots. Das RAID im Level 1 schützt vor physikalischen Fehlern, die Snapshots – sofern man sie regelmäßig anlegt – vor logischen, wie einem versehentlichen ‘rm -rf’.

Die Frage ist, wie stabil btrfs inzwischen geworden ist. Da es beinahe das Standardsystem unter Fedora 16 geworden wäre ist meine persönliche Einschätzung: Stabil genug für mich. Der Grund, warum FC16 doch noch ext4 verwendet, ist das fehlende bzw. nicht rechtzeitig fertig gewordene fsck. Mit den git-Quellen jedoch kein Problem, dort findet sich inzwischen ein ‘btrfsck’. Sowieso würde ich für den Einsatz einen aktuellen Kernel (3.x) und die aktuellen Tools aus dem Git-Repository verwenden, siehe https://btrfs.wiki.kernel.org/.

Zuerst müssen die Partitionen im RAID-1-Modus formatiert werden:

$ sudo mkfs.btrfs -L mediafiles -d raid1 -m raid1  /dev/sdd1 /dev/sde1

Im Gegensatz zu einem klassischen mkfs gibt man hier also zwei (bzw. mehr) Devices an. Mit den Parametern -d (–data) und -m (–metadata) wird der jeweilige Speichermodus festgelegt. Standardmäßig spiegelt btrfs bei mehr als einer Partition die Metadaten (raid1) und teilt die Daten auf beide Devices auf (raid0).

Damit btrfs alle zusammengehörigen Partitionen automatisch finden kann, erhalten sie die selbe UUID und unterschiedliche Sub-UUIDs:

$ sudo blkid /dev/sdd1 /dev/sde1
/dev/sdd1: LABEL="mediafiles" UUID="243efbc4-5f72-4352-9160-d693b3ed41b5" UUID_SUB="0a5b948d-9761-4c94-8f85-c9548f1149f2" TYPE="btrfs"
/dev/sde1: LABEL="mediafiles" UUID="243efbc4-5f72-4352-9160-d693b3ed41b5" UUID_SUB="66fbc6c1-8295-476a-bdfe-72536f0b50ed" TYPE="btrfs"

Dementsprechend reicht es beim Mounten auch aus, entweder eines der beiden Devices oder die UUID anzugeben. Die folgenden drei Befehle sind also identisch zueinander:

$ mount /dev/sdd1 /mnt
$ mount /dev/sde1 /mnt
$ mount UUID=243efbc4-5f72-4352-9160-d693b3ed41b5 /mnt

Der Befehl ‘btrfs filesystem show’ zeigt alle erkannten Dateisysteme an:

$ sudo btrfs filesystem show
Label: 'mediafiles'  uuid: 243efbc4-5f72-4352-9160-d693b3ed41b5
        Total devices 2 FS bytes used 809.82GB
        devid    1 size 1.82TB used 817.03GB path /dev/sdd1
        devid    2 size 1.82TB used 817.01GB path /dev/sde1

Btrfs v0.19-102-g2482539

Es gibt jedoch eine kleine Stolperfalle. Soll das RAID-1-btrfs beim Booten automatisch eingehängt werden, so *müssen* alle Devices in der /etc/fstab eingetragen werden. Ansonsten meckert das System, da es nicht alle dazugehörigen Devices selbst finden kann, selbst wenn die UUID verwendet wird:

UUID=19aa7588-9694-4440-ae33-e5b8dc4030fa /media/mediafiles btrfs device=/dev/sdd1,device=/dev/sde1 0 0

Gefährlich ist dies vor allem bei Headless-Systemen, da im laufenden Betrieb die automatische Erkennung der Devices durchaus funktioniert und ein Eintrag ohne die ‘device=’-Optionen daher beim Testen durchaus funktionieren würde.

Nicht ganz einfach ist übrigens die Größe bzw. der freie Speicher des RAID-1-Dateisystems zu ermitteln:

$ df -h /media/mediafiles
Dateisystem            Größe Benut  Verf Ben% Eingehängt auf
/dev/sdd1             3,7T  1,6T  2,1T  44% /media/mediafiles

‘df’ zählt hier also einfach den gesamten und belegten Speicher aller Einzelpartitionen zusammen. Der Grund hierfür liegt, soweit ich das im Wiki verstanden habe, in einem Berechtigungsproblem: Um das Dateisystem als RAID-1 zu erkennen und die Größe damit korrekt anzugeben müsste df direkt darauf zugreifen, was ihm aber zumindest als normaler User nicht erlaubt ist. btrfs bringt daher sein eigenes ‘df’ mit:

$ sudo btrfs fi df /media/mediafiles
Data, RAID1: total=815.00GB, used=808.73GB
Data: total=8.00MB, used=0.00
System, RAID1: total=8.00MB, used=120.00KB
System: total=4.00MB, used=0.00
Metadata, RAID1: total=2.00GB, used=1.09GB
Metadata: total=8.00MB, used=0.00

Das Tool btrfs wird auch verwendet, um weitere Devices zum Raid hinzuzufügen, zu entfernen, Snapshots anzulegen oder das FS zu defragmentieren. Hiermit habe ich bisher aber noch nicht experimentiert, ggf. wird’s einen Nachtrag geben. Erstmal werde ich nun das Verhalten im MythTV-Betrieb beobachten und vor allem auf die – subjektive – Performance im Vergleich zu ext4 achten.

Links:

• btrfs Projektseite
• Ubuntu Wiki
• BTRFS Fun

When doing MVC programming in Java, there is a problem that most people don’t know about. I’ve ignored it myself much too long. The problem is that when you bind a model class to an UI component you will get a giant memory leak.

What happens?

Well, imagine a model class supporting listening for property changes. A simple example might look like this (I extend from PropertyChangeSupport here so that I don’t have to delegate all the methods, normally you wouldn’t do so, of course):

public class Model extends PropertyChangeSupport {
    private String name;
    public Model(String name) {
        super(new Object()); // Only an example! Don't do this in RL!
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        firePropertyChange("name", this.name, this.name = name);
    }
}

Next, imagine a view for this model class. It has an input field that is binded in both direction with the model (very simplified example here, I normally don’t code this way ):

public class ModelView extends JPanel {
    public ModelView(final Model model) {
        super(new BorderLayout());
        add(new JLabel("Name: "), BorderLayout.WEST);

        final JTextField textfield = new JTextField(model.getName());
        add(textfield, BorderLayout.CENTER);

        // Bind textfield => model (harmless)
        textfield.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                model.setName(textfield.getText());
            }
        });

        // Bind model => textfield (introduces memory leak)
        model.addPropertyChangeListener("name", new PropertyChangeListener() {
            public void propertyChange(PropertyChangeEvent e) {
                textfield.setText(model.getName());
            }
        });
    }
}

From now on we have a memory leak, because the JPanel, the JLabel and the JTextField (and all other referenced) objects will never be removed by the garbage collector as long as the model exists (which might be until the applications end of life). The reason is that the anonymous inner PropertyChangeListener instance has (and must have!) an implicit reference to the JPanel. And even if you replace it by a static class it does have to know the textfield which is a child object of the panel and has a reference back to it. So even if nobody else references the panel the garbage collector sees:

  Model => PropertyChangeListener => JPanel

There is a little known class called WeakReference (and his brother WeakHashMap). It contains an object, but the object could still be removed by the garbage collector as long as there is no other (non-weak) reference to it.

A naive idea is to just encapsulate the PropertyChangeListener within a WeakReference object:

public class WeakListener implements PropertyChangeListener {
    private final WeakReference<PropertyChangeListener> listener;
    public WeakListener(PropertyChangeListener listener) {
        this.listener = new WeakReference<PropertyChangeListener>(listener);
    }

    public void propertyChange(PropertyChangeEvent e) {
        PropertyChangeListener l = this.listener.get();
        if (l != null) {
            l.propertyChange(e);
        }
    }
}

Code in ModelView constructor:

// Bind model => textfield (with little memory leak)
model.addPropertyChangeListener("name", new WeakListener(new PropertyChangeListener() {
    public void propertyChange(PropertyChangeEvent e) {
        textfield.setText(model.getName());
    }
}));

The idea is that you still have this simple and small WeakListener object within your model’s listener list, but the really big part (the original listener, the panel, label, textfield, etc) could be free’d. Sadly, this will not work, because as soon as you gave the anonymous PropertyChangeListener to WeakListener’s constructor nobody else does reference to it, so the garbage collector will remove the object immediately.

The trick is to create a single reference to it which belongs the parent object:

public class ModelView extends JPanel {
    private PropertyChangeListener modelTextfieldListener;

    public ModelView(final Model model) {
        super(new BorderLayout());
        add(new JLabel("Name: "), BorderLayout.WEST);

        final JTextField textfield = new JTextField(model.getName());
        add(textfield, BorderLayout.CENTER);

        // Bind textfield => model (harmless)
        textfield.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                model.setName(textfield.getText());
            }
        });

        // Bind model => textfield (with little memory leak)
        model.addPropertyChangeListener("name", new WeakListener(modelTextfieldListener = new PropertyChangeListener() {
            public void propertyChange(PropertyChangeEvent e) {
                textfield.setText(model.getName());
            }
        }));
    }
}

That’s it. To make this easier I’ve created a little support class WeakListenerSupport that’s very helpful if you have to deal with multiple input-property-bindings. Also it tries to remove (”unlink”) itself from the model if the listener doesn’t exist any longer. It even allows to unlink all weak listeners from a single object.

With this class the above example would look like:

public class ModelView extends JPanel {
    private final WeakListenerSupport wls = new WeakListenerSupport();

    public ModelView(final Model model) {
        super(new BorderLayout());
        add(new JLabel("Name: "), BorderLayout.WEST);

        final JTextField textfield = new JTextField(model.getName());
        add(textfield, BorderLayout.CENTER);

        // Bind textfield => model (harmless)
        textfield.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                model.setName(textfield.getText());
            }
        });

        // Bind model => textfield (without memory leak)
        model.addPropertyChangeListener("name", wls.propertyChange(new PropertyChangeListener() {
            public void propertyChange(PropertyChangeEvent e) {
                textfield.setText(model.getName());
            }
        }, model));
    }
}