honeymoose/OpenSearch
1
0
Fork 0
mirror of https://github.com/honeymoose/OpenSearch.git synced 2025-04-03 05:48:31 +00:00
Code Issues Packages Projects Releases Wiki Activity
OpenSearch/src/main/java/org/elasticsearch/Version.java

328 lines
14 KiB
Java
Raw Normal View History

initial commit
2010-02-08 15:30:06 +02:00
/*
finalize structure, tests pass
2011-12-06 02:42:25 +02:00
* Licensed to ElasticSearch and Shay Banon under one
initial commit
2010-02-08 15:30:06 +02:00
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
finalize structure, tests pass
2011-12-06 02:42:25 +02:00
* regarding copyright ownership. ElasticSearch licenses this
initial commit
2010-02-08 15:30:06 +02:00
* file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.elasticsearch;
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
import org.elasticsearch.common.Nullable;
import org.elasticsearch.common.io.stream.StreamInput;
import org.elasticsearch.common.io.stream.StreamOutput;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
import org.elasticsearch.common.lucene.Lucene;
initial support for process monitoring using sigar
2010-05-06 21:07:24 +03:00
import org.elasticsearch.monitor.jvm.JvmInfo;
Add a -v flag to output version information, closes #128
2010-04-26 11:05:56 +03:00
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
import java.io.IOException;
have version implement serializable to DiscoveryNode can be serialized
2012-02-01 11:52:57 +02:00
import java.io.Serializable;
initial commit
2010-02-08 15:30:06 +02:00
/**
*/
have version implement serializable to DiscoveryNode can be serialized
2012-02-01 11:52:57 +02:00
public class Version implements Serializable {
initial commit
2010-02-08 15:30:06 +02:00
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
// The logic for ID is: XXYYZZAA, where XX is major version, YY is minor version, ZZ is revision, and AA is Beta/RC indicator
// AA values below 50 are beta builds, and below 99 are RC builds, with 99 indicating a release
// the (internal) format of the id is there so we can easily do after/before checks on the id
initial commit
2010-02-08 15:30:06 +02:00
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
public static final int V_0_18_0_ID = /*00*/180099;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_18_0 = new Version(V_0_18_0_ID, false, org.apache.lucene.util.Version.LUCENE_36);
move to 0.19.0 snap
2011-10-26 21:04:10 +02:00
public static final int V_0_18_1_ID = /*00*/180199;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_18_1 = new Version(V_0_18_1_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.18.2 option
2011-10-27 01:43:08 +02:00
public static final int V_0_18_2_ID = /*00*/180299;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_18_2 = new Version(V_0_18_2_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.18.3
2011-10-27 20:42:43 +02:00
public static final int V_0_18_3_ID = /*00*/180399;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_18_3 = new Version(V_0_18_3_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.18.4 version
2011-11-16 15:23:58 +02:00
public static final int V_0_18_4_ID = /*00*/180499;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_18_4 = new Version(V_0_18_4_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.18.5 version
2011-11-16 22:00:13 +02:00
public static final int V_0_18_5_ID = /*00*/180599;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_18_5 = new Version(V_0_18_5_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.18.6
2011-11-29 13:55:11 +02:00
public static final int V_0_18_6_ID = /*00*/180699;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_18_6 = new Version(V_0_18_6_ID, false, org.apache.lucene.util.Version.LUCENE_36);
move to 0.18.7
2011-12-19 11:43:50 +02:00
public static final int V_0_18_7_ID = /*00*/180799;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_18_7 = new Version(V_0_18_7_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.18.8
2012-01-10 13:10:53 +02:00
public static final int V_0_18_8_ID = /*00*/180899;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_18_8 = new Version(V_0_18_8_ID, false, org.apache.lucene.util.Version.LUCENE_36);
initial commit
2010-02-08 15:30:06 +02:00
move to 0.19.0.RC2 snap
2012-02-07 15:17:09 +02:00
public static final int V_0_19_0_RC1_ID = /*00*/190051;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_0_RC1 = new Version(V_0_19_0_RC1_ID, false, org.apache.lucene.util.Version.LUCENE_36);
move to 0.19.0 snap
2011-10-26 21:04:10 +02:00
move to 0.19.0.RC2 snap
2012-02-07 15:17:09 +02:00
public static final int V_0_19_0_RC2_ID = /*00*/190052;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_0_RC2 = new Version(V_0_19_0_RC2_ID, false, org.apache.lucene.util.Version.LUCENE_36);
move to 0.19.0.RC2 snap
2012-02-07 15:17:09 +02:00
update versions to 0.19.3 snap
2012-02-09 00:37:12 +02:00
public static final int V_0_19_0_RC3_ID = /*00*/190053;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_0_RC3 = new Version(V_0_19_0_RC3_ID, false, org.apache.lucene.util.Version.LUCENE_36);
update versions to 0.19.3 snap
2012-02-09 00:37:12 +02:00
release 0.19.0
2012-03-02 11:17:55 +02:00
public static final int V_0_19_0_ID = /*00*/190099;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_0 = new Version(V_0_19_0_ID, false, org.apache.lucene.util.Version.LUCENE_36);
Add 0.19.1
2012-03-02 17:05:41 +02:00
public static final int V_0_19_1_ID = /*00*/190199;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_1 = new Version(V_0_19_1_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.19.2 version
2012-03-20 14:06:29 +02:00
public static final int V_0_19_2_ID = /*00*/190299;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_2 = new Version(V_0_19_2_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.19.3
2012-04-04 20:53:45 +03:00
public static final int V_0_19_3_ID = /*00*/190399;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_3 = new Version(V_0_19_3_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.19.4
2012-04-30 12:33:24 +03:00
public static final int V_0_19_4_ID = /*00*/190499;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_4 = new Version(V_0_19_4_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.19.5
2012-05-21 22:08:14 +02:00
public static final int V_0_19_5_ID = /*00*/190599;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_5 = new Version(V_0_19_5_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.19.6
2012-06-25 15:37:35 +02:00
public static final int V_0_19_6_ID = /*00*/190699;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_6 = new Version(V_0_19_6_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.19.7
2012-06-25 17:34:31 +02:00
public static final int V_0_19_7_ID = /*00*/190799;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_7 = new Version(V_0_19_7_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.19.8
2012-06-26 19:59:40 +02:00
public static final int V_0_19_8_ID = /*00*/190899;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_8 = new Version(V_0_19_8_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.19.9
2012-07-02 22:10:28 +02:00
public static final int V_0_19_9_ID = /*00*/190999;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_9 = new Version(V_0_19_9_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.19.10
2012-08-23 13:52:57 +02:00
public static final int V_0_19_10_ID = /*00*/191099;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_10 = new Version(V_0_19_10_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.19.11 and 0.19.12 versions
2012-10-24 01:41:46 +02:00
public static final int V_0_19_11_ID = /*00*/191199;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_11 = new Version(V_0_19_11_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.19.11 and 0.19.12 versions
2012-10-24 01:41:46 +02:00
public static final int V_0_19_12_ID = /*00*/191299;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_12 = new Version(V_0_19_12_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.19.13
2012-12-04 15:41:38 +01:00
public static final int V_0_19_13_ID = /*00*/191399;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_19_13 = new Version(V_0_19_13_ID, false, org.apache.lucene.util.Version.LUCENE_36);
Add 0.19.1
2012-03-02 17:05:41 +02:00
release 0.20.0.RC1
2012-10-22 01:48:09 +02:00
public static final int V_0_20_0_RC1_ID = /*00*/200051;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_20_0_RC1 = new Version(V_0_20_0_RC1_ID, false, org.apache.lucene.util.Version.LUCENE_36);
use the 0.20.0 version
2012-12-07 23:15:44 +01:00
public static final int V_0_20_0_ID = /*00*/200099;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_20_0 = new Version(V_0_20_0_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.20 versions
2012-12-08 01:37:21 +01:00
public static final int V_0_20_1_ID = /*00*/200199;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_20_1 = new Version(V_0_20_1_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.20 versions
2012-12-08 01:37:21 +01:00
public static final int V_0_20_2_ID = /*00*/200299;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_20_2 = new Version(V_0_20_2_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.20.3
2012-12-27 14:30:40 -08:00
public static final int V_0_20_3_ID = /*00*/200399;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_20_3 = new Version(V_0_20_3_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.20.4
2013-01-25 22:02:34 +01:00
public static final int V_0_20_4_ID = /*00*/200499;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_20_4 = new Version(V_0_20_4_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.20.5
2013-01-29 10:14:25 +01:00
public static final int V_0_20_5_ID = /*00*/200599;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_20_5 = new Version(V_0_20_5_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.20.6 ver
2013-02-14 14:29:30 +01:00
public static final int V_0_20_6_ID = /*00*/200699;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_20_6 = new Version(V_0_20_6_ID, false, org.apache.lucene.util.Version.LUCENE_36);
add 0.20.7
2013-03-25 12:33:55 +01:00
public static final int V_0_20_7_ID = /*00*/200799;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_20_7 = new Version(V_0_20_7_ID, false, org.apache.lucene.util.Version.LUCENE_36);
move to 0.20.0.Beta1 snapshot
2012-03-02 11:23:24 +02:00
release 0.90.0.Beta1
2013-02-26 10:32:50 +01:00
public static final int V_0_90_0_Beta1_ID = /*00*/900001;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_90_0_Beta1 = new Version(V_0_90_0_Beta1_ID, false, org.apache.lucene.util.Version.LUCENE_41);
release 0.90.0.RC1
2013-03-20 19:05:08 +01:00
public static final int V_0_90_0_RC1_ID = /*00*/900051;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_90_0_RC1 = new Version(V_0_90_0_RC1_ID, false, org.apache.lucene.util.Version.LUCENE_41);
move to 0.90.0.RC2 snap
2013-03-20 19:06:30 +01:00
public static final int V_0_90_0_RC2_ID = /*00*/900052;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public static final Version V_0_90_0_RC2 = new Version(V_0_90_0_RC2_ID, false, org.apache.lucene.util.Version.LUCENE_42);
release 0.90.0 GA
2013-04-29 13:41:43 +02:00
public static final int V_0_90_0_ID = /*00*/900099;
public static final Version V_0_90_0 = new Version(V_0_90_0_ID, false, org.apache.lucene.util.Version.LUCENE_42);
move to 1.0.0.Beta1 snap
2013-04-29 13:51:09 +02:00
public static final int V_0_90_1_ID = /*00*/900199;
Upgrade to Lucene 4.3.0 This Lucene Release introduced a new API on DocIdSetIterator that requires each implementation to return a `cost` upperbound as a function of the iterated documents. This API allows for several optimizations during query execution especially in Conjunction and Disjunction Queries with min_should_match set. Closes #2990
2013-04-17 22:12:07 +02:00
public static final Version V_0_90_1 = new Version(V_0_90_1_ID, false, org.apache.lucene.util.Version.LUCENE_43);
add 0.90.2 version
2013-05-30 14:27:33 +02:00
public static final int V_0_90_2_ID = /*00*/900299;
public static final Version V_0_90_2 = new Version(V_0_90_2_ID, false, org.apache.lucene.util.Version.LUCENE_43);
add 0.90.3
2013-06-26 09:02:54 +01:00
public static final int V_0_90_3_ID = /*00*/900399;
0.90.3 uses lucene 44
2013-07-25 18:33:52 +02:00
public static final Version V_0_90_3 = new Version(V_0_90_3_ID, false, org.apache.lucene.util.Version.LUCENE_44);
move to 0.90.0.RC2 snap
2013-03-20 19:06:30 +01:00
move to 1.0.0.Beta1 snap
2013-04-29 13:51:09 +02:00
public static final int V_1_0_0_Beta1_ID = /*00*/1000001;
Upgrade to Lucene 4.4
2013-07-16 15:41:23 +02:00
public static final Version V_1_0_0_Beta1 = new Version(V_1_0_0_Beta1_ID, true, org.apache.lucene.util.Version.LUCENE_44);
move to 1.0.0.Beta1 snap
2013-04-29 13:51:09 +02:00
public static final Version CURRENT = V_1_0_0_Beta1;
add 0.90.2 version
2013-05-30 14:27:33 +02:00
Upgrade Lucene Version to 4.2. The latest Elasticsearch version must use the latest Lucene version as specified in o.e.common.lucene.Lucene and must be upgraded with each lucene release. This commit adds an assert that fails once the actual lucene version that is used is higher than the current releases version.
2013-04-30 13:15:29 +02:00
static {
add 0.90.2 version
2013-05-30 14:27:33 +02:00
assert CURRENT.luceneVersion == Lucene.VERSION : "Version must be upgraded to [" + Lucene.VERSION + "] is still set to [" + CURRENT.luceneVersion + "]";
Upgrade Lucene Version to 4.2. The latest Elasticsearch version must use the latest Lucene version as specified in o.e.common.lucene.Lucene and must be upgraded with each lucene release. This commit adds an assert that fails once the actual lucene version that is used is higher than the current releases version.
2013-04-30 13:15:29 +02:00
}
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
public static Version readVersion(StreamInput in) throws IOException {
return fromId(in.readVInt());
}
improve multicast message to have an internal header for node to node discovery
2011-12-16 18:29:10 +02:00
public static Version fromId(int id) {
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
switch (id) {
move to 1.0.0.Beta1 snap
2013-04-29 13:51:09 +02:00
case V_1_0_0_Beta1_ID:
return V_1_0_0_Beta1;
add 0.90.3
2013-06-26 09:02:54 +01:00
case V_0_90_3_ID:
return V_0_90_3;
add 0.90.2 version
2013-05-30 14:27:33 +02:00
case V_0_90_2_ID:
return V_0_90_2;
move to 1.0.0.Beta1 snap
2013-04-29 13:51:09 +02:00
case V_0_90_1_ID:
return V_0_90_1;
release 0.90.0 GA
2013-04-29 13:41:43 +02:00
case V_0_90_0_ID:
return V_0_90_0;
move to 0.90.0.RC2 snap
2013-03-20 19:06:30 +01:00
case V_0_90_0_RC2_ID:
return V_0_90_0_RC2;
release 0.90.0.RC1
2013-03-20 19:05:08 +01:00
case V_0_90_0_RC1_ID:
return V_0_90_0_RC1;
release 0.90.0.Beta1
2013-02-26 10:32:50 +01:00
case V_0_90_0_Beta1_ID:
return V_0_90_0_Beta1;
move master to be 0.21.0 Beta1 snap
2012-10-22 01:51:20 +02:00
add 0.20.7
2013-03-25 12:33:55 +01:00
case V_0_20_7_ID:
return V_0_20_7;
add 0.20.6 ver
2013-02-14 14:29:30 +01:00
case V_0_20_6_ID:
return V_0_20_6;
add 0.20.5
2013-01-29 10:14:25 +01:00
case V_0_20_5_ID:
return V_0_20_5;
add 0.20.4
2013-01-25 22:02:34 +01:00
case V_0_20_4_ID:
return V_0_20_4;
add 0.20.3
2012-12-27 14:30:40 -08:00
case V_0_20_3_ID:
return V_0_20_3;
add 0.20 versions
2012-12-08 01:37:21 +01:00
case V_0_20_2_ID:
return V_0_20_2;
case V_0_20_1_ID:
return V_0_20_1;
use the 0.20.0 version
2012-12-07 23:15:44 +01:00
case V_0_20_0_ID:
return V_0_20_0;
release 0.20.0.RC1
2012-10-22 01:48:09 +02:00
case V_0_20_0_RC1_ID:
return V_0_20_0_RC1;
move to 0.18.7
2011-12-19 11:43:50 +02:00
move to 0.19.0.RC2 snap
2012-02-07 15:17:09 +02:00
case V_0_19_0_RC1_ID:
return V_0_19_0_RC1;
case V_0_19_0_RC2_ID:
return V_0_19_0_RC2;
update versions to 0.19.3 snap
2012-02-09 00:37:12 +02:00
case V_0_19_0_RC3_ID:
return V_0_19_0_RC3;
release 0.19.0
2012-03-02 11:17:55 +02:00
case V_0_19_0_ID:
return V_0_19_0;
Add 0.19.1
2012-03-02 17:05:41 +02:00
case V_0_19_1_ID:
return V_0_19_1;
add 0.19.2 version
2012-03-20 14:06:29 +02:00
case V_0_19_2_ID:
return V_0_19_2;
add 0.19.3
2012-04-04 20:53:45 +03:00
case V_0_19_3_ID:
return V_0_19_3;
add 0.19.4
2012-04-30 12:33:24 +03:00
case V_0_19_4_ID:
return V_0_19_4;
add 0.19.5
2012-05-21 22:08:14 +02:00
case V_0_19_5_ID:
return V_0_19_5;
add 0.19.6
2012-06-25 15:37:35 +02:00
case V_0_19_6_ID:
return V_0_19_6;
add 0.19.7
2012-06-25 17:34:31 +02:00
case V_0_19_7_ID:
return V_0_19_7;
add 0.19.8
2012-06-26 19:59:40 +02:00
case V_0_19_8_ID:
return V_0_19_8;
add 0.19.9
2012-07-02 22:10:28 +02:00
case V_0_19_9_ID:
return V_0_19_9;
add 0.19.10
2012-08-23 13:52:57 +02:00
case V_0_19_10_ID:
return V_0_19_10;
add 0.19.11 and 0.19.12 versions
2012-10-24 01:41:46 +02:00
case V_0_19_11_ID:
return V_0_19_11;
case V_0_19_12_ID:
return V_0_19_12;
add 0.19.13
2012-12-04 15:41:38 +01:00
case V_0_19_13_ID:
return V_0_19_13;
move to 0.20.0.Beta1 snapshot
2012-03-02 11:23:24 +02:00
add node version to each request/response transport message a version associated with each request, and having it associated with the stream when (de)serializing, can allow us in the future to better support cross version communication
2012-09-22 02:35:29 +02:00
case V_0_18_0_ID:
return V_0_18_0;
case V_0_18_1_ID:
return V_0_18_1;
case V_0_18_2_ID:
return V_0_18_2;
case V_0_18_3_ID:
return V_0_18_3;
case V_0_18_4_ID:
return V_0_18_4;
case V_0_18_5_ID:
return V_0_18_5;
case V_0_18_6_ID:
return V_0_18_6;
case V_0_18_7_ID:
return V_0_18_7;
case V_0_18_8_ID:
return V_0_18_8;
move to 0.20.0.Beta1 snapshot
2012-03-02 11:23:24 +02:00
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
default:
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
return new Version(id, null, Lucene.VERSION);
initial commit
2010-02-08 15:30:06 +02:00
}
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
}
initial commit
2010-02-08 15:30:06 +02:00
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
public static void writeVersion(Version version, StreamOutput out) throws IOException {
out.writeVInt(version.id);
initial commit
2010-02-08 15:30:06 +02:00
}
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
public final int id;
public final byte major;
public final byte minor;
public final byte revision;
public final byte build;
public final Boolean snapshot;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
public final org.apache.lucene.util.Version luceneVersion;
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
Version(int id, @Nullable Boolean snapshot, org.apache.lucene.util.Version luceneVersion) {
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
this.id = id;
this.major = (byte) ((id / 1000000) % 100);
this.minor = (byte) ((id / 10000) % 100);
this.revision = (byte) ((id / 100) % 100);
this.build = (byte) (id % 100);
this.snapshot = snapshot;
Use Lucene Version that was used to create the index in Analysis Lucene ships with a version constant that is mainly used to provide consistent behaviour across lucene release versions. Lucene's Analysis capabilities are commonly applied at index and search time such that the search-time behaviour should be identical to the index-time behaviour in most of the cases. Currently ElasticSearch always uses the latest version from Lucene which can break backwards compatibility with the index for users that rely on behaviour that changed in new Lucene version. Users should always use the version the index was created with unless it's explicitly configured. closes #2945
2013-04-29 13:18:51 +02:00
this.luceneVersion = luceneVersion;
initial commit
2010-02-08 15:30:06 +02:00
}
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
public boolean snapshot() {
return snapshot != null && snapshot;
initial commit
2010-02-08 15:30:06 +02:00
}
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
public boolean after(Version version) {
Changing version semantics to be more readable The Version class had hard to understand semantics when two versions were compared against each other. Sample of the new logic: * V_0_20_0.before(V_0_90_0) => true * V_0_90_0.after(V_0_20_0) => true Closes #3124
2013-05-31 17:01:21 +02:00
return version.id < id;
initial commit
2010-02-08 15:30:06 +02:00
}
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
public boolean onOrAfter(Version version) {
Changing version semantics to be more readable The Version class had hard to understand semantics when two versions were compared against each other. Sample of the new logic: * V_0_20_0.before(V_0_90_0) => true * V_0_90_0.after(V_0_20_0) => true Closes #3124
2013-05-31 17:01:21 +02:00
return version.id <= id;
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
}
Transport: Add header token This allows to more easily identify when illegal content is being sent to the transport port closes #2280
2012-09-21 23:56:27 +02:00
public boolean before(Version version) {
Changing version semantics to be more readable The Version class had hard to understand semantics when two versions were compared against each other. Sample of the new logic: * V_0_20_0.before(V_0_90_0) => true * V_0_90_0.after(V_0_20_0) => true Closes #3124
2013-05-31 17:01:21 +02:00
return version.id > id;
Transport: Add header token This allows to more easily identify when illegal content is being sent to the transport port closes #2280
2012-09-21 23:56:27 +02:00
}
public boolean onOrBefore(Version version) {
Changing version semantics to be more readable The Version class had hard to understand semantics when two versions were compared against each other. Sample of the new logic: * V_0_20_0.before(V_0_90_0) => true * V_0_90_0.after(V_0_20_0) => true Closes #3124
2013-05-31 17:01:21 +02:00
return version.id >= id;
Transport: Add header token This allows to more easily identify when illegal content is being sent to the transport port closes #2280
2012-09-21 23:56:27 +02:00
}
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
/**
* Just the version number (without -SNAPSHOT if snapshot).
*/
public String number() {
StringBuilder sb = new StringBuilder();
sb.append(major).append('.').append(minor).append('.').append(revision);
if (build < 50) {
sb.append(".Beta").append(build);
} else if (build < 99) {
sb.append(".RC").append(build - 50);
initial commit
2010-02-08 15:30:06 +02:00
}
return sb.toString();
}
Add a -v flag to output version information, closes #128
2010-04-26 11:05:56 +03:00
public static void main(String[] args) {
Add Git build info when we build a distribution closes #3370
2013-07-24 20:24:23 +02:00
System.out.println("Version: " + Version.CURRENT + ", Build: " + Build.CURRENT.hashShort() + "/" + Build.CURRENT.timestamp() + ", JVM: " + JvmInfo.jvmInfo().version());
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
}
finalize structure, tests pass
2011-12-06 02:42:25 +02:00
@Override
public String toString() {
associate a version with a discovery node
2011-10-05 12:42:27 +02:00
StringBuilder sb = new StringBuilder();
sb.append(number());
if (snapshot()) {
sb.append("-SNAPSHOT");
}
return sb.toString();
Add a -v flag to output version information, closes #128
2010-04-26 11:05:56 +03:00
}
add node version to each request/response transport message a version associated with each request, and having it associated with the stream when (de)serializing, can allow us in the future to better support cross version communication
2012-09-22 02:35:29 +02:00
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Version version = (Version) o;
if (id != version.id) return false;
return true;
}
@Override
public int hashCode() {
return id;
}
initial commit
2010-02-08 15:30:06 +02:00
}
Reference in New Issue Copy Permalink