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

网格计算

开发平台:

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.contrib.index.mapred;
  19. import java.io.DataInput;
  20. import java.io.DataOutput;
  21. import java.io.IOException;
  22. import java.util.ArrayList;
  23. import java.util.Collections;
  24. import java.util.StringTokenizer;
  25. import org.apache.hadoop.io.Text;
  26. import org.apache.hadoop.io.WritableComparable;
  27. /**
  28.  * This class represents the metadata of a shard. Version is the version number
  29.  * of the entire index. Directory is the directory where this shard resides in.
  30.  * Generation is the Lucene index's generation. Version and generation are
  31.  * reserved for future use.
  32.  * 
  33.  * Note: Currently the version number of the entire index is not used and
  34.  * defaults to -1.
  35.  */
  36. public class Shard implements WritableComparable {
  37.   // This method is copied from Path.
  38.   public static String normalizePath(String path) {
  39.     // remove double slashes & backslashes
  40.     path = path.replace("//", "/");
  41.     path = path.replace("\", "/");
  42.     // trim trailing slash from non-root path (ignoring windows drive)
  43.     if (path.length() > 1 && path.endsWith("/")) {
  44.       path = path.substring(0, path.length() - 1);
  45.     }
  46.     return path;
  47.   }
  48.   public static void setIndexShards(IndexUpdateConfiguration conf,
  49.       Shard[] shards) {
  50.     StringBuilder shardsString = new StringBuilder(shards[0].toString());
  51.     for (int i = 1; i < shards.length; i++) {
  52.       shardsString.append(",");
  53.       shardsString.append(shards[i].toString());
  54.     }
  55.     conf.setIndexShards(shardsString.toString());
  56.   }
  57.   public static Shard[] getIndexShards(IndexUpdateConfiguration conf) {
  58.     String shards = conf.getIndexShards();
  59.     if (shards != null) {
  60.       ArrayList<Object> list =
  61.           Collections.list(new StringTokenizer(shards, ","));
  62.       Shard[] result = new Shard[list.size()];
  63.       for (int i = 0; i < list.size(); i++) {
  64.         result[i] = Shard.createShardFromString((String) list.get(i));
  65.       }
  66.       return result;
  67.     } else {
  68.       return null;
  69.     }
  70.   }
  71.   // assume str is formatted correctly as a shard string
  72.   private static Shard createShardFromString(String str) {
  73.     int first = str.indexOf("@");
  74.     int second = str.indexOf("@", first + 1);
  75.     long version = Long.parseLong(str.substring(0, first));
  76.     String dir = str.substring(first + 1, second);
  77.     long gen = Long.parseLong(str.substring(second + 1));
  78.     return new Shard(version, dir, gen);
  79.   }
  80.   // index/shard version
  81.   // the shards in the same version of an index have the same version number
  82.   private long version;
  83.   private String dir;
  84.   private long gen; // Lucene's generation
  85.   /**
  86.    * Constructor.
  87.    */
  88.   public Shard() {
  89.     this.version = -1;
  90.     this.dir = null;
  91.     this.gen = -1;
  92.   }
  93.   /**
  94.    * Construct a shard from a versio number, a directory and a generation
  95.    * number.
  96.    * @param version  the version number of the entire index
  97.    * @param dir  the directory where this shard resides
  98.    * @param gen  the generation of the Lucene instance
  99.    */
  100.   public Shard(long version, String dir, long gen) {
  101.     this.version = version;
  102.     this.dir = normalizePath(dir);
  103.     this.gen = gen;
  104.   }
  105.   /**
  106.    * Construct using a shard object.
  107.    * @param shard  the shard used by the constructor
  108.    */
  109.   public Shard(Shard shard) {
  110.     this.version = shard.version;
  111.     this.dir = shard.dir;
  112.     this.gen = shard.gen;
  113.   }
  114.   /**
  115.    * Get the version number of the entire index.
  116.    * @return the version number of the entire index
  117.    */
  118.   public long getVersion() {
  119.     return version;
  120.   }
  121.   /**
  122.    * Get the directory where this shard resides.
  123.    * @return the directory where this shard resides
  124.    */
  125.   public String getDirectory() {
  126.     return dir;
  127.   }
  128.   /**
  129.    * Get the generation of the Lucene instance.
  130.    * @return the generation of the Lucene instance
  131.    */
  132.   public long getGeneration() {
  133.     return gen;
  134.   }
  135.   /* (non-Javadoc)
  136.    * @see java.lang.Object#toString()
  137.    */
  138.   public String toString() {
  139.     return version + "@" + dir + "@" + gen;
  140.   }
  141.   // ///////////////////////////////////
  142.   // Writable
  143.   // ///////////////////////////////////
  144.   /* (non-Javadoc)
  145.    * @see org.apache.hadoop.io.Writable#write(java.io.DataOutput)
  146.    */
  147.   public void write(DataOutput out) throws IOException {
  148.     out.writeLong(version);
  149.     Text.writeString(out, dir);
  150.     out.writeLong(gen);
  151.   }
  152.   /* (non-Javadoc)
  153.    * @see org.apache.hadoop.io.Writable#readFields(java.io.DataInput)
  154.    */
  155.   public void readFields(DataInput in) throws IOException {
  156.     version = in.readLong();
  157.     dir = Text.readString(in);
  158.     gen = in.readLong();
  159.   }
  160.   // ///////////////////////////////////
  161.   // Comparable
  162.   // ///////////////////////////////////
  163.   /* (non-Javadoc)
  164.    * @see java.lang.Comparable#compareTo(java.lang.Object)
  165.    */
  166.   public int compareTo(Object o) {
  167.     return compareTo((Shard) o);
  168.   }
  169.   /**
  170.    * Compare to another shard.
  171.    * @param other  another shard
  172.    * @return compare version first, then directory and finally generation
  173.    */
  174.   public int compareTo(Shard other) {
  175.     // compare version
  176.     if (version < other.version) {
  177.       return -1;
  178.     } else if (version > other.version) {
  179.       return 1;
  180.     }
  181.     // compare dir
  182.     int result = dir.compareTo(other.dir);
  183.     if (result != 0) {
  184.       return result;
  185.     }
  186.     // compare gen
  187.     if (gen < other.gen) {
  188.       return -1;
  189.     } else if (gen == other.gen) {
  190.       return 0;
  191.     } else {
  192.       return 1;
  193.     }
  194.   }
  195.   /* (non-Javadoc)
  196.    * @see java.lang.Object#equals(java.lang.Object)
  197.    */
  198.   public boolean equals(Object o) {
  199.     if (this == o) {
  200.       return true;
  201.     }
  202.     if (!(o instanceof Shard)) {
  203.       return false;
  204.     }
  205.     Shard other = (Shard) o;
  206.     return version == other.version && dir.equals(other.dir)
  207.         && gen == other.gen;
  208.   }
  209.   /* (non-Javadoc)
  210.    * @see java.lang.Object#hashCode()
  211.    */
  212.   public int hashCode() {
  213.     return (int) version ^ dir.hashCode() ^ (int) gen;
  214.   }
  215. }