ServerRegistry.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:6k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.eclipse.servers;
  19. import java.io.File;
  20. import java.io.FilenameFilter;
  21. import java.io.IOException;
  22. import java.util.Collection;
  23. import java.util.Collections;
  24. import java.util.HashSet;
  25. import java.util.Map;
  26. import java.util.Set;
  27. import java.util.TreeMap;
  28. import org.apache.hadoop.conf.Configuration;
  29. import org.apache.hadoop.eclipse.Activator;
  30. import org.apache.hadoop.eclipse.server.HadoopServer;
  31. import org.eclipse.jface.dialogs.MessageDialog;
  32. /**
  33.  * Register of Hadoop locations.
  34.  * 
  35.  * Each location corresponds to a Hadoop {@link Configuration} stored as an
  36.  * XML file in the workspace plug-in configuration directory:
  37.  * <p>
  38.  * <tt>
  39.  * &lt;workspace-dir&gt;/.metadata/.plugins/org.apache.hadoop.eclipse/locations/*.xml
  40.  * </tt>
  41.  * 
  42.  */
  43. public class ServerRegistry {
  44.   private static final ServerRegistry INSTANCE = new ServerRegistry();
  45.   public static final int SERVER_ADDED = 0;
  46.   public static final int SERVER_REMOVED = 1;
  47.   public static final int SERVER_STATE_CHANGED = 2;
  48.   private final File baseDir =
  49.       Activator.getDefault().getStateLocation().toFile();
  50.   private final File saveDir = new File(baseDir, "locations");
  51.   private ServerRegistry() {
  52.     if (saveDir.exists() && !saveDir.isDirectory())
  53.       saveDir.delete();
  54.     if (!saveDir.exists())
  55.       saveDir.mkdirs();
  56.     load();
  57.   }
  58.   private Map<String, HadoopServer> servers;
  59.   private Set<IHadoopServerListener> listeners =
  60.       new HashSet<IHadoopServerListener>();
  61.   public static ServerRegistry getInstance() {
  62.     return INSTANCE;
  63.   }
  64.   public synchronized Collection<HadoopServer> getServers() {
  65.     return Collections.unmodifiableCollection(servers.values());
  66.   }
  67.   /**
  68.    * Load all available locations from the workspace configuration directory.
  69.    */
  70.   private synchronized void load() {
  71.     Map<String, HadoopServer> map = new TreeMap<String, HadoopServer>();
  72.     for (File file : saveDir.listFiles()) {
  73.       try {
  74.         HadoopServer server = new HadoopServer(file);
  75.         map.put(server.getLocationName(), server);
  76.       } catch (Exception exn) {
  77.         System.err.println(exn);
  78.       }
  79.     }
  80.     this.servers = map;
  81.   }
  82.   private synchronized void store() {
  83.     try {
  84.       File dir = File.createTempFile("locations", "new", baseDir);
  85.       dir.delete();
  86.       dir.mkdirs();
  87.       for (HadoopServer server : servers.values()) {
  88.         server.storeSettingsToFile(new File(dir, server.getLocationName()
  89.             + ".xml"));
  90.       }
  91.       FilenameFilter XMLFilter = new FilenameFilter() {
  92.         public boolean accept(File dir, String name) {
  93.           String lower = name.toLowerCase();
  94.           return lower.endsWith(".xml");
  95.         }
  96.       };
  97.       File backup = new File(baseDir, "locations.backup");
  98.       if (backup.exists()) {
  99.         for (File file : backup.listFiles(XMLFilter))
  100.           if (!file.delete())
  101.             throw new IOException("Unable to delete backup location file: "
  102.                 + file);
  103.         if (!backup.delete())
  104.           throw new IOException(
  105.               "Unable to delete backup location directory: " + backup);
  106.       }
  107.       saveDir.renameTo(backup);
  108.       dir.renameTo(saveDir);
  109.     } catch (IOException ioe) {
  110.       ioe.printStackTrace();
  111.       MessageDialog.openError(null,
  112.           "Saving configuration of Hadoop locations failed", ioe.toString());
  113.     }
  114.   }
  115.   public void dispose() {
  116.     for (HadoopServer server : getServers()) {
  117.       server.dispose();
  118.     }
  119.   }
  120.   public synchronized HadoopServer getServer(String location) {
  121.     return servers.get(location);
  122.   }
  123.   /*
  124.    * HadoopServer map listeners
  125.    */
  126.   public void addListener(IHadoopServerListener l) {
  127.     synchronized (listeners) {
  128.       listeners.add(l);
  129.     }
  130.   }
  131.   public void removeListener(IHadoopServerListener l) {
  132.     synchronized (listeners) {
  133.       listeners.remove(l);
  134.     }
  135.   }
  136.   private void fireListeners(HadoopServer location, int kind) {
  137.     synchronized (listeners) {
  138.       for (IHadoopServerListener listener : listeners) {
  139.         listener.serverChanged(location, kind);
  140.       }
  141.     }
  142.   }
  143.   public synchronized void removeServer(HadoopServer server) {
  144.     this.servers.remove(server.getLocationName());
  145.     store();
  146.     fireListeners(server, SERVER_REMOVED);
  147.   }
  148.   public synchronized void addServer(HadoopServer server) {
  149.     this.servers.put(server.getLocationName(), server);
  150.     store();
  151.     fireListeners(server, SERVER_ADDED);
  152.   }
  153.   /**
  154.    * Update one Hadoop location
  155.    * 
  156.    * @param originalName the original location name (might have changed)
  157.    * @param server the location
  158.    */
  159.   public synchronized void updateServer(String originalName,
  160.       HadoopServer server) {
  161.     // Update the map if the location name has changed
  162.     if (!server.getLocationName().equals(originalName)) {
  163.       servers.remove(originalName);
  164.       servers.put(server.getLocationName(), server);
  165.     }
  166.     store();
  167.     fireListeners(server, SERVER_STATE_CHANGED);
  168.   }
  169. }