And I also did a talk about Media Viewers and demoed PdfJs and the Embed viewer (read more about them here). In preparing this speak I used reveal.js, a tool to make html presentations. And it also supports using markdown syntax. Wouldn’t it be possible to use the Alfresco add-on Manual Manager I had created to author the slides?

Well I added this.

Using that menu option your current topic page will become first slide. All subtopics will be the following slides (navigating your slide deck right/left). Each of those subtopics that has childs will also become slides (the up/down navigation in reveal.js).
All with selectable theme and transitions.

Full introduction to the Manual Manager here. Lots of features, check the video in that post out.

And I hope more people will use this tool. I’m now releasing it as open source. It is now available at github https://github.com/loftuxab/manual-manager!

At first glance, the quickshare feature introduced with Alfresco 4.2 really seemed to address a long standing requirement for me. I have been asked more than once about how to share content publicly. A few days ago, I wanted to share a big file with another guy. I happily uploaded that file to our alfresco server, clicked the share button and checked the public page to make sure the other guy gets a chance to see and download the file.

Bummer ! Where is the download link ?

I was looking around in Share whether I missed a checkbox or something … no. I checked issues.alfresco.com and googled around – found I am not the only one missing that download link. Jeff Potts and another guy were asking about it months ago. I have to say I just do not understand the arguing of the Alfresco Cloud/Mobile support team why it should be as it is, so I “fixed” it myself. The file below provides a drop-in fix giving you the link. Assuming you have a standard Alfresco tomcat installation, just unzip it in the alfresco directory, restart Share and enjoy sharing.

References

• Quick share page needs a download link

The post The Missing Alfresco Quickshare Download Link appeared first on CONTENTREICH.

Alfresco est une plate-forme de gestion de contenu extensible, souple et évolutif. Alfresco fournit par défaut un système de modèles de données assez complet qui vous permet de gérer la plupart de vos données. Cependant, rien ne vous empêche d‘étendre ces modèles ou de créer un modèle personnalisé pour le faire correspondre à des besoins métier spécifiques. Dans cet article nous allons mettre en œuvre la création d’un nouveau modèle de données personnalisé en introduisant, dans une première partie, quelques définitions et en détaillant, dans une deuxième partie, les étapes de création une par une.

Partie 1 : Qu’est-ce qu’un modèle de donnée sous Alfresco ?

Un modèle de donnée : c’est le système qui permet de décrire les données stockées dans l’entrepôt des données sous Alfresco. C’est la collection entre des types de données, des propriétés (métadonnées), des contraintes, des associations, des aspects de contenu et des comportements personnalisés :

1. Les types de contenu: c’est l’équivalent d’une classe dans le monde orienté objet. Un type de contenu complexe peut avoir plusieurs propriétés qui peuvent être héritées à partir d’un type parent. Par défaut, on trouve dans Alfresco deux types complexes qui sont le « Content » et le « Folder ». Il est possible d’étendre les modèles de données pour les faire correspondre à des besoins métier personnalisés.
2. Les propriétés (Property types or data types) : ce sont les métadonnées associées à un type particulier.
3. Les types de données: Ils décrivent les types fondamentaux de données utilisés pour stocker les propriétés. Exemple de type fondamental : « Double », « Float », « Integer ».
4. Les contraintes: Ils sont imposées sur les propriétés (telles que des contraintes sur les valeurs des propriétés pour les faire correspondre à un certain modèle). On distingue 4 types de contraintes disponibles :

- REGEX : utilisée pour vérifier la correspondance d’une valeur avec une expression régulière.
- LIST : utilisée pour définir une liste de valeurs possibles pour une propriété donnée.
- MINMAX : permet de définir un intervalle de valeurs limitées entre une valeur Minvalue et Maxvalue.
- LENGTH : permet d’ajouter une restriction sur la longueur d’une chaine de caractère.

Partie 2 : Comment créer un modèle de donnée personnalisé sous Alfresco ?

Dans la suite, nous allons détailler étape par étape la création d’un modèle de donnée personnalisé avec deux types de contenus personnalisés « Type facture » et « Type contrat ». Ci-dessous les propriétés de chaque type :

Type facture :
- Date de règlement (type : date)
- Date d’exécution (type : date)
- Référence (type : texte)
- Nom Client (type : texte avec une contrainte de type «REGEX» pour n’autoriser que les valeurs alphabétiques)
- Montant (type : int)
- Nom émetteur (type : texte)

Type contrat :
- Nom Client (type : texte)
- Nom émetteur (type : texte)
- Référence (type : texte)
- Date du contrat (type : date)

1.  Créer un nouveau dossier nommé « tuto » et placer le sous Alfresco/tomcat/shared /classes/alfresco/extension/. Cette technique permet d’ajouter une extension sans toucher au code natif d’Alfresco.

2.  La deuxième étape est la déclaration de notre modèle de donnée personnalisé via l’ajout d’un fichier de contexte (Custom Model Context File).  Ce fichier permet de déclarer à Alfresco la création d’un nouveau modèle de contenu. Nativement, Alfresco charge tous les fichiers qui se terminent par « context.xml« , placés dans le dossier « extension ». Tout ce que nous devons faire est de créer un fichier qui se termine par ce suffixe, et d’y déclarer notre modèle.

Sous le dossier de l’extension, créez un nouveau fichier XML  appelé « tuto-model-context» et y insérez le code suivant :

Code : tuto-model-context.xml :

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE beans PUBLIC '-//SPRING//DTD BEAN//EN' 'http://www.springframework.org/dtd/spring-beans.dtd'>
 <beans>
    <!-- Registration of new models -->	

	<bean id="example.dictionaryBootstrap" parent="dictionaryModelBootstrap" depends-on="dictionaryBootstrap">

        	<property name="models">
          	<list>
                		<value>alfresco/extension/tuto/tutoModel.xml</value>
            	</list>
        	</property>

      </bean>
</beans>

3.  Passons maintenant à la création de notre modèles de donné. Créez un nouveau fichier XML dans le répertoire de l’extension et y insérer le code ci-dessous. Assurez-vous que le nom correspond à ce que vous avez spécifié dans le fichier « tuto-model-context.xml ». Pour notre exemple, le fichier doit être nommé « tutoModel.xml ».

Code : tuto-model-context.xml :

<?xml version="1.0" encoding="UTF-8"?>
<!-- Definition of new Model -->
<model name="tut:tutomodel" xmlns="http://www.alfresco.org/model/dictionary/1.0">
    <!-- Optional meta-data about the model -->
    <description>ArchiveYourDocs</description>
    <author>Salmen KTATA</author>
    <version>1.0</version>
    <!-- Imports are required to allow references to definitions in other models -->
    <imports>
        <!-- Import Alfresco Dictionary Definitions -->
        <import uri="http://www.alfresco.org/model/dictionary/1.0" prefix="d" />
        <!-- Import Alfresco Content Domain Model Definitions -->
        <import uri="http://www.alfresco.org/model/content/1.0" prefix="cm" />
    </imports>
    <!-- Introduction of new namespaces defined by this model -->
    <namespaces>
        <namespace uri="tuto.model.client" prefix="tut" />
    </namespaces>

    <types>
        <!-- Enterprise-wide generic document type -->

		<type name="tut:facture">
            <title>Tuto Facture</title>
            <parent>cm:content</parent>
			<properties>

				<property name="tut:factdateReglement">
					<title>Date de réglement</title>
					<type>d:date</type>
					<mandatory>false</mandatory>
				</property>

				<property name="tut:factdateExecution">
					<title>Date d'exécution</title>
					<type>d:date</type>
					<mandatory>true</mandatory>
				</property>

				<property name="tut:factreference">
					<title>Référence</title>
					<type>d:text</type>
					<mandatory>false</mandatory>
				</property>

				<property name="tut:factnomClient">
					<title>Nom Client</title>
					<type>d:text</type>
					<mandatory>false</mandatory>
					<constraints>
						<constraint name="tut:regex1" type="REGEX">
						<parameter name="expression"><value>[a-zA-Z]*</value></parameter>
						<parameter name="requiresMatch"><value>flase</value></parameter>
					</constraint>
				</property>

				<property name="tut:factmontant">
					<title>Montant</title>
					<type>d:int</type>
					<mandatory>false</mandatory>
				</property>

				<property name="tut:factnomEmetteur">
					<title>Nom emetteur</title>
					<type>d:text</type>
					<mandatory>false</mandatory>
				</property>
         </properties>
        </type>

        <type name="tut:contrat">
            <title>Tuto Contrat</title>
            <parent>cm:content</parent>
		<properties>
				<property name="tut:contnomClient">
					<title>Nom Client</title>
					<type>d:text</type>
					<mandatory>false</mandatory>
				</property>

				<property name="tut:contnomEmetteur">
					<title>Nom emetteur</title>
					<type>d:text</type>
					<mandatory>false</mandatory>
				</property>

				<property name="tut:contreference">
					<title>Référence</title>
					<type>d:text</type>
					<mandatory>false</mandatory>
				</property>

				<property name="tut:contdate">
					<title>Date du contract</title>
					<type>d:date</type>
					<mandatory>false</mandatory>
				</property>
		 </properties>	
        </type>
    </types>
</model>

4.  La dernière étape consiste à redémarrer Tomcat pour qu’Alfresco charge notre modèle personnalisé. Regardez le journal pendant le redémarrage. Vous ne devriez pas voir des erreurs liées au chargement du modèle personnalisé.

Vous pouvez télécharger le modèle personnalisé qu’on a créé via ce lien.

With the new User Script Console extension for Alfresco Share the users finally can access the powerful JavaScript API directly by themselves without needing a specialist. It integrates as a page in a Share site:

Of cause it can not be expected of end users to know JavaScript or the Alfresco APIs right away. That is why the User Script Console slowly introduces the users to the capabilities of the API using a Gamification approach. Users start out as novices and can gain experience (XP) while using the JavaScript API.

User “Experience”

API access gradually changes with increased experience:

• 0 XP = No Alfresco API access
• 10 XP = Read properties and permissions, only document root object
• 1000 XP = Add comments, add Tags to any node
• 5000 XP = Write properties and add tags, Site API, full ScriptNode api
• 10000 XP = Groups API (Add/Remove people from sites)
• 20000 XP = Full Alfresco Javascript API
• 50000 XP = runas admin, access beans using Packages.java

A new user starting out as a novice must first write a syntactically correct JavaScript using given examples. He receives 1 XP for each successful transaction and will soon gain access to some parts of the Alfreco API (XP of 10 or more). Commands above his experience level are not available:

Examples

To help users find their way around, there are examples in the “Examples” menu that are adjusted to the users experience level. It starts out with a list of simple JavaScript examples for “for”-loops and “if”-clauses.

Badges

Additionally users can earn badges for special achievements (each earns 500 XP):

• Unlocker: Unlocked more than 10 documents that were locked by the Sharepoint API.
• Tagmaster: Added 100 different tags to documents
• Ninja: more than 10 “hidden” property changes with behaviourfilter.disableBehaviour()
• Shapeshifter: More than 100 calls of the transformDocument/transformImage
• JsGuru: Run 10 consecutive scripts that all JsLint without any warnings
• Loadtester: Your last 10 scripts have all run longer than 30s
• MrClean: Purge the archive store (nodeArchiveService)
• Reporter: Generation of more than 10000 lines of print output
• Bouncer: Removed at least 100 people from groups/sites
• Hacker: Usage of Packages.java to access Spring beans directly

The new User Script Console will help to empower the savvy user to automate Alfresco in an unprecedented way and lets administrators focus on more important tasks like backup and restore of the Alfresco repository.

Available today for Alfresco 4.1.

Back when we upgraded from 3.4.x to 4.0.2.9, we had a bunch of problems with getting our production database to upgrade properly. Thanks to some really great help from Alfresco’s support team (thanks Kyle!), we were able to successfully manipulate the database to allow the upgrade to complete successfully. The worrisome thing about this is that the databases for our development and QA instances upgraded without a hitch.

Because of that, we learned to always test a major upgrade on a copy of the production database and repository. The only hard thing about that is that making a copy of our nearly-3-TB production repository to be able to test an upgrade is a real pain. This is where the tip from Loftux comes in. He wrote:

Upgrade tip: Create a copy instance from backup with only the database, skip content (alf_data). Then in alfresco-global.properties set system.bootstrap.config_check.strict=false. Then you can run the upgrade and test that all the patches work without having to copy all your content data. This is an important first test. Your instance will not be usable (you have no content), but saves you the trouble copying all that file content.

Thanks Loftux!

Running a Java process as a service has always been somewhat messy and causing headaches. In the typical case of the tomcat lifecyle, there are usually are a bunch of shell scripts involved. This post gives a recipe to hook Alfresco system lifecyle to init and to behave like an admin might expect.

Admins want tomcat to start and stop when the system goes up or down. And they want this to happen in an absolutely reliable way. If they tell it to stop, they want it to stop. They don’t care whether the process is out of memory or stuck for another reason. And most likely, admins do not want the process to run with root privileges. Still it may be required to bind to privileged ports.

System Lifecycle Management Tooling Provided

The interactive Alfresco installer provides you with a shell-script alfresco.sh to start and stop the system. Even database lifecycle is managed by this script if you chose to install the database as well. On top of that, there even is a graphical manager app. There is nothing wrong which these tools – they are great for initial exploration, but they are not really suited for init or upstart and hence, systems in production.

Hooking Alfresco System Lifecycle to Init

I have been writing at least half a dozen init shell scripts to manage lifecycle of Java based daemons. This time I wanted something ready made and maintained by other people. As expected, there is a tomcat7 package for Ubuntu (and other Debians most likely) shipping a fairly decent /etc/init.d/tomcat7 script. It reads configuration from /etc/default/tomcat7, so that is the place to set some variables, such as TOMCAT7_USER, TOMCAT7_GROUP, JAVA_HOME, JAVA_OPTS, AUTHBIND, CATALINA_HOME, CATALINA_BASE and some more. Setting it up is self explanatory. The init-script expects $CATALINA_BASE/conf/policy.d for concatenation as $CATALINA_BASE/work/catalina.policy. I have not checked what the package ships, but assuming it is sane, you can copy it to the Alfresco tomcat installation, e.g.:

cp -r /etc/tomcat7/policy.d /opt/alfresco/tomcat/conf

Beware of tomcat/bin/setenv.sh shipped with Alfresco. It unconditionally sets JAVA_HOME. The init script will fail if the value differs from the one in /etc/default/tomcat7. Hence, it is safer to wrap it:

if [ -z "$JAVA_HOME" ] ; then
    JAVA_HOME=/opt/alfresco_42s/java
    JRE_HOME=/opt/alfresco_42s/java
    JAVA_OPTS="$JAVA_OPTS "
    export JAVA_HOME
    export JRE_HOME
    export JAVA_OPTS
fi

Finally, you may want to try it out

/etc/init.d/tomcat7 start

and create appropriate links for init

sudo update-rc.d tomcat defaults

Beware that alfresco.sh and tomcat7 don’t mix. They both work on their own. But using one to start, the other to stop won’t work. This is due to the different pid file they use.

References

• Image Credits

The post Starting and Stopping Alfresco the Admin Way : Using Init appeared first on CONTENTREICH.

The process of editing goes like this; you create your file in Alfresco, this file is stored in by default as an Open Office XML file (Microsoft Office 2007). You then check this file out, in this case transfer it to Google Docs. This is where the first conversion of file format takes place, from ooxml to proprietary Google Docs format. And we have the first formatting loss. Do your edits, save back to Alfresco. Now we have a second conversion of file format, from Google Docs format back to ooxml, and with that some more formatting loss.

This is what it can look like

You can clearly notice that some formatting gets lost on each edit, and you cannot be sure that your end result is what you expected. I also tested with Open Document format files, result is different formatting loss, but the same basic problem.
As test documents I used OoXML files from ooninja.

I actually think the Google Docs editor is ok for most situations, and if you print the document or export the document to pdf while still in Google Docs, the looks and formatting matches what you see on screen.

So what can be done about this situation?
Not much until Google makes its proprietary document format available. Even if format conversion filters improves a lot I think there will be formatting losses when you have to convert format back and forth each edit. But if you could actually retrieve the Google Docs format file, Alfresco could store this file in the repository. When you need to edit next time, just upload this file to Google Docs, it’s their own format so should be no formatting loss here. Preview could be generated when the checking is done by exporting a pdf from Google Docs. We shouldn’t need to involve other office formats at all.

As stated initially, I think Alfresco engineers have done as good job as possible. The problem here is locking in file formats, only Google can change that. They will probably argue that there is no lock in since you can export content in may different formats. And it may be that it is technically very difficult, I’m still thinking ‘file’ when thinking about document, a document stored in Google Docs format may very well be many fragments split up in a database.

• private cache: managed by the user browser. Can hold the webscript response previously received by that user and serve it without intervention from Alfresco.
  
• public cache: managed by a proxy cache placed between Alfresco and the website. Can hold the webscript response previously received by any user and serve it without intervention from Alfresco.

###
#
#    Minimal configuration file for webscript caching needs of Fastweb    Mind
#
###

##proxy accepting connections on port 80, acting as reverse proxy
http_port 80 accel defaultsite=localhost
##Origin server on localhost:8080, PASSTHRU supports http authentication from the client
cache_peer 127.0.0.1 parent 8080 0 no-query no-digest originserver login=PASSTHRU
acl our_sites dstdomain localhost
http_access allow our_sites
http_access deny all

##avoid caching static resources so cache directory will only hold cached webscript response
##resources can be inspected manually (requested by Leonardo Fenu)
acl images urlpath_regex -i \.(jpg|jpeg|gif|png)(\?.*)?$
acl css urlpath_regex -i \.(css)(\?.*)?$
acl javascript urlpath_regex -i \.(js)(\?.*)?$
cache deny images
cache deny css
cache deny javascript
cache allow all

##max memory available for caching (there aren't many cacheable resources at the moment)
cache_mem       16 MB
#memory_cache_mode      always
##specify disk caching
##parameters after ufs
##1) cache directory
##2) amount space in MB that squid is allowed to use
##3) number of level 1 subdirectories that will be created under cache dir (leave 1 only for simple manual inspection)
##4) number of level 2 subdirectories that will be created under cache dir (leave 1 only for simple manual inspection)
##uncomment to cache on disk so cached resources can be inspected and caches will survive squid restarts
##!!!IMPORTANT see instructions Installation.txt file before enabling disk caching  
#cache_dir ufs /squid 100 1 1

webscripts_caching.zip
File Size:	35 kb
File Type:	zip

Download File

---

...
<!--
This POM manages the lifecycle of an Alfresco Project
        Usage:
            Configure environment dependent properties!
            mvn clean package -Pfull-deploy        builds amp
            mvn process-classes -Pfast-deploy        quickly deploys project files on tomcat
 -->
<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">
...
    <properties>
        <!-- Environment dependent Properties -->
        <tomcatDir>/Users/matteogrolla/Development/alfresco/alfresco-enterprise-4.1.x/tomcat</tomcatDir>

<import resource="classpath:alfresco/templates/webscripts/com/sourcesense/common/cacheUtils.lib.js">

function computeLastModifiedContent(){
   var lm = new Date();
   
   //content has been modified at last time multiple of 10 seconds
   lm.setSeconds( truncate(lm.getSeconds(), 10) );
   
   //content has been modified at the beginning of current minute
   //lm.setSeconds(0);
   
   //content has been modified at the beginning of current hour
   //lm.setMinutes(0, 0);

   //content has been modified today at 8:00
   //lm.setHours(8, 0, 0);

   return lm;
}

function generateModel(){
   value = "computed value"           
   model.value = value;
   model.lastModified = new Date();
   model.lastModifiedContent = computeLastModifiedContent();
   model.now = new Date();
}

//only code may change
//executeIfModified(generateModel);

//code and data may change
//executeIfModified(generateModel, computeLastModifiedContent, {isPublic: true});
executeIfModified(generateModel, computeLastModifiedContent, {maxAge: 10, isPublic: false});

//only code may change
//response can be cached for 5s
//executeIfModified(generateModel, null, {maxAge: 5});

Dokumentenbestände aller Art im Unternehmen wachsen und wachsen. Ab einer gewissen Menge wird es unmöglich mit Fileserver und Disziplin die Kontrolle zu behalten. Enterprise Content Management Systeme (ECMS) versprechen (seit vielen Jahren) Abhilfe und bieten im Kern in der Regel Unterstüzung bei Themen wie Inhaltsablage, Versionierung, Auditing, Sicherheit, Modellierung, Suche, Lebenszylus, Transformation, Metadaten Extraktion, Taxonomy, Workflow etc. Diese Funktionalitäten möchte vermutlich jedes Unternehmen gerne zur Verfügung haben. Das Gute bringt zieht allerdings das Schlechte nach sich. Features bringen Komplexitität mit sich.

Wie sollte man sich als Einsteiger der Materie sinnvoll nähern ?
Kommt ein ECM für mich überhaupt in Frage ?

ECM Hemmschuhe

Dank Open Source und Produkten wie Alfresco oder Nuxeo kann man heute sehr mächtige Systeme auch lizenzkostenfrei bekommen. Dieser alte Hemmschuh muss also heute nicht zwingend noch einer sein.

Bei den lizenzkostenfreien “Community” Varianten stellt sich schnell die Frage nach Support und Gewährleistung. Hersteller und Partner übernehmen diese Aufgaben im freien Community Modell in der Regel nicht.

Kann lizenzkostenfreie Software eigentlich etwas taugen ?

Was mache ich wenn es mit geschäftskritischen Dokumenten im System plötzlich zu Problemen kommt ?

Speziell zu Alfresco gibt es dazu seit Jahren Frage und Antwort “Using Alfresco Community in production” auf stackoverflow. Trotz des Alters denke ich sind die Aussagen heute so aktuell und richtig wie damals. Man kann es also grundsätzlich durchaus wagen. Und um es auszuprobieren reicht es allemal.

Umgang mit Komplexität und kleinem Budget

Vor einigen Jahren hat so mancher Hersteller allein für Installation und Konfiguration eines Test-Systems durchaus ein paar Manntage abgerechnet. Das Setup eines solchen Systems “zum Ausprobieren” sollte heute der nette Adminstrator Kollege auf die Schnelle hinbekommen. Auch das Thema Betrieb ist in der Regel kein Problem für diesen Mitarbeiter.

Mit der Entwicklung verhält es sich da meist etwas anders. Der Kollege der schon mal mit Java programmiert hat kann durchaus schnell überfordert sein, wenn es darum geht das System durch Konfiguration und Logik anzupassen oder einen Bug zu beheben. Entwickler “aufzugleisen” ist schlichtweg aufwendiger als bei anderer Technologie. Diese Tatsache ist unter anderem bedingt durch Funktionsvielfalt der Plattform. Unternehmen müssen klar darüber werden, ob sie man Entwicklungs-Know-How aufbauen wollen oder nicht.

Für eine erste Erkundung schlagen wir in der Regel vor:

• Fachliche Komplexität so gering wie möglich halten
• Einen Spike / Prototypen für einen einfachen Anwendungsfall implementieren
• Funktionälität einsetzen von der man nach einer Recherche sicher sein kann, dass das System sie (nahezu) so liefert wie man es braucht

In der Praxis ist es oft leider so, dass gerade kleine Unternehmen gar nicht wissen welche Funktionalität genau sie wirklich brauchen. Man sollte zumindest den einen oder anderen ganz konkreten Anwendungsfall im Kopf haben.

Auch neigen Einsteiger mitunter dazu fachliche Komplexität zu unterschätzen. In der Vergangenheit habe ich einige Projekte an Komplexität scheitern sehen. Oft, weil dem “you ain’t gonna need it” Prinzip nicht Folge geleistet, und viel Aufwand für Dinge aufgebracht wurde die nie gebraucht wurden oder würden. In einem Fall wollte ein kleiner Mittelständler der bis dato keine ECM Erfahrungen hatte gleich ein Projekt “Revisionssichere Archivierung” umsetzen. Ein Anderer analog “Rechnungseingang und Workflow”. Grundsätzlich sind dies absolut legitime Anwendungen für ein ECM – aber eben keine trivialen Themen für einen Einsteiger mit schmalem Budget. Insbesondere dann nicht, wenn auch die Technik mit der realisiert werden soll noch Neuland für das Unternehmen ist.

Wichtig ist zu akzeptieren das vieles eben nicht klar, und die gesamte Materie auch nicht trivial ist. Mit dieser Einsicht wird der Eine oder Andere feststellen, dass es in so einem Fall nicht unbedingt sinnvoll ist im Vorfeld hausintern lange Konzepte zu schreiben welche man dann einem Dienstleister vorlegt. Wenn man sich erst einmal damit abgefunden hat, dass ein Projekt etwas chaoitisch sein kann kommt man schnell zu agilen Methoden wie Scrum oder Kanban. Diese Methoden sind eben genau auf so ein Szenario ausgerichtet.

Bei Alfresco ist das Thema “Dokumentenaustausch über das Internet” – mit internen und externen Mitarbeitern etwas was sich hervorragend für Einstieger eignet. Mit wenig Aufwand kann man für die meisten Unternehmen schnell echten Wert schaffen und realistische Anwendungsfälle abbilden. Der Anfänger bekommt ein Gefühl für Aspeke von ECM, und lernt einzuschätzen welche weiteren Anwendungsfälle sinnvoll abgebildet werden können. Learning by doing – Gangnam Agile Style.

Referenzen

• Using Alfresco Community in production @ stackoverflow
• Sane Enterprise Software in Germany and Beyond
• Driving a Scrum team at the edge of chaos (Agreement-Certainty Matrix)
• Agile Product Ownership in a Nutshell
• YAGNI Prinzip
• Spike (Agile)
• Image Credits

The post Agile erste Schritte mit Alfresco ECM appeared first on CONTENTREICH.

This post introduces a very simple pure Open Source approach knocking down JVM- and application restarts during development. It may not address every scenario requiring class updates, but it reduced the total amount of restarts significantly for me. Your mileage may vary. My workstation is a Linux system and a part of the approach outlined uses a stacked filesystem. I don’t know whether a stacked filesystem that will do is available on every other OS Juava supports. It may not be required for you at all. Even if, I am fairly sure it is possible to come up with an alternative which does not leverage OS support.

Java Class Reloading : A long History of Pain

Developers’ desire to reload class changes is as old as Java. Official bug entry “4910812 : Enhance Hot Code Replacement” dates back to 2003. The most annoying thing for me is the fact that restarts distract a lot. I tend to switch context, do something else and forget about the restarted application. In fact, reloading pain was a major driver for me to almost convert towards dynamic languages. Sure, the problem is not easy to solve, but there still is demand – not everybody has given up hope yet.

Pain perceived depends on various factors. It may not really matter in situations where restarts are fast, such as in the case of desktop applications. But it can matter a lot when you are working on server side components which need a heavyweight environment bootstrapped to run. One of my heavyweights is a webapp called alfresco repository, and one workaround is trying to avoid the Java language and use a dynamic language instead. I am still doing this and will keep doing it when I feel it makes sense.

Approaches Solutions addressing the bug issue generally separate in to categories, JVM – und agent based ones. The ones I looked at over time did not work for me for one reason or another. JRebel, the canonical choice was ruled out because it is not Open Souce and I don’t like that it wants the IDE to be aware of it. DCEVM and most other efforts seem either dead or immature.

Revisiting Class Reloading

Actually, I was fairly happy with the help offered by dynamic languages. I was watching Graeme Rochers Groovy / Grails Exchange 2012 Keynote where he mentioned that spring-loaded, the agent based reloading solution introduced with Grails 2 is available separately on github. I consider SpringSource and the Grails community trustworthy, so I decided to try adding the missing pieces for my “other than grails day to day” work.

Frankly, the spring-loaded agent source looks ugly, but I guess that is due to current JVM limitations imposed at an agent based solution in general. I doubt JRebel sources look better in this respect. At the end of the day, I don’t really care about how ugly the source looks as long as is works for me and there is no need to understand it.

All the spring-loaded agent requires to work are a few Java command line arguments, e.g. -javaagent:/opt/spring-loaded/springloaded-1.1.1-dev.jar -noverify. Depending on your use case, this may already be most you need besides immediate recompilation of classes whenever they change. Eclipse has “build automatically” set by default and hence does the latter out of the box. I hope IntelliJ has a similiar feature (I am about to switch).

For my current alfresco repository case I needed a way to get the project classes directory “merged” with the one of the webapp. The missing ingredient was a stacking filesystem – I picked FUSE based UnionFS. Layering the directories works like this:

unionfs-fuse /opt/alfresco/tomcat/webapps/alfresco/WEB-INF/classes-default=RO:/home/deas/projects/project-a/target/classes=RO:/home/deas/work/projects/project-b/target/classes=RO /opt/alfresco/tomcat/webapps/alfresco/WEB-INF/classes

This union-mount makes changes of class files in target/classes directories of projects appear immediately in the webapp where they are detected by spring-loaded. Neither spring-loaded nor the IDE need to be aware of what is actually happing.

I have just started using this and I am exploring further possibilities. But it already helps me – a lot. It may help you as well.

Honestly, I wonder why SpringSource is not making serious noise about spring-loaded. I am quite excited already. Thank you guys.

Yes, it is not easy but Oracle should still ship cure with the JVM. This may change a little with Java 8. Bug 4910812 received a fresh comment in December. But even if JVM-level efforts resume, it may still take some more time until hotswap catches up in terms of functionality.

References

• Bug 4910812 : Enhance Hot Code Replacement
• JRebel
• Reloading Java Classes: HotSwap and JRebel — Behind the Scenes
• Dynamic Code Evolution VM
• spring-loaded @ github
• fakereplace @ github
• agentsmith
• Feenix class reloading tool
• unionfs-fuse
• Groovy / Grails Exchange 2012 Keynote
• Image Credits

The post Java Class Reloading Pain : A Fresh Open Source JRebel Alternative appeared first on CONTENTREICH.

ERP, CRM, ECM – Enterprise software can be incredibly frustrating. For some reason, special rules seems apply. I think it is somehow related to the fact that enterprise things tend to change rather slowly. And even more so in Germany. But they do change, no matter whether vendors object and stick to historical principles. The motivation for this post originated from one of the worst enterprise software experiences I encountered. It summarizes what I personally expect from a contemporary product.

Get you started easily

It should be in the best interest of any software vendor to offer a pleasing user experience – in general and for developers in particular if enterprise software is your kind of business. Usually the product will have to integrate somehow. I expect to get playing quickly and painlessly. Provide me with a download and a basic installation procedure. At the try out stage, I don’t care about all the bells and whistles which might need tweaking at some point. I want to get a basic feeling of the product. Please don’t tell me the product is super sophisticated and powerful and hence requires one week of your consultant to set it up. If that happens to be the case, the product is broken. Check out MongoDB, Riak or Elasticsearch (or even Alfresco) to get an idea what I am talking about – delightful in this regard.

Support Developers

Given that enterprise software requires integration work carried out by developers, you should better make sure not annoy them too much. Major painpoints include long turnaround (probably involving server restarts) and lack of public access to (read : googleable) documentation. Why developers matter ? Because at the end of the day, truth is that developers often end up using what they want to use. Their influence on how things evolve is quite strong. You may want to check out the Redmonks predictions page from the references. John Newton from Alfresco seems to have realized that years ago – engineering culture matters … and the enterprise needs a little overhaul. That does not necessarily mean github punks have to invade. Just look at the Alfresco-EMC vendor comparsion and choose for yourself.

Obey the Unix Philosophy

Implement functionality exceptionally well, leverage others where they are really good at and prevent overlap. At the very least, follow the “Rule of Composition” (but the others should not hurt either). I could come up with countless examples of useless features shipped with enterprise software. Paying customers expect serious functionality unless explicitly stated otherwise. Do not frustrate them with immature solutions not labeled as such – not even for free. It will fire back. At the Alfresco Devcon Keynote in Berlin, John Newton said Alfresco will be focusing on what they do really well. That has not always been the case in the past.

Provide excellent support for RESTful HTTP communication – client and server side. The glory days of CORBA, DCOM and RMI are over. Today we know HTTP has beautiful properties for general interprocess communication. On top of that it is the protocol of the cloud.

Embrace the Cloud

Like it or not, applications are moving to the cloud. Cloud issues (legal, security, extensibility) are all being addressed. The application in the cloud will soon be a massive competitive advantage for various reasons – TCO, availabilty, manageability, scalability etc. Sure some people operating on-premise systems might not like the idea, be scared of the cloud and hence object. But it is too late for the most part : “The suits have taken over”. ;)

Be Open

Open Source is of course what we all like most. But it is not a must. I can happily work with closed source software which has a healthy community and information I can find using google. Conversation behind closed doors raises suspicion something is wrong with the company or the product.

No Marketing Nonsense please

Terms such as “integrates seamless” or “modularity” seem to be popular among software marketers. To me, they immediately make an ugly smell when they are not backed reasonably. Sure nobody wants a seam or a huge monolithic island. Everybody wants it smooth and pluggable. But please marketeers – back these terms or leave them. And please if you say “future proof due to standards” – drop at least one word or two which standard you are referring to. Standards are not a good thing per se. In fact, praising them in general also makes a smell for me.

The best (very special) feature advertised in my case was the fact that “data is safe in your RDMBS”. Great, I really appreciate my data being safe. In practice, that boiled down to roughly 40 “meaningful” named tables per tenant. Meaningful in this context meant most of them were called “data_n_m” with a bunch of columns “value_m” and n being the index of the tenant.

References

• Unix philosophy
• IDC-Studie: Cloud Computing in Deutschland 2012 – Evolution der Revolution
• Cloud decisions are no longer in the IT department’s hands – the suits have taken over
• Redmonk predictions and what we really do in IT
• Cloud-Security [quora]
• Does a good engineering culture matter?
• The Enterprise Is Cool Again, and Box CEO Aaron Levie Is Loving It
• Documentum to Alfresco Migration – Comparing Company Visions

The post Sane Enterprise Software in Germany and Beyond appeared first on CONTENTREICH.

I want to start with mentioning one of the simplest included viewers, Embed. It does exactly that, it takes the document content and loads it in an iframe. This means that the browser kicks in a plugin and just render. Lets start with an example for html. Normally you would get the html file converted to flash, but with this config it shown as is.

      <condition mimeType="text/html">
         <plugin testPluginAvailability="false">Embed</plugin>
      </condition>

→ Try out HTML Embed Example.
The property testPluginAvailability=”false” means that the Embed Viewer skips tests if a plugin is available, we do not need this since html always can be rendered by the browser. And just change the condition in the config to mimetype=”text/plain” and you will have the same for plain text files (rendered in browser instead of transformed to flash).
Note that Alfresco sanitize some html tags for security reasons.

Now what if you have a document format, and have installed a special viewer? In this example I have used Visio, and installed a special free viewer downloaded from Microsofts website.
→ Try out Visio Example.

      <condition mimeType="application/vnd.visio">
         <plugin testPluginAvailability="true" ieActiveX="VisioViewer.Viewer.1">Embed</plugin>
      </condition>

Setting testPluginAvailability=”true” means that the Embed viewer will test if the mentioned viewer is actually available. The setting ieActiveX=”VisioViewer.Viewer.1″ is what is tested for in Internet Explorer. That is the ActiveX string found in the Windows registry, you can add many AciveX string separated by comma, the Embed viewer will test each one of them for availability. For other browsers it tests if a suitable plugin is available using the mimetype.

If you are not on Windows, use IE, and do not have Visio Viewer installed, the viewer has probably used it fallback capability, and you will see it using the PdfJs viewer (and so on, see below).

Now for some PdfJs magic. In the Media Viewer we have included the pdf.js library and created what we have called the PdfJs Viewer that will render pdf documents and other documents that can be transformed to pdf directly in the browser.

      <condition thumbnail="pdf">
         <plugin src="pdf">PdfJs</plugin>
         <plugin src="pdf" testPluginAvailability="true">Embed</plugin>
         <plugin src="webpreview" paging="true">WebPreviewer</plugin>
      </condition>
      
      <!-- PdfJS viewer for PDF -->
      <condition mimeType="application/pdf">
         <plugin>PdfJs</plugin>
         <plugin testPluginAvailability="true">Embed</plugin>
         <plugin src="webpreview" paging="true">WebPreviewer</plugin>
      </condition>

What this config does is that it first test if the PdfJs viewer can be used (minimum html5 capable browser). If not, it falls back to the Embed viewer mentioned above. It has built in IE tests for PDF Reader and Foxit reader, if you have others you need to specify them. Again for other browsers, Embed test is done using mimetype, so no need for configuration there.
If the first two options have failed, it uses Alfresco default flash based viewer.
I suggest you try to view these examples with different browsers, and if possible with and without a pdf reader installed, and you should see some of the fallback mechanisms.
→ Try out Large document 151 pages.
→ Try out Grafic intense document. This one take some time to render using PdfJs. I got it to work on iPad as well, but takes a couple of minutes before rendering is complete.
→ Try out Slide Presentation. For this one, try to zoom out, and you will see how nicely the slides flow (thanks to Will Abson css magic). That is, you can only see this if you browser supports PdfJs.

There are many more kinds of viewers included in the Media Viewers project. To use the features shown here, you need to grab the source code and compile yourself for now.
And if you forgot to test the Search capability with syntax highlighting in the PdfJs viewer, now its time to revisit one of the links above with a html5 capable browser.

The strike of the enterprise toys is not over yet and the ones aiming at basic file sharing (such as box or dropbox) have already invaded territory of traditional enterprise content management. The battle is being fought right now. This post is about a new contender – Google.

Is it becoming a threat for enterprise content management ?

You may say : “No way ! Are you crazy ? We neither trust Google nor do we trust the cloud in general. We will never ever use Google Drive or something even remotely similar for enterprise content management ! Besides, we can’t do serious enterprise content management with this new toy anyways.”

Really ?

I guess pretty much everybody I have been talking to in this regard reacts somewhat like this – and even more so when people are from Germany. It reminds me a bit of the situation with the enterprise toys where this kind of “killer counterarguments” was raised. But are they actually reasonable ?

When referring to traditional enterprise content management, what I have in mind are highly transactional process driven on-premise systems in general and Alfresco in particular since I know this one best. With Alfresco in the Cloud and Alfresco One, Alfresco has expanded beyond company firewalls so it is no longer strictly traditional in this sense, but it is still frequently used in this way.

This November, I have been attending the Alfresco Devcon in Berlin and Devoxx in Antwerp one week later. In Antwerp, I chose to join the Google Drive SDK session by Nicolas Garnier. All of a sudden it felt like thunderstruck when I realized the Google Drive product actually has quite some things in common with the Alfresco Platform. In areas such as editing, Google Drive even reaches way beyond. For now I would like to focus on what these systems have in common or where they are tending to converge.

Content Model and -Services: The Basic

First I did a quick comparison of the very basic stuff – CMIS seemed a good start. It looks like Google Drive already has pretty much everything a CMIS implementation is required to have. The main difference today being that the Google Drive API is RESTful JSON instead of SOAP / Atom Pub as demanded by the Spec. In the Q&A part of the session, I asked Nicolas whether Google is targeting the enterprise and if they are planing to offer a full CMIS implementation. The answer to the first question was a bit vague. But the second answer was amazing. Nicolas did not know what CMIS was, so I gave him a brief explanation. Even better: Right after the session, I found CMIS for Google Drive is already there (beta though) and called Cloudoku.

Cloud and Mobile: The Buzz

Clound and mobile, that’s where the Buzz is. You either take these into account or your product may be irrelevant very soon. Alfresco has realized this and they are making serious investments. Have a look at Alfresco in the Cloud, their mobile solution or the Alfresco One product aiming to cover the entire enterprise content lifecycle. Now how does Google compare ?

Regarding mobile, there is a Drive app providing basic content creation and editing capabilities. Not completely equivalent to the Alfresco App but remarkably similar. Alfresco introduced a mobile SDK at the Devcon. Google has a SDK targeting mobile as well.

And the Cloud ? Google Drive (formerly Docs) has always been cloud based. Alfresco in the Cloud has been released this year. Google offers OAuth2 based access for third party applications. If I got it right, Alfresco does the same thing now. The Cloud API has been released in October along with the mobile SDK. Google does not distinguish SDKs between mobile and cloud as Alfresco does, but it is available for various languages and platforms. On top of that, both companies are coming up with desktop sync applications – competition for the “traditional” file sharing enterprise toys.

In addition to a the service based SDK, both platforms provide a Javascript API to build custom user interfaces. Alfresco does not yet allow you to deploy this kind of code in their cloud environment.

Transactions, Processes and Control: The Nasty

Traditional enterprise content management usually is very transactional and process (BPM) driven. Naturally, companies like the idea of having total control of their assets. Unfortunately, these requirements tend to pose tremendous technical challenges. Things are already complicated when you are dealing with shared resources (memory, storage and CPU) within one process, but they get orders of magnitude more complex when this is not the case. Alfresco aims to address these requirements everywhere at once – on-premise, in the cloud and mobile with their Alfresco One product. I cannot tell how well it works in practice.

The simple process scoped solutions already have issues. Introducing custom bugs code always comes at the risk of introducing failure – which in worst case brings the whole system down. This may not be a problem on-premise, but it is a different story in the cloud where functionality is usually backed by multi-tenancy aware software running on shared resources. Hence, SaaS providers may not like the idea of deploying your code.

Alfresco is clearly ahead in terms of the nasty as Google has nothing comparable so far and does not even care yet. But what is holding them back offering an appliance just as they did in search.

Conclusions and Predictions

• I think Google will give the enterprise more attention in the near future
• The biggest roadblock for Google and the cloud in general are based on trust and our perception of security. I am sure Google is aware of that combating it. I am not promoting to just blindly trust the cloud. But I think it is about time to rethink security in general. Do our old policies still hold in 2012 ?
• Alfresco is still quite a bit ahead in terms of functionality, but Google has a vast amount of cloud applications for a wide variety of domains. I am sure there is quite a bit of symbiosis (with regards to content) waiting to be found and released.
• Google Drive may evolve to “Alfresco Community in the Cloud” ;)

These are just my 0.2c. Feel free to let me know what you think.

References

• Rise of The Enterprise Toys
• Why traditional ECM tools like Documentum, FileNet, SharePoint, and Alfresco are not suited for cloud file sharing
• Cloudoku (CMIS for Google Drive)
• How is Cloud Connected Content Different? (Alfresco One)
• Google Drive SDK Session @ Devoxx 2012 (Nicolas Garnier)
• Introducing Google Drive and the Google Drive SDK
• CMIS (Wikipedia)
• Alfresco Content Services
• Google UI Service API
• Share Client-side API / Community 4.2.b

The post Is Google Drive becoming a Threat for Enterprise Content Management ? appeared first on CONTENTREICH.

• Real-time display of formatting when editing
• Sortable topics
• Movie, Copy and Delete topics including subtopics
• Insert standard Alfresco images and icons
• Upload custom images via dialog box or drag and drop
• Insert custom image size, transformed using Alfresco thumbnails
• Custom templates for new content, repository default stored in Data Dictionary or Site specific
• Manage versions, quickly view what previous versions looked like.
• Print an individual topic or include all subtopics, each topic includes edit metadata in footer
• Page content is loaded using ajax, then formatted client side so page loading is superfast

Of course this need not only to be used for Software manuals, it can be use for any type of documentation. One use case could be for project minutes, using the template feature to add a default minute template.

I will release this add-on soon. It will be a paid-for add-on, I have yet to decide on how.
Meanwhile, I have created a video where you can see how the Manual Manager works.

http://www.youtube.com/watch?v=iTn-lJozYkM

Es macht folgende Einschränkungen:

• Jeder Site-Benutzer ist mindestens einer der vier Gruppen welche bei der Zuweisung der Berechtigungen an Inhalten zur Verfügung stehen zugeordnet.
• Globale Gruppen können nur vom Administrator angelegt werden und führen neue Komplexität ein.

Das Contentreich Alfresco add-on Site Gruppen kann alternativ zu der Standard-Gruppenfunktionalität mit Hinblick auf Zugriffsrechte für bestimmte oder alle Sites eines Repositories genutzt werden.

Es bietet:

• Beliebig viele site-lokale Gruppen die von Site-Managern verwaltet werden können
• Zusätzliche Zuweisung von Berechtigungen für lokalen Gruppen
• Zuweisung von Personen zu den site-lokalen Gruppen bevor eine Einladung angenommen wird

Im Zusammenhang mit Zugriffsberechtigungen ist es wichtig zu verstehen, dass Berechtigung grundsätzlich gewährt wird. Verboten wird in diesem Sinne nicht explizit, sondern implizit dadurch, dass keine Erlaubnis erteilt ist.

Vorraussetzung für dieses add-on ist Alfresco ab Version 4. Das folgende Video illustriert die Funktionsweise mit einem Anwendungsfall.

Referenzen

• Individuelle Alfresco Share Gruppen

The post Contentreich Alfresco add-on – Site Gruppen appeared first on CONTENTREICH.

In einer Alfresco Out-of-the Box Installation kommt der Email-Adresse eine weniger bedeutsame Rolle zu. Gründe dafür sind unter anderem, dass im Enterprise Umfeld oftmals andere externe Systeme zur Authentifizierung genutzt werden die nicht die Email-Adresse zur Identifikation eines Benutzers nutzen (z.B. Active-Directory). In so einem Szenario ist es oftmals auch nicht möglich schreibend auf die Datenbestände zuzugreifen, so dass “Passwort vergessen” nicht immer ohne weiteres realisierbar ist.

Das Contentreich Alfresco add-on Email ist für Anwendungen gedacht welche der Email-Adresse als Schlüssel zur Identifikation von Usern allgemein höherere Bedeutung beimessen als Alfresco es von Haus aus tut.

Es bietet folgende Funktionalität:

• Vermeidung von mehrfach angelegten Benutzeren – insbesondere im Rahmen von Einladungen aus Share Sites
• Erweiterung der Personen Suche um Email-Adresse
• Erzwingung von eindeutigen Benutzer Email-Adressen durch Behaviour (optional)
• Share login mit Username oder Email-Adresse
• Prozess Passwort vergessen

Grundsätzlich ist es nicht zwingend notwendig, dass Alfresco ausschließlich die native Authentisierung nutzt. Es können also durchaus zusätzlich Active Directory oder andere externe Authentisierungs-Komponenten genutzt werden.

Unterstützt wird Alfresco ab Version 4. Das folgende Video illustriert die Funktionsweise dieses add-on.

Referenzen

• Doppelte Alfresco Share Benutzer vermeiden

The post Contentreich Alfresco add-on – Email appeared first on CONTENTREICH.

Wir möchten unseren Kunden zukünftig Contentreich add-ons zur Verfügung stellen, die ähnlich den gängigen Browser add-ons zur Laufzeit aktiviert und deaktiviert werden können.

Im Vorfeld müssen diese Erweiterungen in die Alfresco Umgebung eingespielt werden. Diverse zusätzliche Anpassungen an der Alfresco Konfiguration (z.B. XML Anpassungen von Hand) sollten bei kleineren Erweiterungen der Vergangenheit angehören.

Im nachfolgenden Screenshot könnt ihr unsere Erweiterungen innerhalb der Contentreich Alfresco Umgebung sehen (Share und Repository seitig):

In folgenden Video könnt ihr euch davon überzeugen, wie einfach add-ons zur Laufzeit aktiviert und deaktiviert werden. Ein einfacher Browser Reload und die add-ons können benutzt werden. So macht Alfresco Erweiterung Spass ;-)

Contentreich add-ons Teil 1:

• “Theme-Erweiterung”,
• “Login mit Email oder Username” und
• “Passwort vergessen” Funktion

Hinweis: Bei dem “Passwort vergessen” add-on haben wir uns funktional weitestgehend am bestehenden ResetPasswordDialog add-on (siehe share-extras) von Will Abson orientiert.

Dieses Video ist nur ein Ausschnitt aus unserer add-ons Sammlung. In den kommenden Tagen und Wochen kommt noch mehr!

The post Contentreich Alfresco add-ons appeared first on CONTENTREICH.

Die neue Rich Media Gallery View, die neuen Suche Dashlets, einfaches Sharing von Inhalten und Vieles mehr, machen die Zusammenarbeit im Alfresco Share noch einfacher und effektiver.

Wir haben euch fünf Video Reviews für diese Neuerungen innerhalb der Benutzeroberfläche von Share vorbereitet. Diese Videos präsentieren unsere ganz persönlichen Eindrücke vom neuen Release.

Fazit für uns (mit einer kleinen Einschränkung, Solr funktioniert bei uns nach dem Umstieg noch nicht) :

Ein Umstieg auf die 4.2.a lohnt sich :)

Review Teil 1: Erweiterungen am My Task Dashlet

Review Teil 2: Die neuen Search und Saved Search Dashlets

Review Teil 3: Image Preview Dashlet und Rich Media Gallery View

Review Teil 4: Zip Download und Quick Share

Review Teil 5: Single Click Google Docs Integration

Wir hoffen die Video Reviews konnten euch bei eurer Entscheidung für oder gegen die Version 4.2.a helfen.

Update: Mit der 4.2.a gab es einen Fehler bei Einladung via Email. Dieser wird mit Version 4.2.b laut Alfresco gefixt (siehe ALF-16436)

In den kommenden Tagen möchten wir euch die neuen Erweiterungsmöglichkeiten von Alfresco Share vorstellen und versprechen euch einen Einblick in eine ganz neue, unkomplizierte Vorgehensweise :) .

The post Alfresco Community 4.2.a Review appeared first on CONTENTREICH.

Back in 3.4.x, I usually monitored the log file with the command:

tail -500f /usr/share/tomcat/logs/catalina.out | grep -v "^\Wat"

What that does is to strip out all of the stack traces from the log (all of the lines beginning with ” at”), making the log file much more readable. As this was just affecting which lines are displayed, not what’s actually in the log file, I could turn off the grep filtering if I ever wanted the complete version for troubleshooting.

However, in 4.0.2.9, there’s a lot more spurious stuff in there. In addition to the stack traces, there’s also:

1) Very frequent repetitions of the lines:

Sep 7, 2012 3:35:03 PM org.apache.tomcat.util.http.Parameters processParameters
WARNING: Parameters: Invalid chunk '' ignored.


2) Complete copies of the raw HTML of the error page served up whenever a HTTP 500 (internal error) error occurs.

3) A bunch of blank lines

So, this afternoon, after a bit of chatter about this on the Alfresco IRC channel, I decided I really needed a better version of my log file monitoring command. Here’s what I developed:

tail -7500f /usr/share/tomcat/logs/catalina.out | perl -nle 'print if (($_ !~ /^\W*[<a\.]/) && ($_ !~ /^$/) && ($_ !~ /org.apache.tomcat.util.http.Parameters processParameters/) && ($_ !~ /Invalid chunk/))'

Note that the line above scrolls sideways so it doesn’t get word-wrapped incorrectly.

To break down the individual portions of that perl “print if” command:
($_ !~ /^\W*[<a\.]/): Don’t print any lines that begin with whitespace (optional), followed by either a “<” (getting rid of the error 500 HTML lines); an “a” (getting rid of the ” at” lines); or a “.” (getting rid of the ” … 40 more” lines)

($_ !~ /^$/): Don’t print any blank lines

($_ !~ /org.apache.tomcat.util.http.Parameters processParameters/): Get rid of the lines containing “org.apache.tomcat.util.http.Parameters processParameters”

($_ !~ /Invalid chunk/): Get rid of the lines containing “Invalid chunk”

This isn’t an earth-shattering improvement, but it does make the log file a bunch easier to read, for me at least.

Now it is perfectly acceptable to write AND yourself between keywords (feel free to try), but we want it automatically. There is an issue ALF-6349 where it is described how it can be done generally to all searches by changing the Search.java to make it configurable via the bean definition. The problem with introducing the change is that when you have already selected a default (OR) you can not just change when a number of components and their adaptations may depend on current behavior, and we can have unexpected bugs.

My solution was instead to change only how Share quick search behaves, also here a change is needed for projects/repository/source/java/org/alfresco/repo/jscript/Search.java by extending the class when the search is done with the javascript search object to be able to take a new parameter, andOperator: boolean optional, if true, use the AND operator, defaults to false (OR) .
Next file to change is projects/remote-api/config/alfresco/templates/webscripts/org/alfresco/slingshot/search/search.lib.js
We can now use a parameter in the serach
var queryDef = {
query: ftsQuery,
language: "fts-alfresco",
page: {maxItems: params.maxResults * 2}, // allow for space for filtering out results
templates: getQueryTemplate(),
defaultField: "keywords",
onerror: "no-results",
sort: sortColumns,
andOperator: true
};
In this file there is also one more change needed,ftsQuery += ' AND (+TYPE:"cm:content" OR +TYPE:"cm:folder")' an OR needs to be inserted here, else we get AND (since this is now default).
The last file to change is projects/remote-api/config/alfresco/templates/webscripts/org/alfresco/slingshot/search/search.get.config.xml
<search>
<default-query-template>%(ALL)</default-query-template>
</search>
We need to change the default query template, else all terms will get AND and the results are no hits. But we instead use the magic keyword ALL, not only does our search work, it will automatically search all your custom metadata fields too (you can try this in the quick search using ALL:<your term>).

I will attach a complete diff for my changes to the issue ALF-6349.

• The webscript e.g. /datalists/data/node/workspace/SpacesStore/dae615e9-1d08-483f-a19b-69b30b5bffed (that’s the Datalist’s nodeRef) is called
• A list of columns (from Share’s form configuration) and filter criteria are sent to the repository as well
• The repository webscript runs a lucene search (using the filter criteria, if set)
• It loops over the result
• for each result Evaluator.run() (from evaluator.lib.js) is called
• Evaluator.run() uses the FormService to build the fields
• The FormService builds the complete form from the datamodel (including model, data values, contraints)
• For each field with a ListConstraints alle the values are localized (new in 3.4.8)
• A ListValueConstraint’s getAllowedValues() and getDisplayLabel() are called potentially thousands of times.

What we know

What’s wrong here? Several things. It starts with the search which is not very fast. In Alfresco 3.4.x a lucene PATH query is used here which is known to not be very fast, espcially with large repositories or when the lucene index is not stored on a really fast disk. For the document library Jeff Potts has suggested to use node.children instead of the lucnene PATH query to speed things up. Of course this only works if no filters are used.

Another issue with the search that adds to the performance problems of the datalists, is, that the whole datalist is read into the browser at once. There is no server side paging implemented for datalists which means that if you have 1000 rows in the datalist you have to wait for the browser to load all the 1000 rows before the first 50 are displayed. Stefano Argentiero has suggested a modification to the Alfresco datalist to add server side pagination which whould also help speeding up the datalist rendering.

Stefano Argentiero realized that running the Evaluator.run() function for each row takes a lot of time, but why is that? The Evaluator function calls the FormService for each row and constructs the whole form. This means that all field defintions are built, including contraints and for ListContraints even all the individual contraint values are collected. Since the fields are only displayed in the datalist (mode=”view”) these contraints values are never needed at all.

The new localization doesn’t help

With a change in Alfresco 3.4.9 (ALF-9514) each of these contraint values are even localized. That means if you have 1000 rows in the table and one field with a list contraint of 100 values (not uncommon) your ListContraint’s getDisplayLabel() and getAllowedValues() methods are easily called 100000 times when the datalist model is built in the webscript.

Anyone upgrading to Alfresco >=3.4.8 who is using custom ListContraints should make sure that…

• Your getAllowedValues() method returns a cached List as quickly as possible
• If you don’t need localized constraint values overwrite the getDisplayLabel() method to simply return the value to skip the localization code.

What can be done?

Apart from the issues that this new localization introduced I still wanted to have the datalist displayed as fast as possible. Calling the FormService and building the whole form over and over again for each row didn’t strike me as a smart approach. I looked into the evaluator.lib.js to see if can be removed for good

This is the block from evaluator.lib.js calls the FormService and extracts the data that is returned:

// Use the form service to parse the required properties
scriptObj = formService.getForm("node", node.nodeRef, fields, fields);

// Make sure we can quickly look-up the Field Definition within the formData loop...
var objDefinitions = {};
for each (formDef in scriptObj.fieldDefinitions)
{
 objDefinitions[formDef.dataKeyName] = formDef;
}

// Populate the data model
var formData = scriptObj.formData.data;
for (var k in formData)
{
 var isAssoc = k.indexOf("assoc") == 0,
	value = formData[k].value,
	values,
	type = isAssoc ? objDefinitions[k].endpointType : objDefinitions[k].dataType,
	endpointMany = isAssoc ? objDefinitions[k].endpointMany : false,
	objData =
	{
	   type: type
	};

 if (value instanceof java.util.Date)
 {
	objData.value = utils.toISO8601(value);
	objData.displayValue = objData.value;
	nodeData[k] = objData;
 }
 else if (endpointMany)
 {
	if (value.length() > 0)
	{
	   values = value.split(",");
	   nodeData[k] = [];
	   for each (value in values)
	   {
		  var objLoop =
		  {
			 type: objData.type,
			 value: value,
			 displayValue: value
		  };

		  if (Evaluator.decorateFieldData(objLoop, node))
		  {
			 nodeData[k].push(objLoop);
		  }
	   }
	}
 }
 else
 {
	objData.value = value;
	objData.displayValue = objData.value;

	if (Evaluator.decorateFieldData(objData, node))
	{
	   nodeData[k] = objData;
	}
 }
}

This can be easily replaced by that following block of code which doesn’t use the FormService at all:

// Populate the data model
for each(k in fields)
{
 var value = node.properties[k], objData = {};
 if (value) {
	var formkey = "prop_" + k.replace(":", "_");

	if (typeof value == "boolean") {
		objData.type = "boolean";
		objData.value = value;
		objData.displayValue = objData.value;
		nodeData[formkey] = objData;
	}
	else if (value && value.getMonth)
	{
	objData.type = "date";
		objData.value = utils.toISO8601(value);
		objData.displayValue = objData.value;
		nodeData[formkey] = objData;
	}
	else
	{
		objData.type = "text";
		objData.value = value ? value : "";
		objData.displayValue = objData.value;
		if (Evaluator.decorateFieldData(objData, node))
		{
			nodeData[formkey] = objData;
		}
	}
}
else {
	var assoc = node.assocs[k];
	if (assoc && assoc.length > 0) {

		var formkey = "assoc_" + k.replace(":", "_");
		nodeData[formkey] = [];

		for each(var value in assoc) {

			objData.type = value.typeShort;
			objData.value = value.nodeRef;
			objData.displayValue = objData.value;
			if (Evaluator.decorateFieldData(objData, value))
			{
				nodeData[formkey].push(objData);
			}
		}
	}
}
}

Does it help?

I tested this change using a datalist with 1000 rows and 6 columns with one column having a list contraint (about 30 values). With this configuration the original webscript returned in about 2.4s (on a fast dev system). Using my patched evalator.lib.js without the call to the FormService the same datagrid is displayed in 870ms. This is more than a 2x increase in performance. Depending on the number of rows and constraints your results may vary.

I didn’t need all the features that can be modeled in the datalist so this change does NOT support all the features of the original implementation:

• Multivalue properties are currently not supported (could be easily added)
• NodeRef properties are currently not supported (could be easily added)
• You can not change the datalists values in the grid using FormFilters any more
• maybe other things are broken…

Maybe this well help some of you out there to improve the performance of the datalists in your Alfresco solutions.

In the recently-released Mac OS X 10.7.4 update, Apple has implemented changes to its WebDAV client that dramatically speed up connections. If you are connecting to Alfresco by mounting it in the Finder, you’re in for a much improved experience, especially if you’re using the authentication chain to allow users to authenticate against an external authN/Z provider.

In our environment, these speed-ups are on the order of 2.5 times faster. This is especially evident when browsing between folders or working with large numbers of small files.

These changes also make the WebDAV connections more reliable and stable.

So, if you’re using Mac OS X Finder to connect to Alfresco, I’d strongly recommend updating to Mac OS X 10.7.4.

From a technical point of view, all they did was to add support for session cookies to the WebDAV client.

To connect to the Alfresco from the Mac OS X Finder, here’s what you do:

1. In the Finder, choose Connect to Server… from the Go menu
2. Enter https://alfresco.companyname.com/alfresco/webdav in the Server Address: field of the window that appears.

   A question for the audience: In our environment (tomcat running behind Apache, where Apache is set to do a 302 redirect from http to https), entering “http://&#8221; instead of “https://&#8221; does not see the speed benefits mentioned here. I’d appreciate any thoughts about why this might be happening.

3. Click the + button to the right of the server address field to add it to the Favorite Servers list, for easier future access.
4. Click Connect and enter your Name and Password when prompted.
5. You’ll see a “webdav” disk appear on your desktop. You can now use that like any other disk on your system.

Until this update was released, we had been recommending that Mac OS X users use Cyberduck to connect to WebDAV on Alfresco. Cyberduck is still somewhat faster than the Mac OS X Finder, but this update makes the Finder much more usable, and suitable for most uses.

In Share, when I need to alter default functionality I start with looking into the page I need to change, and then find out how this page is called, and if I can add parameters or need to change javascript. In this case it is page/site/{site}/edit-metadata that I somehow need to tell to use a different form. This page use template-instances/edit-metadata.xml, and in there is a form component

<!-- Edit Metadata Form -->
<component>
  <region-id>edit-metadata</region-id>
  <url>/components/form</url>
  <properties>
    <itemKind>node</itemKind>
    <itemId>{nodeRef}</itemId>
    <mode>edit</mode>
    <submitType>json</submitType>
    <showCaption>true</showCaption>
    <showCancelButton>true</showCancelButton>
  </properties>
</component>

The form is rendered using the webscript /components/form, now I need to find out if there is a way to pass in a form id. I then look in folder site-webscripts/org/alfresco/components/form/ to find out how the form generation works, form.get.html.ftl includes form.lib.ftl and in there I can see that you can pass formId as an argument. I can now either alter template-instances/edit-metadata.xml, or use the new Surf extensibility functionality (from version 4.0). With a surf extension i add to site-data/extension a file called myextension.xml with content

<extension>
	<modules>
		<module>
			<id>ReplaceForm</id>
			<description>Show edit metadata for specific form</description>
			<components>
				<component>
					<scope>template</scope>
					<region-id>edit-metadata</region-id>
					<source-id>edit-metadata</source-id>
					<sub-components>
						<sub-component id="default">
							<evaluations>
								<evaluation id="hide">
									<render>false</render>
								</evaluation>
							</evaluations>
						</sub-component>
						<sub-component id="edit-metadata-new" index="25">
							<url>/components/form</url>
							<properties>
								<itemKind>node</itemKind>
								<itemId>{nodeRef}</itemId>
								<formId>{formId}</formId>
								<mode>edit</mode>
								<submitType>json</submitType>
								<showCaption>true</showCaption>
								<showCancelButton>true</showCancelButton>
							</properties>
						</sub-component>
					</sub-components>
				</component>
			</components>
		</module>
	</modules>
</extension>

I will not go into details about surf extension, instead watch the Alfresco Webinar about Surf extension with David Draper and read the slides. What happens when this customization is applied is that the default component is replaced by one that can take formId as url parameter. You can easily test this (when above extension is applied) by navigating to page edit-metadata and in the end of the url add &formId=doclib-simple-metadata. You will se the form that is normally just used for the popup edit metadata dialog in the full page edit.

So now I need a way to call this page with the formId parameter. The edit-metadata page is opened using a document library action, so I need to append the formId parameter if (and only then) the aspect in question is used. From version 4.0 this is in configuration that you can easily alter. The default config for actions is found in share/WEB-INF/classes/alfresco/share-documentlibrary-config.xml. From there I came up with this config that you can put in share-config-custom.xml

  <config evaluator="string-compare" condition="DocLibActions">
    <!-- Action definitions -->
    <actions>
      <action id="document-edit-metadata" type="pagelink" label="actions.document.edit-metadata">
        <param name="page">edit-metadata?nodeRef={node.nodeRef}</param>
        <permissions>
          <permission allow="true">Write</permission>
        </permissions>
        <evaluator negate="true">evaluator.doclib.action.isLocked</evaluator>
        <override>document-edit-properties</override>
      </action>
      <action id="document-edit-metadata-diarie" type="pagelink" label="actions.document.edit-metadata">
        <param name="page"><![CDATA[edit-metadata?nodeRef={node.nodeRef}&formId=diarie]]></param>
        <permissions>
          <permission allow="true">Write</permission>
        </permissions>
        <evaluator>evaluator.isDiarieNotLocked</evaluator>
        <override>document-edit-metadata</override>
        <override>document-edit-properties</override>
      </action>
    </actions>

    <!-- Action Group definitions -->
    <actionGroups>
      <actionGroup id="document-browse">
        <action index="130" id="document-edit-metadata" />
        <action index="130" id="document-edit-metadata-diarie" />
      </actionGroup>
      <actionGroup id="document-details">
        <action index="120" id="document-edit-metadata-diarie" />
      </actionGroup>
    </actionGroups>
  </config>

It does two things, first I replace the popup metadata edit in browse mode, I want the full page. So that is why the default config for action ‘document-edit-metadata’ is added. I cannot only add this action to Action group definitions, because then you will see both, that is why I redefine the action, but now with an override to hide document-edit-properties if used. Next is to add my new action ‘document-edit-metadata-diarie’ that has the formId parameter. Note that it needs enclose the parameter in CDATA to be valid xml. If the evaluator returns true, then use this one and override the others. So next we need to define the evaluator.isDiarieNotLocked. Default evaluators can be found in share/WEB-INF/classes/alfresco/slingshot-documentlibrary-context.xml. Put yours in a mycustom-context.xml file in the class-path.

  <bean id="evaluator.hasdiariefordaspect" parent="evaluator.doclib.action.hasAspect">
    <property name="aspects">
      <list>
        <value>lx:diarieFord</value>
      </list>
    </property>
  </bean>
  <bean id="evaluator.isNotLocked" parent="evaluator.doclib.action.chainedMatchOne">
    <property name="evaluators">
      <list>
        <ref bean="evaluator.doclib.action.notEditable" />
      </list>
    </property>
    <property name="negateOutput" value="true" />
  </bean>
  <bean id="evaluator.isDiarieNotLocked" parent="evaluator.doclib.action.chainedMatchAll">
    <property name="evaluators">
      <list>
        <ref bean="evaluator.hasdiariefordaspect" />
        <ref bean="evaluator.isNotLocked" />
      </list>
    </property>
  </bean>

So my evaluators does this, evaluator.hasdiariefordaspect checks that is has the required aspect, evaluator.isNotLocked evaluates if it can be edited and is not locked (this one propbably can be defined in a smarter way, but it works), then finally put together in evaluator.isDiarieNotLocked where we need both previous evaluators to be true. If you want to learn more about Share Document library extension read Mike Hatfields blog.

And finally we have customized Share to use a specific form for edit metadata when the document has the selected aspect applied. With only configuration files!

Note that my approach lets user with a bit of knowledge add whatever form id they want in the url, and thus potentially edit hidden metadata. In this use case it was not considered an issue.

With many thanks to Alex Strachan and Chris Turner, I’ve been able to greatly improve the script and have it do a somewhat deeper examination of how the files on disk are referenced by tables in the repository. I’ve also greatly cleaned up the script, so it should be easier to understand and modify for use in your environment. (For example, the 7 variables at the start of the script are all you need to change, rather than having to do a search-and-replace for that info throughout.)

First, some background on the structure of the Alfresco database in terms of how it refers to files:

1. At the lowest level, the alf_content_url table directly contains the paths to the files on disk corresponding to nodes in the repository, as well as their sizes.
2. The alf_content_data table contains things like the mime type and content encoding, and refers to the alf_content_url table.
3. Finally, 3 tables refer to entries in the alf_content_data table: alf_node_properties, avm_nodes, and alf_audit_model.

The script below is designed to check all of that for consistency. That is, it will let you know if the 5 tables above all map correctly down to files on disk.

Important notes:

1. Use the script below at your own risk, especially the “Files on disk that are not in the Alfresco DB. Can be backed up, then deleted.” bit. Unless you thoroughly understand what this script is doing and are comfortable with it, be very careful here. You could badly damage your Alfresco repository.
2. This is only a reporting tool. If it reports errors in your repository, some may be harmless, some may be indicative of a real problem. This is meant as a starting point for investigations into potential problems, not as a fix for those problems.
3. Even though the script below only reads from the database and files on disk, and doesn’t make any changes, it’s still a really good idea to have a good backup of the repository and database before running this.

The Script

I’m running EE 3.4.8 on RHEL5 and MySQL, and that’s what this script is written for. It shouldn’t be that hard to modify it for use on other platforms or other databases.

#!/bin/bash

#update the 7 variables below to correspond to your environment
DB_HOST=dbhost.company.com
DB_PORT=3306
DB_NAME=alfresco
DB_USER=alfresco
DB_PASS='alfresco'
REPO_PATH="/var/lib/alf_data/contentstore"
TMP_PATH="/tmp/check_db/"

#You may not need to modify anything below this line unless you are adapting
#this script to a different platform
ORIG_WD=`pwd`
mkdir -p $TMP_PATH
cd $TMP_PATH

ESCAPED_REPO_PATH=$(printf "%s\n" "$REPO_PATH" | sed 's/[][\.*^$/]/\\&/g')

#Get the list of files the DB thinks are on disk
/usr/bin/mysql --skip-column-names -u $DB_USER --password=$DB_PASS \
-h $DB_HOST -P $DB_PORT -e "select content_size, content_url FROM alf_content_url " \
$DB_NAME | /bin/sed 's/store:\//\./' | /bin/sort -n --field-separator='/' -k2 -k3 -k4 \
-k5 -k6 -k7 > compare_db_results.txt

#Get the list of files that are actually on disk
/usr/bin/find $REPO_PATH -type f \
| /usr/bin/xargs du -b | /bin/sed "s/$ESCAPED_REPO_PATH/\./" \
| /bin/sort -n --field-separator='/' -k2 -k3 -k4 -k5 -k6 -k7 > compare_file_results.txt

#Compare the list of files from the DB to the list from disk
/usr/bin/diff compare_db_results.txt compare_file_results.txt \
| /bin/sort --field-separator='/' -k2 -k3 -k4 -k5 -k6 -k7 > compare_store_diff.txt

diff_sizes=`/usr/bin/uniq -f2 -D compare_store_diff.txt | grep "[<>]" | \
/bin/sed 's/^>/---\n>/'`
if [ -n "$diff_sizes" ]
then
    echo "WARNING: Files that have different sizes on disk than what's listed in the DB"
    echo "$diff_sizes"
fi

not_on_disk=`/usr/bin/uniq -f2 -u compare_store_diff.txt | /bin/grep "<"`
if [ -n "$not_on_disk" ]
then
    echo
    echo "WARNING: Files listed in the Alfresco DB that are not on disk"
    echo "$not_on_disk"
fi

not_in_db=`/usr/bin/uniq -f2 -u compare_store_diff.txt | /bin/grep ">"`
if [ -n "$not_in_db" ]
then
    echo
    echo "Files on disk that are not in the Alfresco DB. Can be backed up then deleted."
    echo "$not_in_db"
fi

#get the list of nodes that appear in alf_content_data
mysql -N -u $DB_USER --password=$DB_PASS -h $DB_HOST -P $DB_PORT -e \
"select id FROM alf_content_data" $DB_NAME | sort -un > alf_content_data_ids.txt

#get the list of nodes that appear in alf_node_properties
mysql -N -u $DB_USER --password=$DB_PASS -h $DB_HOST -P $DB_PORT -e \
"select long_value FROM alf_node_properties anp WHERE (anp.actual_type_n=21)" $DB_NAME | \
sort -un > alf_node_properties_long_value.txt

#get the list of nodes that appear in avm_nodes
mysql -N -u $DB_USER --password=$DB_PASS -h $DB_HOST -P $DB_PORT -e \
"select substring(content_url,4) FROM avm_nodes" $DB_NAME  | sort -un > \
avm_nodes_content_url.txt

#get the list of nodes that appear in alf_audit_model
mysql -N -u $DB_USER --password=$DB_PASS -h $DB_HOST -P $DB_PORT -e \
"select content_data_id FROM alf_audit_model" $DB_NAME | sort -un > \
alf_audit_model_content_data_id.txt

echo
echo "Unique entries in alf_content_data"
perl -nle 'print if /^\d+$/' alf_content_data_ids.txt | wc -l

echo "Unique entries in alf_node_properties"
perl -nle 'print if /^\d+$/' alf_node_properties_long_value.txt | wc -l

echo "Unique entries in avm_nodes"
perl -nle 'print if /^\d+$/' avm_nodes_content_url.txt | wc -l

echo "Unique entries in alf_audit_model"
perl -nle 'print if /^\d+$/' alf_audit_model_content_data_id.txt | wc -l

echo
echo "Unique entries in use (alf_node_properties + avm_nodes + alf_audit_model)"
cat alf_node_properties_long_value.txt avm_nodes_content_url.txt \
alf_audit_model_content_data_id.txt | sort -un | perl -nle 'print if /^\d+$/' > \
entries_in_use.txt
cat entries_in_use.txt | wc -l

echo
echo "In alf_content_data but not in any of alf_node_properties, avm_nodes, or \
alf_audit_model"
diff alf_content_data_ids.txt entries_in_use.txt | perl -nle 'print if /^< \d+$/' | wc -l

echo "In alf_node_properties but not alf_content_data"
diff alf_content_data_ids.txt alf_node_properties_long_value.txt | \
perl -nle 'print if /^> \d+$/' | wc -l

echo "In avm_nodes but not alf_content_data"
diff alf_content_data_ids.txt avm_nodes_content_url.txt | \
perl -nle 'print if /^> \d+$/' | wc -l

echo "In alf_audit_model but not alf_content_data"
diff alf_content_data_ids.txt alf_audit_model_content_data_id.txt | \
perl -nle 'print if /^> \d+$/' | wc -l

diff alf_content_data_ids.txt entries_in_use.txt | perl -nle 'print if /^< \d+$/' | \
/bin/sed 's/^< //'  >limbo_nodes.txt

nodes_to_check=`perl -pe 's/\n/, /g' limbo_nodes.txt | /bin/sed 's/, $//'`
if [ -n "$nodes_to_check" ]
then
    echo
    echo "Listing of node IDs in alf_content_data that are not in any of \
alf_node_properties, avm_nodes, or alf_audit_model"
    echo "$nodes_to_check"

    echo
    echo "Files corresponding to the node IDs in alf_content_data that are not in any of \
alf_node_properties, avm_nodes, or alf_audit_model"
    mysql -N -u $DB_USER --password=$DB_PASS -h $DB_HOST -P $DB_PORT -e \
    "select acu.content_url from alf_content_data acd, alf_content_url acu where acd.id \
in ($nodes_to_check) AND acd.content_url_id=acu.id;" $DB_NAME | \
    sed "s/store:\//$ESCAPED_REPO_PATH/"
fi

cd $ORIG_WD
rm -rf $TMP_PATH

Example Results

Clean repository

The output from running this script against a fully-intact repository looks like:

Unique entries in alf_content_data
15426
Unique entries in alf_node_properties
14459
Unique entries in avm_nodes
962
Unique entries in alf_audit_model
5

Unique entries in use (alf_node_properties + avm_nodes + alf_audit_model)
15426

In alf_content_data but not in any of alf_node_properties, avm_nodes, or alf_audit_model
0
In alf_node_properties but not alf_content_data
0
In avm_nodes but not alf_content_data
0
In alf_audit_model but not alf_content_data
0

Less-clean repository

The output from running this script against a repository thats still functioning perfectly normally, but has a few issues, looks like the following. In other words, if you get output like this, don’t panic! Everything may still be OK:

WARNING: Files that have different sizes on disk than what's listed in the DB
---
> 0	./2012/3/13/14/29/12296f59-d5f6-4c4c-af0d-16583aa299ad.bin
< 270	./2012/3/13/14/29/12296f59-d5f6-4c4c-af0d-16583aa299ad.bin
---
> 0	./2012/3/13/14/29/74f4bb37-440b-4c4d-b118-85aa7c2d3602.bin
< 274	./2012/3/13/14/29/74f4bb37-440b-4c4d-b118-85aa7c2d3602.bin
---
> 0	./2012/3/13/14/29/a03d4b7c-090f-4535-ae6f-fd7ceebf3233.bin
< 352	./2012/3/13/14/29/a03d4b7c-090f-4535-ae6f-fd7ceebf3233.bin
---
> 0	./2012/3/13/14/29/dd9d0e21-78a2-419e-a640-d413243cbb33.bin
< 322	./2012/3/13/14/29/dd9d0e21-78a2-419e-a640-d413243cbb33.bin
---
> 0	./2012/3/13/14/29/dfba42f6-4de8-4ba8-bfac-570dc83919c0.bin
< 270	./2012/3/13/14/29/dfba42f6-4de8-4ba8-bfac-570dc83919c0.bin

Files on disk that are not in the Alfresco DB. Can be deleted.
> 304	./dsmerror.log

Unique entries in alf_content_data
318462
Unique entries in alf_node_properties
305564
Unique entries in avm_nodes
12865
Unique entries in alf_audit_model
5

Unique entries in use (alf_node_properties + avm_nodes + alf_audit_model)
318434

In alf_content_data but not in any of alf_node_properties, avm_nodes, or alf_audit_model
28
In alf_node_properties but not alf_content_data
0
In avm_nodes but not alf_content_data
0
In alf_audit_model but not alf_content_data
0

Listing of node IDs in alf_content_data that are not in any of alf_node_properties, 
avm_nodes, or alf_audit_model
1178218, 1185143, 1185851, 1185858, 1189818, 1189883, 1189887, 1189889, 1189891, 1190182, 
1192920, 1193702, 1193985, 1195720, 1200796, 1228477, 1232014, 1234133, 1234135, 1246246, 
1257045, 1257046, 1307167, 1315011, 1315014, 1315018, 1315306, 1325256

Files corresponding to the node IDs in alf_content_data that are not in any of 
alf_node_properties, avm_nodes, or alf_audit_model
/var/lib/alf_data/contentstore/2011/9/19/19/16/88d5fe33-b713-48e8-9ea5-0c8f9b8e67bc.bin
/var/lib/alf_data/contentstore/2011/10/4/14/45/b8c81f19-c1d7-4742-8ac6-0afdddd25662.bin
/var/lib/alf_data/contentstore/2011/10/5/16/27/653e0bc9-12d6-4793-b193-2cb586d3764c.bin
/var/lib/alf_data/contentstore/2011/10/5/16/27/6bb5309c-bd3c-41fd-9da9-fd15e0ce5775.bin
/var/lib/alf_data/contentstore/2011/10/17/13/32/edd92f96-2592-4665-ae00-43071461ba99.bin
/var/lib/alf_data/contentstore/2011/10/18/14/56/6dfe33b9-bb47-4b4b-9fc4-b3e2a5b5b907.bin
/var/lib/alf_data/contentstore/2011/10/18/14/58/f9a0e767-edd1-48ce-9370-4d14e3905841.bin
/var/lib/alf_data/contentstore/2011/10/18/14/59/82b483df-5993-454a-98a8-1367b19fd833.bin
/var/lib/alf_data/contentstore/2011/10/18/14/59/df59b441-b67d-4a26-a5ee-01911703b9b5.bin
/var/lib/alf_data/contentstore/2011/10/19/16/13/3a664989-fa0b-4e2c-9222-ebd8fe02cf32.bin
/var/lib/alf_data/contentstore/2011/10/26/11/12/06efd829-3468-4b39-8c92-c4822d4b3341.bin
/var/lib/alf_data/contentstore/2011/10/26/17/38/7bae34d5-8097-49f3-b7a9-a2b2cb4c63c8.bin
/var/lib/alf_data/contentstore/2011/10/27/11/16/389f3450-477a-495a-b509-8800c6c6b046.bin
/var/lib/alf_data/contentstore/2011/10/28/13/8/1cefb1b5-664f-427f-b325-906012eba680.bin
/var/lib/alf_data/contentstore/2011/11/4/12/30/bf52a856-9516-4d11-af6a-645c0322d1c2.bin
/var/lib/alf_data/contentstore/2011/12/5/14/45/856d2b67-28e8-40ce-8859-26a29a23afe3.bin
/var/lib/alf_data/contentstore/2011/12/7/16/36/6d4b2dd7-551b-4472-a075-2f9f3e4ecaf6.bin
/var/lib/alf_data/contentstore/2011/12/14/12/42/1910cb27-6812-420e-abcb-05e6793d2e54.bin
/var/lib/alf_data/contentstore/2011/12/14/12/42/f38205bf-2d48-452c-bf5f-36cdb0480f30.bin
/var/lib/alf_data/contentstore/2012/1/12/14/14/c6de3fe1-74c3-410d-903d-b89d3739fb47.bin
/var/lib/alf_data/contentstore/2012/1/30/15/10/2c49054d-b6d4-4864-b2e2-46ce242c1962.bin
/var/lib/alf_data/contentstore/2012/1/30/15/10/59b8d996-6dcc-44dc-9a5e-caf7a9453dc1.bin
/var/lib/alf_data/contentstore/2012/3/7/19/50/9378ca45-851e-4ad2-833c-e7bceed3ded8.bin
/var/lib/alf_data/contentstore/2012/3/14/11/28/80bcceb1-c7bd-485f-aa40-41e6ef0a17d4.bin
/var/lib/alf_data/contentstore/2012/3/14/11/28/2be42bd0-e658-435a-9b07-3c3b06537604.bin
/var/lib/alf_data/contentstore/2012/3/14/11/28/6020177f-ae02-4833-8465-a21cbe24dd09.bin
/var/lib/alf_data/contentstore/2012/3/14/16/32/d42425d9-4139-4c1e-8b08-a394474eafcb.bin
/var/lib/alf_data/contentstore/2012/3/23/14/33/367ff98d-8bce-4970-a67e-be2b41a63ed7.bin

I personally use Adium to connect to it, and, since it’s a bit obscure, I thought I’d post some instructions on how to get Adium to connect to the #Alfresco IRC chat:

1. Choose preferences from the Adium menu
2. Choose IRC (Internet Relay Chat) from the ‘+’ pop-up menu in the lower left corner of the Accounts tab of the Preferences window.
3. On Account tab in window that appears, enter chat.us.freenode.net.
4. Nickname should be your nickname on irc, e.g. ‘iancrew’. Leave password field blank.
5. On Personal tab in that window, enter your IRC nickname in the “Username (Ident)” field.
6. Click OK.
7. You should see chat.us.freenode.net (nickname) in your accounts list, and it should connect pretty quickly.
8. Close the preferences window
9. Choose “Join Group Chat” from the File menu
10. Choose “chat.us.freenode.net (nickname)” from the Account pop-up menu
11. Enter “#alfresco” in the Channel field. Leave the password field blank.
12. Click Join.
13. Once you’re in the chat, choose “Add Group Chat Bookmark” from the Contact menu to save the #Alfresco chat in your contacts list

To have Adium automatically connect to the #Alfresco chat each time it starts up:

1. Right-click on the #Alfresco listing in your contacts list
2. Choose “Get Info”
3. Check the checkbox on the “Bookmark: Automatically join on connect” line

The only thing I don’t like about Adium is that it doesn’t auto-split your posts to the chatroom at 256 characters, which means that longer posts sometimes get cut off. Annoying, but not that big a deal. (Though if anyone knows how to fix it, please let me know in the comments below!)

Hope to see you there! (Yes, “iancrew” is me….)