Moxkiriya7/src/com/wiki/standalone/moxkiriya/WikiRepository.java

   1 /**
   2  * Moxkiriya standalone Wiki.
   3  * Wiki Repository.
   4  *
   5  * @author Ryuhei Terada
   6  * See the '<a href="{@docRoot}/copyright.html">Copyright</a>'
   7  */
   8
   9 package com.wiki.standalone.moxkiriya;
  10
  11 import java.io.File;
  12 import java.io.FileInputStream;
  13 import java.io.FileOutputStream;
  14 import java.net.NetworkInterface;
  15 import java.util.ArrayList;
  16 import java.util.Enumeration;
  17 import java.util.HashMap;
  18 import java.util.Hashtable;
  19 import java.util.Iterator;
  20
  21 import javax.jcr.Credentials;
  22 import javax.jcr.ImportUUIDBehavior;
  23 import javax.jcr.NamespaceException;
  24 import javax.jcr.NamespaceRegistry;
  25 import javax.jcr.Node;
  26 import javax.jcr.NodeIterator;
  27 import javax.jcr.Property;
  28 import javax.jcr.Repository;
  29 import javax.jcr.RepositoryException;
  30 import javax.jcr.Session;
  31 import javax.jcr.Value;
  32 import javax.jcr.ValueFactory;
  33 import javax.jcr.Workspace;
  34 import javax.jcr.nodetype.NodeType;
  35 import javax.jcr.query.Query;
  36 import javax.jcr.query.QueryManager;
  37 import javax.jcr.version.Version;
  38 import javax.jcr.version.VersionHistory;
  39 import javax.jcr.version.VersionIterator;
  40 import javax.jcr.version.VersionManager;
  41 import javax.naming.Context;
  42 import javax.naming.InitialContext;
  43
  44 import org.apache.jackrabbit.core.jndi.RegistryHelper;
  45 import org.apache.jackrabbit.value.StringValue;
  46
  47 import com.wiki.standalone.moxkiriya.PageData.FileData;
  48
  49 /**
  50  * WikiRepository class.
  51  *
  52  */
  53 public class WikiRepository {
  54         /** repository_cluster_derby.xml */
  55         public static final String REPOSITORY_CUSTER_FILENAME = "repository_cluster_derby.xml";
  56
  57         /** repository_local.xml */
  58         public static final String REPOSITORY_LOCAL_FILENAME = "repository_local.xml";
  59
  60         public static final String REOPSITORY_DIRNAME = "Repository";
  61
  62         /** Moxkiriya repository generic namespace */
  63         public static final String NAMESPACE_MOXKI = "moxki";
  64
  65         public static final String NAMESPACE_MOXKI_URI = "https://osdn.net/users/ryuhei__terada/pf/Moxkiriya7/moxki/1.0";
  66
  67         /** Node name "wikiroot" */
  68         public static final String NODE_WIKIROOT = NAMESPACE_MOXKI      + ":wikiroot";
  69
  70         /** Node name "namespace" */
  71         public static final String NODE_NAMESPACE = NAMESPACE_MOXKI + ":namespacelist";
  72
  73         /** Property name "namespace" */
  74         public static final String PROPERTY_NAMESPACE = NAMESPACE_MOXKI + ":namespace";
  75
  76         /** Property value "Main" in namespace */
  77         public static final String PROPERTY_MAIN = "Main";
  78
  79         /** Property value "Category" in namespace */
  80         public static final String PROPERTY_CATEGORY = "Category";
  81
  82         /** Property value "File" in namespace */
  83         public static final String PROPERTY_FILE = "File";
  84
  85         /** Node name "pages" */
  86         public static final String NODE_PAGES = NAMESPACE_MOXKI + ":pages";
  87
  88         /** Node name "page" */
  89         public static final String NODE_PAGE = NAMESPACE_MOXKI + ":page";
  90
  91         /** Property name "title" */
  92         public static final String PROPERTY_TITLE = NAMESPACE_MOXKI + ":title";
  93
  94         /** Property name "content" */
  95         public static final String PROPERTY_CONTENT = NAMESPACE_MOXKI + ":content";
  96
  97         /** Property name "category" */
  98         public static final String PROPERTY_category = NAMESPACE_MOXKI + ":category";
  99
 100         /** Node name "file" */
 101         public static final String NODE_FILE = NAMESPACE_MOXKI + ":file";
 102
 103         /** Repository Home directory */
 104         private String repositoryHomeDir_;
 105
 106         /** repository.xml */
 107         private String repositoryFile_;
 108
 109         /** Initial context settings table */
 110         private static Hashtable<String, String> envHashTable = new  Hashtable<String, String>() {
 111                 private static final long serialVersionUID = 1L;
 112                 {
 113                         put(Context.INITIAL_CONTEXT_FACTORY,
 114                                 "org.apache.jackrabbit.core.jndi.provider.DummyInitialContextFactory");
 115                 }
 116                 {
 117                         put(Context.PROVIDER_URL, "localhost");
 118                 }
 119         };
 120
 121         /** Repository */
 122         private Repository repository_;
 123
 124         /** Session */
 125         private Session    session_;
 126
 127         /**
 128          * Constructor.
 129          * @param wikirootPath
 130          * @throws Exception
 131          */
 132         public WikiRepository(File wikirootPath) throws Exception {
 133                 SettingManager settingMgr = SettingManager.getInstance();
 134
 135                 setSystemProperties();
 136
 137                 String configXML = settingMgr.get(SettingManager.SETINGKEY_CLUSTER).equals("true")
 138                                 ? REPOSITORY_CUSTER_FILENAME
 139                                 : REPOSITORY_LOCAL_FILENAME;
 140
 141                 repositoryHomeDir_ = settingMgr.getAbsolutePath(REOPSITORY_DIRNAME);
 142                 repositoryFile_    = settingMgr.getAbsolutePath(configXML);
 143
 144                 InitialContext initialContext = new InitialContext(envHashTable);
 145         RegistryHelper.registerRepository(initialContext,
 146                         "repo",
 147                         repositoryFile_,
 148                         repositoryHomeDir_,
 149                         true);
 150         repository_ = (Repository)initialContext.lookup("repo");
 151         session_    = repository_.login((Credentials)null);
 152         }
 153
 154         /**
 155          * Session closer.
 156          */
 157         public void closeSession() {
 158                 session_.logout();
 159         }
 160
 161         /**
 162          * Build Apache Jackrabbit Repository.
 163          * @param pageData
 164          * @throws Exception
 165          */
 166         public void buildWikiRepository(PageData pageData) throws Exception {
 167                 Workspace         workspace  = session_.getWorkspace();
 168
 169                 try {
 170                         NamespaceRegistry nsRegistry = workspace.getNamespaceRegistry();
 171
 172                         nsRegistry.getPrefix(NAMESPACE_MOXKI_URI);
 173                 } catch(NamespaceException e) {
 174                         /*
 175                          * Build Apache Jackrabbit Repository if namespace"moxki" hasnot registered.
 176                          */
 177                         workspace.getNamespaceRegistry().registerNamespace(NAMESPACE_MOXKI, NAMESPACE_MOXKI_URI);
 178
 179                 Node root      = session_.getRootNode();
 180                 Node wikiroot  = root.addNode(NODE_WIKIROOT);
 181                 Node namespace = wikiroot.addNode(NODE_NAMESPACE);
 182                 namespace.setProperty(PROPERTY_NAMESPACE,
 183                                                                 new Value[] {
 184                                                                         new StringValue(PROPERTY_MAIN),
 185                                                                         new StringValue(PROPERTY_CATEGORY),
 186                                                                         new StringValue(PROPERTY_FILE)
 187                                                                 });
 188                 wikiroot.addNode(NODE_PAGES);
 189
 190                 /*
 191                  * "page"ノードを作成
 192                  */
 193                 checkin(pageData);
 194                 }
 195         }
 196
 197         /**
 198          * Add pageNode.
 199          * @param pageData
 200          * @throws Exception
 201          */
 202         public Node addPageNode(PageData pageData) throws Exception {
 203         Node root      = session_.getRootNode();
 204         Node wikiroot  = root.getNode(NODE_WIKIROOT);
 205         Node pagesNode = wikiroot.getNode(NODE_PAGES);
 206         Node pageNode  = pagesNode.addNode(NODE_PAGE);
 207
 208         pageNode.addMixin(NodeType.MIX_VERSIONABLE);
 209         pageNode.addMixin(NodeType.MIX_REFERENCEABLE);
 210
 211         return transformPageDataToNode(pageData, pageNode);
 212         }
 213
 214         /**
 215          * Transform PageData to node.
 216          * @param pageData
 217          * @param node
 218          * @return Node
 219          * @throws Exception
 220          */
 221         public Node transformPageDataToNode(PageData pageData, Node node) throws Exception {
 222                 node.setProperty(PROPERTY_NAMESPACE, new StringValue(pageData.getNamespace()));
 223                 node.setProperty(PROPERTY_TITLE, new StringValue(pageData.getTitle()));
 224                 node.setProperty(PROPERTY_CONTENT, new StringValue(pageData.getContent()));
 225
 226         ArrayList<String> categories = pageData.getCategories();
 227         Value[] values = new Value[] { new StringValue("") };
 228         if(categories.size() > 0) {
 229                 values = new Value[categories.size()];
 230                 for(int count = 0; count < categories.size(); count++) {
 231                         values[count] = new StringValue(categories.get(count));
 232                 }
 233         }
 234         node.setProperty(PROPERTY_category, values);
 235
 236                 FileData fileData = pageData.getFileData();
 237
 238                 if(fileData != null) {
 239                         Node fileNode;
 240                         if(node.hasNode(WikiRepository.NODE_FILE) == true) {
 241                                 fileNode = node.getNode(WikiRepository.NODE_FILE);
 242                         }
 243                         else {
 244                                 fileNode     = node.addNode(WikiRepository.NODE_FILE, NodeType.NT_FILE);
 245                                 fileNode.addNode(Property.JCR_CONTENT, NodeType.NT_RESOURCE);
 246                         }
 247
 248                         Node         nodeResource = fileNode.getNode(Property.JCR_CONTENT);
 249                         ValueFactory valueFactory = session_.getValueFactory();
 250
 251                         nodeResource.setProperty(Property.JCR_DATA, valueFactory.createBinary(fileData.getInputStream()));
 252                         nodeResource.setProperty(Property.JCR_MIMETYPE, new StringValue(fileData.getMimeType()));
 253                         nodeResource.setProperty(Property.JCR_LAST_MODIFIED, valueFactory.createValue(fileData.getLastModified()));
 254                         if(fileData.getMimeType().startsWith("text/") == true) {
 255                                 nodeResource.setProperty(Property.JCR_ENCODING, new StringValue("UTF-8"));
 256                         }
 257                 }
 258
 259         return node;
 260         }
 261
 262         /**
 263          * Execute query.
 264          * @param sql
 265          * @return HashMap<String, PageData>
 266          * @throws Exception
 267          */
 268         private HashMap<String, PageData> executeQuery(String sql) throws Exception {
 269                 Workspace    workspace = session_.getWorkspace();
 270                 QueryManager queryMgr  = workspace.getQueryManager();
 271                 Query        query     = queryMgr.createQuery(sql, Query.JCR_SQL2);
 272         NodeIterator iter      = query.execute().getNodes();
 273
 274         return convertNodeIteratorToPageDataMap(iter);
 275         }
 276
 277         /**
 278          * Get node matched namespace.
 279          * @param pageTitle
 280          * @return HashMap<String, PageData>
 281          * @throws Exception
 282          */
 283         public HashMap<String, PageData> queryPageNamespace(String namespace) throws Exception {
 284         return executeQuery(
 285                                 "SELECT * "
 286                                 + "     FROM [nt:unstructured]"
 287                                 + " WHERE"
 288                                 + " ISDESCENDANTNODE(["
 289                                         + "/" + NODE_WIKIROOT + "/" + NODE_PAGES + "])"
 290                                 + " AND"
 291                                 + " [" + PROPERTY_NAMESPACE + "] = '" + namespace + "'"
 292                 );
 293         }
 294
 295         /**
 296          * Get node matched uuid.
 297          * @param uuid
 298          * @return HashMap<String, PageData>
 299          * @throws Exception
 300          */
 301         public HashMap<String, PageData> queryPageUUID(String uuid) throws Exception {
 302         return executeQuery(
 303                         "SELECT * "
 304                         + "     FROM [nt:unstructured]"
 305                         + " WHERE"
 306                         + " ISDESCENDANTNODE(["
 307                                         + "/" + NODE_WIKIROOT + "/" + NODE_PAGES + "])"
 308                         + " AND"
 309                         + " [" + Property.JCR_UUID + "] = '" + uuid + "'"
 310                 );
 311         }
 312
 313         /**
 314          * Get node matched page title.
 315          * @param pageTitle
 316          * @return HashMap<String, PageData>
 317          * @throws Exception
 318          */
 319         public HashMap<String, PageData> queryPageTitle(String pageTitle) throws Exception {
 320                 String       namespace = PROPERTY_MAIN;
 321                 String       title     = pageTitle;
 322
 323                 if(pageTitle.contains(":") == true) {
 324                         namespace = pageTitle.substring(0, pageTitle.indexOf(":"));
 325                         title     = pageTitle.substring(pageTitle.indexOf(":") + ":".length());
 326                 }
 327
 328         return queryPageTitle(title, namespace);
 329         }
 330
 331         /**
 332          * Get node matched page title.
 333          * @param pageTitle
 334          * @param namespace
 335          * @return HashMap<String, PageData>
 336          * @throws Exception
 337          */
 338         public HashMap<String, PageData> queryPageTitle(String pageTitle, String namespace) throws Exception {
 339         return executeQuery(
 340                         "SELECT * "
 341                         + "     FROM [nt:unstructured]"
 342                         + " WHERE"
 343                         + " ISDESCENDANTNODE(["
 344                                 + "/" + NODE_WIKIROOT + "/" + NODE_PAGES + "])"
 345                         + " AND"
 346                         + " [" + PROPERTY_NAMESPACE + "] = '" + namespace + "'"
 347                         + " AND"
 348                         + " [" + PROPERTY_TITLE + "] = '" + pageTitle + "'"
 349                         );
 350         }
 351
 352         /**
 353          * Execute full text search.
 354          * @param searchKey
 355          * @return String
 356          * @throws Exception
 357          */
 358         public HashMap<String, PageData> queryPageFullTextSearch(String searchKey) throws Exception {
 359         return executeQuery(
 360                         "SELECT * "
 361                         + "     FROM [nt:unstructured]"
 362                         + " WHERE"
 363                         + " ISDESCENDANTNODE(["
 364                                 + "/" + NODE_WIKIROOT + "/" + NODE_PAGES + "])"
 365                         + " AND "
 366                         + " CONTAINS([" + PROPERTY_TITLE + "], '" + searchKey + "')"
 367                         + " OR "
 368                         + " CONTAINS([" + PROPERTY_CONTENT + "], '" + searchKey +  "')"
 369                 );
 370         }
 371
 372         /**
 373          * Converter NodeIterator to PageDatMap.
 374          * @param nodeIter
 375          * @return HashMap<String, PageData>
 376          * @throws Exception
 377          */
 378         public HashMap<String, PageData> convertNodeIteratorToPageDataMap(NodeIterator nodeIter) throws Exception {
 379         HashMap<String, PageData> pageDataMap = new HashMap<String, PageData>();
 380         while(nodeIter.hasNext() == true) {
 381                 Node     node     = nodeIter.nextNode();
 382                 Version  baseVersion = getBaseVersion(node);
 383                 PageData pageData = new PageData(node);
 384
 385                 pageData.setBaseVersion(baseVersion);
 386                 pageDataMap.put(node.getProperty(Property.JCR_UUID).getString(), pageData);
 387         }
 388
 389         return pageDataMap;
 390         }
 391
 392         /**
 393          * NamespaceList getter
 394          * @return Value[]
 395          * @throws Exception
 396          */
 397         public Value[] getNamespaceList() throws Exception {
 398                 Node namespace      = session_.getNode("/" + NODE_WIKIROOT + "/" + NODE_NAMESPACE);
 399
 400                 return namespace.getProperty(PROPERTY_NAMESPACE).getValues();
 401         }
 402
 403         /**
 404          * Checkout
 405          * @param pageData
 406          * @throws Exception
 407          */
 408         public void checkout(PageData pageData) throws Exception {
 409                 Node node = pageData.getNode();
 410                 if(node != null) {
 411                         session_.refresh(false);
 412
 413                         Workspace      workspace = session_.getWorkspace();
 414                         VersionManager versionMgr = workspace.getVersionManager();
 415                         versionMgr.checkout(node.getPath());
 416                 }
 417         }
 418
 419         /**
 420          * Checkin.
 421          * @param pageData
 422          * @throws Exception
 423          */
 424         public PageData checkin(PageData pageData) throws Exception {
 425                 Workspace      workspace  = session_.getWorkspace();
 426                 VersionManager versionMgr = workspace.getVersionManager();
 427                 Node           node       = pageData.getNode();
 428
 429                 if(node == null) {
 430                         node = addPageNode(pageData);
 431                         session_.save();
 432                         versionMgr.checkout(node.getPath());
 433                 }
 434                 else {
 435                         String uuid = node.getProperty(Property.JCR_UUID).getString();
 436
 437                         node = transformPageDataToNode(pageData, session_.getNodeByIdentifier(uuid));
 438                         session_.save();
 439                 }
 440
 441                 versionMgr.checkin(node.getPath());
 442                 createCategoryPages(node);
 443
 444                 String uuid = node.getProperty(Property.JCR_UUID).getString();
 445
 446                 return new PageData(session_.getNodeByIdentifier(uuid));
 447         }
 448
 449         /**
 450          * Cancel checkout
 451          * @param pageData
 452          * @throws Exception
 453          */
 454         public void cancelCheckout(PageData pageData) throws Exception {
 455                 Node node = pageData.getNode();
 456                 if(node != null) {
 457                         Workspace      workspace  = session_.getWorkspace();
 458                         VersionManager versionMgr = workspace.getVersionManager();
 459                         String         path       = node.getPath();
 460                         if(versionMgr.isCheckedOut(path) == true) {
 461                                 versionMgr.restore(versionMgr.getBaseVersion(path), true);
 462                         }
 463                 }
 464         }
 465
 466         /**
 467          * Delete page node.
 468          * @param pageData
 469          * @throws Exception
 470          */
 471         public void deletePage(PageData pageData) throws Exception {
 472                 pageData.getNode().remove();
 473                 session_.save();
 474         }
 475
 476         /**
 477          * Refresh session.
 478          * @throws RepositoryException
 479          */
 480         public void refreshSession() throws RepositoryException {
 481                 session_.refresh(false);
 482         }
 483
 484         /**
 485          * Set SystemProperties.
 486          * @throws Exception
 487          */
 488         private void setSystemProperties() throws Exception {
 489                 SettingManager settingMgr = SettingManager.getInstance();
 490
 491                 String macAddress = getMacAddress();
 492                 String username   = System.getProperty("user.name");
 493                 String approot    = settingMgr.get(SettingManager.SETTINGSKEY_WIKIROOT);
 494                 String partyName  = settingMgr.getSelectedParty();
 495
 496                 System.setProperty("cluster.id", String.valueOf(macAddress.hashCode()
 497                                 + "-" + partyName
 498                                 + "-" + username));
 499                 System.setProperty("wiki.root", approot);
 500
 501                 if(settingMgr.get(SettingManager.SETINGKEY_CLUSTER).equals("true")) {
 502                         System.setProperty("party.name", partyName);
 503                         System.setProperty("cluster.setting", "TRUE");
 504                         System.setProperty("dbserver.url", settingMgr.get(SettingManager.SETINGKEY_DBSERVER_URL));
 505                         System.setProperty("dbserver.port", settingMgr.get(SettingManager.SETINGKEY_DBSERVER_PORT));
 506                         System.setProperty("jdbc.driver", settingMgr.get(SettingManager.SETINGKEY_JDBC_DRIVER));
 507                 }
 508                 else {
 509                         System.setProperty("cluster.setting", "FALSE");
 510                         System.setProperty("dbserver.url", "");
 511                         System.setProperty("dbserver.port", "");
 512                         System.setProperty("jdbc.driver", "");
 513                 }
 514         }
 515
 516         /**
 517          * Mac Address getter.
 518          * @return
 519          * @throws Exception
 520          */
 521         private String getMacAddress() throws Exception {
 522                 StringBuffer                  buf     = new StringBuffer();
 523                 Enumeration<NetworkInterface> nicList = NetworkInterface.getNetworkInterfaces();
 524
 525                 while(nicList.hasMoreElements() == true) {
 526                         NetworkInterface nic = nicList.nextElement();
 527                         if(nic.getName().equals("lo") != true) {
 528                                 byte[] macAddress = nic.getHardwareAddress();
 529                                 if(macAddress != null) {
 530                                         for(byte b: macAddress) {
 531                                                 buf.append(String.format("%02X-", b));
 532                                         }
 533                                         break;
 534                                 }
 535                         }
 536                 }
 537
 538                 return buf.toString();
 539         }
 540
 541         /**
 542          *
 543          * @param node
 544          * @throws Exception
 545          */
 546         private void createCategoryPages(Node node) throws Exception {
 547                 Workspace      workspace  = session_.getWorkspace();
 548                 VersionManager versionMgr = workspace.getVersionManager();
 549                 Value[]        categories = node.getProperty(PROPERTY_category).getValues();
 550
 551                 for(Value category: categories) {
 552                         String                    title = category.getString();
 553
 554                         if(title.isEmpty() != true) {
 555                                 HashMap<String, PageData> map   = queryPageTitle(title, PROPERTY_CATEGORY);
 556
 557                                 if(map.size() == 0) {
 558                                         /*
 559                                          * category pageが未作成の場合、
 560                                          */
 561                                         PageData pageData = new PageData();
 562                                         pageData.setNamespace(PROPERTY_CATEGORY);
 563                                         pageData.setTitle(title);
 564
 565                                         Node categoryNode = addPageNode(pageData);
 566                                         session_.save();
 567                                         versionMgr.checkout(categoryNode.getPath());
 568                                         versionMgr.checkin(categoryNode.getPath());
 569                                 }
 570                         }
 571                 }
 572         }
 573
 574         /**
 575          * Test namespace is contains namespaceList.
 576          * @param namespace
 577          * @return boolean
 578          * @throws Exception
 579          */
 580         public boolean isContainsNamespaceList(String namespace) throws Exception {
 581         Node root          = session_.getRootNode();
 582         Node wikiroot      = root.getNode(NODE_WIKIROOT);
 583         Node namespaceNode = wikiroot.getNode(NODE_NAMESPACE);
 584
 585         Value[] list       = namespaceNode.getProperty(PROPERTY_NAMESPACE).getValues();
 586         boolean isContains = false;
 587
 588         for(Value entry: list) {
 589                 if(entry.getString().equals(namespace) == true) {
 590                         isContains = true;
 591                         break;
 592                 }
 593         }
 594
 595         return isContains;
 596         }
 597
 598         /**
 599          * Version history getter.
 600          * @param uuid
 601          * @return VersionIterator
 602          * @throws Exception
 603          */
 604         public VersionIterator getVersionHistory(String uuid) throws Exception {
 605                 HashMap<String, PageData> nodeMap  =  queryPageUUID(uuid);
 606                 PageData                  pageData = nodeMap.values().iterator().next();
 607                 Node                      node     = pageData.getNode();
 608
 609                 Workspace      workspace      = session_.getWorkspace();
 610                 VersionManager versionMgr     = workspace.getVersionManager();
 611                 VersionHistory versionHistory = versionMgr.getVersionHistory(node.getPath());
 612
 613                 return versionHistory.getAllVersions();
 614         }
 615
 616         /**
 617          * Base version getter.
 618          * @param node
 619          * @return Version
 620          * @throws Exception
 621          */
 622         public Version getBaseVersion(Node node) throws Exception {
 623                 Workspace      workspace      = session_.getWorkspace();
 624                 VersionManager versionMgr     = workspace.getVersionManager();
 625
 626                 return versionMgr.getBaseVersion(node.getPath());
 627         }
 628
 629         /**
 630          * Restore version.
 631          * @param version
 632          * @param node
 633          * @throws Exception
 634          */
 635         public void restoreVersion(Version version, Node node) throws Exception {
 636                 Workspace      workspace      = session_.getWorkspace();
 637                 VersionManager versionMgr     = workspace.getVersionManager();
 638
 639                 versionMgr.restore(version, true);
 640         }
 641
 642         /**
 643          * Import system view.
 644          * @param outputFile
 645          * @throws Exception
 646          */
 647         public void importSystemView(File outputFile) throws Exception {
 648                 FileInputStream inStream = new FileInputStream(outputFile);
 649
 650                 try {
 651                 Node root      = session_.getRootNode();
 652                 Node wikiroot  = root.getNode(NODE_WIKIROOT);
 653                 Node pagesNode = wikiroot.getNode(NODE_PAGES);
 654
 655                 session_.importXML(pagesNode.getPath(), inStream, ImportUUIDBehavior.IMPORT_UUID_COLLISION_REMOVE_EXISTING);
 656                 session_.save();
 657
 658                 Node    namespaceNode = wikiroot.getNode(NODE_NAMESPACE);
 659                 Value[] namespaces    = namespaceNode.getProperty(PROPERTY_NAMESPACE).getValues();
 660
 661                 for(Value namespace: namespaces) {
 662                         HashMap<String,PageData> map = queryPageNamespace(namespace.getString());
 663                         Iterator<PageData>       iter = map.values().iterator();
 664                         while(iter.hasNext() == true) {
 665                                 PageData pageData = iter.next();
 666                                 checkout(pageData);
 667                                 checkin(pageData);
 668                         }
 669                 }
 670                 } finally {
 671                         inStream.close();
 672                 }
 673         }
 674
 675         /**
 676          * Export system view.
 677          * @param outputFile
 678          * @throws Exception
 679          */
 680         public void exportSystemView(File outputFile) throws Exception {
 681                 FileOutputStream outStream = new FileOutputStream(outputFile);
 682
 683                 try {
 684                 Node root      = session_.getRootNode();
 685                 Node wikiroot  = root.getNode(NODE_WIKIROOT);
 686                 Node pagesNode = wikiroot.getNode(NODE_PAGES);
 687
 688                 session_.exportSystemView(pagesNode.getPath(), outStream, false, false);
 689                 } finally {
 690                         outStream.close();
 691                 }
 692         }
 693 }