jcr/JcrPreferenceStore.java

   1 package org.argeo.eclipse.ui.jcr;
   2
   3 import java.io.ByteArrayInputStream;
   4 import java.io.ByteArrayOutputStream;
   5 import java.io.IOException;
   6 import java.util.Properties;
   7
   8 import javax.jcr.Node;
   9 import javax.jcr.Property;
  10 import javax.jcr.PropertyIterator;
  11 import javax.jcr.RepositoryException;
  12 import javax.jcr.Session;
  13 import javax.jcr.version.VersionManager;
  14
  15 import org.apache.commons.io.IOUtils;
  16 import org.argeo.ArgeoException;
  17 import org.argeo.jcr.ArgeoNames;
  18 import org.argeo.jcr.ArgeoTypes;
  19 import org.argeo.jcr.JcrUtils;
  20 import org.eclipse.jface.preference.PreferenceStore;
  21 import org.eclipse.ui.preferences.ScopedPreferenceStore;
  22 import org.osgi.framework.BundleContext;
  23
  24 /**
  25  * Persist preferences as key/value pairs under ~/argeo:preferences.<br>
  26  * TODO: better integrate JCR and Eclipse:<br>
  27  * - typing<br>
  28  * - use eclipse preferences<br>
  29  * - better integrate with {@link ScopedPreferenceStore} provided by RAP
  30  */
  31 public class JcrPreferenceStore extends PreferenceStore implements ArgeoNames {
  32         private Session session;
  33         private BundleContext bundleContext;
  34
  35         /** Retrieves the preference node */
  36         protected Node getPreferenceNode() {
  37                 try {
  38                         if (session.hasPendingChanges())
  39                                 session.save();
  40                         Node userHome = JcrUtils.getUserHome(session);
  41                         if (userHome == null)
  42                                 throw new ArgeoException("No user home for "
  43                                                 + session.getUserID());
  44                         Node preferences;
  45                         if (!userHome.hasNode(ARGEO_PREFERENCES)) {
  46                                 preferences = userHome.addNode(ARGEO_PREFERENCES);
  47                                 preferences.addMixin(ArgeoTypes.ARGEO_PREFERENCE_NODE);
  48                                 session.save();
  49                         } else
  50                                 preferences = userHome.getNode(ARGEO_PREFERENCES);
  51
  52                         String pluginPreferencesName = bundleContext.getBundle()
  53                                         .getSymbolicName();
  54                         Node pluginPreferences;
  55                         if (!preferences.hasNode(pluginPreferencesName)) {
  56                                 VersionManager vm = session.getWorkspace().getVersionManager();
  57                                 vm.checkout(preferences.getPath());
  58                                 pluginPreferences = preferences.addNode(pluginPreferencesName);
  59                                 pluginPreferences.addMixin(ArgeoTypes.ARGEO_PREFERENCE_NODE);
  60                                 session.save();
  61                                 vm.checkin(preferences.getPath());
  62                         } else
  63                                 pluginPreferences = preferences.getNode(pluginPreferencesName);
  64                         return pluginPreferences;
  65                 } catch (RepositoryException e) {
  66                         e.printStackTrace();
  67                         JcrUtils.discardQuietly(session);
  68                         throw new ArgeoException("Cannot retrieve preferences", e);
  69                 }
  70
  71         }
  72
  73         @Override
  74         public void load() throws IOException {
  75                 ByteArrayOutputStream out = null;
  76                 ByteArrayInputStream in = null;
  77                 try {
  78                         Properties props = new Properties();
  79                         PropertyIterator it = getPreferenceNode().getProperties();
  80                         while (it.hasNext()) {
  81                                 Property p = it.nextProperty();
  82                                 if (!p.isMultiple() && !p.getDefinition().isProtected()) {
  83                                         props.setProperty(p.getName(), p.getValue().getString());
  84                                 }
  85                         }
  86                         out = new ByteArrayOutputStream();
  87                         props.store(out, "");
  88                         in = new ByteArrayInputStream(out.toByteArray());
  89                         load(in);
  90                 } catch (Exception e) {
  91                         e.printStackTrace();
  92                         throw new ArgeoException("Cannot load preferences", e);
  93                 } finally {
  94                         IOUtils.closeQuietly(in);
  95                         IOUtils.closeQuietly(out);
  96                 }
  97         }
  98
  99         @Override
 100         public void save() throws IOException {
 101                 ByteArrayOutputStream out = null;
 102                 ByteArrayInputStream in = null;
 103                 Node pluginPreferences = null;
 104                 try {
 105                         out = new ByteArrayOutputStream();
 106                         save(out, "");
 107                         in = new ByteArrayInputStream(out.toByteArray());
 108                         Properties props = new Properties();
 109                         props.load(in);
 110                         pluginPreferences = getPreferenceNode();
 111                         VersionManager vm = pluginPreferences.getSession().getWorkspace()
 112                                         .getVersionManager();
 113                         vm.checkout(pluginPreferences.getPath());
 114                         for (Object key : props.keySet()) {
 115                                 String name = key.toString();
 116                                 String value = props.getProperty(name);
 117                                 pluginPreferences.setProperty(name, value);
 118                         }
 119                         JcrUtils.updateLastModified(pluginPreferences);
 120                         pluginPreferences.getSession().save();
 121                         vm.checkin(pluginPreferences.getPath());
 122                 } catch (Exception e) {
 123                         JcrUtils.discardUnderlyingSessionQuietly(pluginPreferences);
 124                         throw new ArgeoException("Cannot save preferences", e);
 125                 } finally {
 126                         IOUtils.closeQuietly(in);
 127                         IOUtils.closeQuietly(out);
 128                 }
 129         }
 130
 131         public void init() {
 132                 try {
 133                         load();
 134                 } catch (IOException e) {
 135                         throw new ArgeoException("Cannot initialize preference store", e);
 136                 }
 137         }
 138
 139         public void setSession(Session session) {
 140                 this.session = session;
 141         }
 142
 143         public void setBundleContext(BundleContext bundleContext) {
 144                 this.bundleContext = bundleContext;
 145         }
 146
 147 }