For cutting releases, it’s convenient to have just a single, defined artifact that aggregates all project artifacts into one, has a single version number, and is easily installed.

Including OSGi bundles for installation in a content package is easy enough, including content packages in other content packages on the other hand is not so common (but also easy enough). Here’s how it works:

• configure maven-vault-plugin
• add the packages to include as dependencies
• copy the packages into the aggregate package
• adjust your vlt filter config
• set the assembly package configuration (as usual)

configure maven-vault-plugin:

As always, configure maven-vault-plugin. Just use a different group than for your other packages, e.g. by appending ” Releases”. Also, set your module’s packaging to content-bundle.

<plugin>
    <groupId>com.day.jcr.vault</groupId>
    <artifactId>maven-vault-plugin</artifactId>
    <extensions>true</extensions>
    <configuration>
        <group>MyProject Releases</group>
        <requiresRoot>true</requiresRoot>
 
        <install>true</install>
        <verbose>true</verbose>
 
        <packageFile>${project.build.directory}/${project.build.finalName}.zip</packageFile>
 
        <version>${project.version}</version>
    </configuration>
</plugin>

add the packages to include as dependencies:

Just list them as regular dependencies, with the appropriate type (typically content-bundle).

<dependencies>
    <dependency>
        <groupId>my-project-groupid</groupId>
        <artifactId>uiapp</artifactId>
        <version>${project.version}</version>
        <type>content-package</type>
    </dependency>
    <dependency>
        <groupId>my-project-groupid</groupId>
        <artifactId>content</artifactId>
        <version>${project.version}</version>
        <type>content-package</type>
    </dependency>
    <dependency>
        <groupId>my-project-groupid</groupId>
        <artifactId>samplecontent</artifactId>
        <version>${project.version}</version>
        <type>content-package</type>
    </dependency>
</dependencies>

copy the packages into the aggregate package:

Configure maven-dependency-plugin to copy the dependencies to /etc/packages/MyProject as shown below.
You need to list out your artifacts in includeArtifacts.

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
        <execution>
            <id>copy-packages</id>
            <phase>prepare-package</phase>
            <goals>
                <goal>copy-dependencies</goal>
            </goals>
            <configuration>
                <outputDirectory>
                    ${project.build.directory}/vault-work/jcr_root/etc/packages/MyProject
                </outputDirectory>
                <overWriteIfNewer>true</overWriteIfNewer>
                <includeArtifactIds>
                    uiapp,samplecontent,content
                </includeArtifactIds>
            </configuration>
        </execution>
    </executions>
</plugin>

adjust your vlt filter config (as usual):

Of course, your aggregate package needs to have an appropriate filter.xml, like so:

<?xml version="1.0" encoding="UTF-8"?>
<workspaceFilter version="1.0">
    <filter root="/etc/packages/MyProject"/>
</workspaceFilter>

set the assembly package configuration (as usual):

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <executions>
        <execution>
            <id>package-zip</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
            <configuration>
                <appendAssemblyId>false</appendAssemblyId>
                <descriptors>
                    <descriptor>src/main/assembly/package.xml</descriptor>
                </descriptors>
            </configuration>
        </execution>
    </executions>
</plugin>

<assembly>
    <id>zip</id>
    <formats>
        <format>zip</format>
    </formats>
    <includeBaseDirectory>false</includeBaseDirectory>
 
 
    <fileSets>
        <fileSet>
            <directory>${project.build.directory}/vault-work</directory>
            <outputDirectory/>
        </fileSet>
    </fileSets>
 
</assembly>

That’s it – now build your bundle with mvn package and you’ll get a neatly wrapped content bundle that contains your content bundles.

handling OSGi bundles

You can include your OSGi bundles directly in this bundle as well, or you can include them in your inner content bundles. Either way works. Above example takes the latter approach (so it cannot be seen and the examples are cleaner :)

adding metadata

As this is a regular content bundle, you can easily add custom content with release information, e.g. a file /etc/myapp-releaseinfo.txt that contains build number, etc.

I want exactly what my browser gets – at exactly the same price

FireCurl gives you a curl command line ready for pasting into your bash command line for any request in the Firebug net panel:

In:

• Request Parameters
• Post and Put Parameters
• Cookies
• Headers

Out:

• File Uploads

Following below suggestions, you’ll be able to use the following for your Mozilla Extension project:

# to build a new XPI
mvn package
 
# to cycle versions in the POM, tag and build
mvn release:prepare

Automatic submission to AMO is missing so far.

The directory structure is pretty simple and what you’d expect:

.
└── src
    └── main
        ├── assembly
        └── resources
            ├── chrome
            │   ├── content
            │   │   └── firecurl
            │   ├── locale
            │   │   └── en-US
            │   └── skin
            │       └── classic
            └── defaults
                └── preferences

In your pom, you need to configure the maven assembly plugin to create a .xpi file from the contents in resources/. (lines 29-47 below).
The descriptor (src/main/assembly/xpi.xml) defines how the file is packaged (more below).
Unfortunately, the finalName configuration parameter is appending “-xpi.zip” and I couldn’t find how to prevent that. This is why starting at line 49, I use an antrun target to move the file.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

<?xml version="1.0" encoding="UTF-8" ?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>cx.bp.moz</groupId>
    <artifactId>firecurl</artifactId>
    <packaging>pom</packaging>
    <version>0.0.3-SNAPSHOT</version>
 
    <name>FireCurl</name>
 
    <scm>
        <connection>scm:svn:http://ben-peter.jira.com/svn/FIRECURL/trunk</connection>
        <developerConnection>scm:svn:https://ben-peter.jira.com/svn/FIRECURL/trunk</developerConnection>
        <url>https://ben-peter.jira.com/source/browse/FIRECURL/trunk</url>
    </scm>
 
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-release-plugin</artifactId>
                <version>2.2.1</version>
                <configuration>
                    <releaseProfiles>release</releaseProfiles>
                    <goals>package</goals>
                    <tagBase>https://ben-peter.jira.com/svn/FIRECURL/tags</tagBase>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.2-beta-5</version>
                <configuration>
                    <descriptors>
                        <descriptor>src/main/assembly/xpi.xml</descriptor>
                    </descriptors>
                    <finalName>${project.name}-${project.version}.xpi</finalName>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>prepare-package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <artifactId>maven-antrun-plugin</artifactId>
                <version>1.6</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <configuration>
                            <target>
                                <move file="${project.build.directory}/${project.name}-${project.version}.xpi-xpi.zip" tofile="${project.build.directory}/${project.name}-${project.version}.xpi" />
                            </target>
                        </configuration>
                        <goals>
                            <goal>run</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

The assembly descriptor just packs all the stuff in resources/ into the XPI.
The one exception is that it filters the install.rdf file, so that the version number can be substituted in that file

<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
    <id>xpi</id>
    <includeBaseDirectory>false</includeBaseDirectory>
    <formats>
        <format>zip</format>
    </formats>
    <fileSets>
        <fileSet>
            <outputDirectory>/</outputDirectory>
            <directory>src/main/resources</directory>
            <excludes>
                <exclude>install.rdf</exclude>
            </excludes>
        </fileSet>
        <fileSet>
            <outputDirectory>/</outputDirectory>
            <directory>src/main/resources</directory>
            <includes>
                <include>install.rdf</include>
            </includes>
            <filtered>true</filtered>
        </fileSet>
    </fileSets>
</assembly>

Substitution in the install.rdf looks like this:

<?xml version="1.0"?>
<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
     xmlns:em="http://www.mozilla.org/2004/em-rdf#">
 
    <Description about="urn:mozilla:install-manifest">
        <em:id>firecurl@bp.cx</em:id>
        <em:version>${project.version}</em:version>
        <em:iconURL>chrome://firecurl/skin/firecurl32.png</em:iconURL>
 
        <em:targetApplication>
            <Description>
                <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>
                <em:minVersion>1.5</em:minVersion>
                <em:maxVersion>7.*</em:maxVersion>
                <em:type>2</em:type>
            </Description>
        </em:targetApplication>
 
        <em:name>FireCurl</em:name>
        <em:description>Copy and paste a curl command line for any request in the Firebug Net Panel.</em:description>
        <em:creator>Ben Peter, bp@ben-peter.com</em:creator>
        <em:homepageURL>http://ben-peter.com/</em:homepageURL>
    </Description>
</RDF>

Although this should go into mvn:install, here’s a quick-fix. Just call it with the filename of the jar file to install. Um, and do this in a tmp space, this leaves clutter.

#!/bin/bash
 
filename=$1
 
if [ "x$filename" = "x" ]; then
	echo "please feed me a file"
	exit 1;
fi
 
POM=$(jar tf $filename | grep pom.xml)
if [ "$?" -ne "0" ]; then
	echo "no pom.xml in file $filename. cannot automatically install this"
	exit 2;
fi
 
POM=$(echo $POM | head -1)
echo "proceeding with POM $POM"
 
jar xf $filename $POM
 
mvn install:install-file -Dfile=$filename -DpomFile=$POM

And here’s the complete goodness for shuffling all artefacts from a running CQ instance into your local maven repository:

#!/bin/sh
 
[ -z "$CRX_URL" ] && CRX_URL=http://localhost:4502
[ -z "$CRX_CREDENTIALS" ] && CRX_CREDENTIALS=admin:admin
 
curl -H x-crxde-version:1.0 -H x-crxde-os:mac -H x-crxde-profile:default -u $CRX_CREDENTIALS $CRX_URL/bin/crxde.classpath.xml > .classpath
FILE_LIST=`cat .classpath | sed -n '/lib/s/.*WebContent\(.*\)\".*/\1/p'`
for file in $FILE_LIST; do
	echo "Downloading $file"
	curl -u $CRX_CREDENTIALS $CRX_URL$file -O
done
 
for filename in *.jar; do
	POM=$(jar tf $filename | grep pom.xml)
	if [ "$?" -ne "0" ]; then
		echo "no pom.xml in file $filename. cannot automatically install this"
	else
		POM=$(echo $POM | head -1)
		echo "proceeding with POM $POM"
 
		jar xf $filename $POM
 
		mvn install:install-file -Dfile=$filename -DpomFile="$POM"
	fi
done

In your typical CMS setup, most of the content is actively managed as such. But you often come across scenarios where other data needs to appear on a page, e.g. prices or product data that are provided by external sources and change on their own schedule.

There are various way to handle such a requirement, each with its own upsides and downsides.

One obvious way would be to access the data from within the CMS domain, i.e. build a component that reaches out to the data source and renders the appropriate data accordingly. It’s straightforward to implement, the only variation being the complexity of data access (which is involved anyways).
The one issue with this approach is that it will leave your page uncacheable to make sure that the data is always up to date. Every request to the page needs to hit the Publisher so that the component can reach out to the data source and pull the most recent data. Caching that page on a Dispatcher or CDN level is out of the question.

If you want a page that doesn’t hit the Publisher and can be cached by the Dispatcher and on the CDN, you can take a slightly different approach: build a component that in edit mode will allow you to pull updated data from the data source, and store it as part of the page’s content. In publish mode the data will be rendered just as the rest of the page’s content.
The issue with data updates is not eliminated, but it’s now pushed to the authoring side. On the publisher, the page is fully cacheable, but you need to make sure that whenever the data changes, the page is activated. That can happen automatically, if you have technical ways to be notified of data changes, or can be organizational (read: phone call). Altough technically often not a problem, the automated update often is impossible because the involved pages contain other content that may or may not be ready for activation and still need to be checked by a human. Or they are simply part of a review and approval workflow that is not certain to complete within the time that the data is allowed to be out of date on the public-facing systems.
From an implementation perspective, this option is slightly more complex than the previous option.

If there is a need to update the data in the page in a fully automated fashion, there are more options available that merge content and data not at the time the page is baked, but on the webserver or in the browser.

Bringing data and content together in the browser is easily done through AJAX requests, as long as you can expose the data source in a way that will give you the right data per page as e.g. JSON. For both performance and information control reasons, you want to put a layer on top of the data source that will not simply spit out all of the data, but just the data that are required for that particular page.
This approach works well, is very simple to implement, and matches the second approach in terms of cacheability: the page can be cached at all levels. A request for the page can be offloaded at a CDN layer and from the Dispatcher cache. Only an activation of the page due to content changes will require these layers to be purged or invalidated. The delivery layer on top of the data source can follow its own caching strategy.
The approach may be inappropriate if the display of data must not be deferred until the request for the data is complete, or if it must not depend on Javascript being available. While today such restrictions are typically not considered important from a user experience point of view, legal requirements can often enforce that a page be either displayed completely with accurate information and independent of Javascript, or not at all.

That leads to the fourth option that’s available which allows for good cacheability, data accuracy and user agent compatibility. Instead of aggregating in the browser, the aggregation is performed on the webserver.
For that, a layer is built on top of the data source that renders HTML fragments that go into the page. The respective CQ component does nothing but render an appropriate SSI statement that fetches the HTML fragment from the data rendering layer and plugs it into the page. As typically SSI does not allow you to include remote sources, a reverse proxy is required to make the data available as a local path if the data source is not deployed within the same virtual host.
That leaves the page cacheable on the publisher: the page including the SSI statement is pulled from the dispatcher cache, SSI statements are evaluated, and the page is then returned to the requesting layer – either the CDN, a proxy, or a browser. It can however not be cached at a CDN level, as for data consistency the webserver needs to re-perform the SSI on each request.
In terms of implementation this option is pretty simple, but you want to make sure you have someone handy who knows your webserver well.

For completeness’ sake, there’s an option that has similar characteristics as the first option in terms of cacheability and process interdependencies but is slightly more complex to implement. If you can afford to hit the Publisher on each request and your data source has a hierarchical structure, you can choose to make it visible to Sling as resources within the repository. This is typically only worth the effort if that data is used in many different scenarios and if it is semantically part of your content, but not managed as such because it comes from an established source that is outside of the system’s domain.

Which of these options is appropriate is up to the concrete situation. None of them can be generally ruled out or recommended, although it may be considered bad manners to introduce interdependencies between content publication and data update processes, which the first two and the fifth option do.

Here’s a simple hack for Firefox:

• create a bookmark to the most common URL, including the endpoint in the system, and susbstitute the changing part with %s e.g. http://%s.cq-vpn.company.com/crx/browser/index.jsp
• Go to the bookmark’s preferences and give it a keyword, e.g. crxb.

After that, all you need to type into the URL bar is crxb author-1.development to get to http://author-1.development.cq-vpn.company.com/crx/browser/index.jsp

Granted, no big science here, but helps to get there quickly without maintaining dozens of bookmarks.

So what then? The best alternative I found was to use Dragon Dictation on the iPhone. It’s an impressive Voice-to-Text Application and allows you to copy to the clipboard, send by mail, post to twitter and facebook.

That’s a start, but still a lot of steps to get a task from spoken words to RTM:

• talk, push “stop” (the “recognize end of text” option doesn’t work too well)
• - hit “email”
• - cut the text body and paste it to the subject line
• - select “qqq” as the recipient (the alias of my RTM inbox)
• - hit “send”

Considering this as a collecting process in terms of TRO, that’s too much by far. Here’s a little tweak to elimiate the cut & paste step, using procmail:

Step 1: create a script that rewrites the mail body to the subject line:

#!/bin/sh
 
MSGBODY=$(formail -I "" | tr "\n\r" "  ")
echo "List: Inbox" | mail -s "$MSGBODY" "yourinbox@rmilk.com"

Step 2: setup a procmail filter for a specific address that pipes to that script

:0 :
* ^To:.*yourownsecret@ddress.com
| rewrite-body-subject.sh

That condenses the steps to

• talk, push “stop” (the “recognize end of text” option doesn’t work too well)
• - hit “email”
• - select “qqq” as the recipient (the alias of my RTM inbox)
• - hit “send”

Still too long. My preferred solution would be a wristwatch that I can talk to to add a task to my RTM inbox. Not coming anytime soon I guess. Jott for Europe would do for a start.

The curl part is pretty easy and didn’t take much after a brief look in Firebug (although I do miss a “copy as curl command” content menu entry in Firebug’s net panel ;-).

What was harder was to find a way to put a timestamp into a filename in a windows .bat file. I’m sure there are smarter ways to do this (including but not limited to installing bash ;-), but here’s what I came up with.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Rem set group and package name as in package manager
Set GROUP=packagegroup
Set PACKAGE=packagename
Set HOST=hostname
 
Set CURRDATE=%TEMP%\CURRDATE.TMP
Set CURRTIME=%TEMP%\CURRTIME.TMP
 
DATE /T > %CURRDATE%
TIME /T > %CURRTIME%
 
Set PARSEARG="eol=; tokens=1,2,3,4* delims=/, "
For /F %PARSEARG% %%i in (%CURRDATE%) Do SET YYYYMMDD=%%l%%k%%j
 
Set PARSEARG="eol=; tokens=1,2,3* delims=:, "
For /F %PARSEARG% %%i in (%CURRTIME%) Do Set HHMM=%%i%%j%%k

Rem -k is only needed if you have a self-signed cert
curl -k -u admin:admin -o backup-%YYYYMMDD%%HHMM%.html -F cmd=build https://%HOST%/etc/packages/%GROUP%/%PACKAGE%.zip/jcr:content.console.html
curl -k -u admin:admin -o backup-%YYYYMMDD%%HHMM%.zip https://%HOST%/etc/packages/%GROUP%/%PACKAGE%.zip.res/%PACKAGE%.zip

This interaction was one permutation of an often-seen interpretation and implementation of personal interaction through social media. Some thoughs on this:

• Social media are the consumers’ domain.
• Make it easy to spread your message, don’t invade.
• Listen and respond, don’t shout or babble.

Social media are the consumers’ domain. What’s facebook, twitter, youtube to a consumer? A medium to communicate with friends, with people they know personally (which does not necessarily mean they have met in person). It’s the fast and easy way to share something cool they’ve found. Yes, it does vary by channel – you find more people actually publishing on youtube and more 1:1 interaction on facebook. But the point here is: these are places that consumers use to update and be updated on their personal relationships (loose and close). They are not typically places where people go to pull information.

Make it easy to spread your message, don’t invade. So how do you approach social media from a marketing perspective? You certainly don’t want to flood the channels and hope that people will “Like” what you say or retweet. The channels are already full with non-statements and junk, and there’s no point in you repeating what you already said elsewhere.

What does get you buzz and recognition is if others repeat what you already said, if people pick things up and tell their personal network about them. This takes an anonymous marketing message to a personal level, and actual someone is saying something about your brand or product, or at least quoting your message – with the effect that

a) your message get’s heard (at all)
b) it’s amplified by the recognition that the quoting person has

To enable that effect, the first thing you want to ensure is that people can easily relay your message to social networks, and that’s not hard to do. Tweet-Buttons, Like-Buttons are easy to start with, and it’s also not hard to go to the next levels of pointedness, like specifying what image and text goes with the user’s message if he shares on facebook.

Listen and respond, don’t shout or babble. So now people talk about your products, they pick up your campaign’s statements, amplify your message, great. The next thing to do is to listen carefully to what people have to say, both on your campaigns but also outside of them. On social media, people talk openly about you or directly to you. Get back to them and so engage in the conversation that’s taking place.

That’s also not something that is hard to do, but it requires people that mindfully respond to what consumers have to say. This is not about a bot that bounces back canned responses according to a smart rule set.

Adding to the experience I made at the Frankfurt International Airport, after going through security, I followed the signs to the Lufthansa lounges, about a half-mile walk from my departure gate. When I got there, I found that they are redoing the lounge and had closed it for Frequent Travelers, allowing only Senators and HONs in. I vented my frustration and tweeted

“@Lufthansa_DE Lounge FRA closed for Business / Frequent Flyers, but no mention until you reach the lounge entry. #fail“

That’s the moments where it makes sense for a company to take action and respond, but the following tweet never came.

“Sorry for the inconvenience @ben_peter! Shoot us your Miles and More number and we’ll credit you 1m miles”

Seriously: listen and respond to real concerns. That’ll be recognized, noted, appreciated. Don’t just pump out junk responses to get meaningless “buzz”.

As usual, audio and video recording was forbidden, and just as usual everyone ignored it, taking pictures and videos with their mobiles.

Although I cannot see why exactly people do this, spending time with their devices instead of listening, I have a feeling that certain rights owners must be freaking out about this, but it would go too far to forbid mobile phones at concerts.

So I started wondering if at some point we’ll see some kind of location based DRM? Granted, not all devices have geolocation information, but for one thing coverage is getting greater (especially for devices which can shoot good videos), and there’s also some near-range communication technology that could be exploited (like Wifi, Bluetooth, RFID). Doesn’t have to be based on GPS.

Maybe this is far-fetched, but looking at the effort that is put into preventing people from digitizing what their eyes can see and their ears can see, it doesn’t seem completely out of range.