honeymoose/OpenSearch
1
0
Fork 0
mirror of https://github.com/honeymoose/OpenSearch.git synced 2025-02-16 09:54:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Consumer Plugin integration tests; Represent feature as string; proper handling of trial licenses

Browse Source 
Original commit: elastic/x-pack-elasticsearch@d86f98a435
This commit is contained in:
Areek Zillur 2014-10-20 15:42:23 -04:00
parent 9f84847681
commit 1964ebc6f2
24 changed files with 408 additions and 287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
src/main/java/org/elasticsearch/license/core/ESLicenses.java
View File

@ -25,12 +25,13 @@ public interface ESLicenses extends Iterable<ESLicenses.ESLicense> {
/** /**
* @return Set of features for which there exists an underlying license * @return Set of features for which there exists an underlying license
*/ */
public Set<FeatureType> features(); public Set<String> features();
/** /**
* @return a license for a code>featureType<</code> * @return a license for a code>featureType<</code>
* @param feature
*/ */
public ESLicense get(FeatureType featureType); public ESLicense get(String feature);
/** /**
* Enum for License Type * Enum for License Type
@ -103,34 +104,6 @@ public interface ESLicenses extends Iterable<ESLicenses.ESLicense> {
} }
} }
/**
* Enum for License FeatureType
*/
public enum FeatureType {
SHIELD("shield"),
MARVEL("marvel");
private final String name;
private FeatureType(String name) {
this.name = name;
}
public String string() {
return name;
}
public static FeatureType fromString(String featureType) {
if (featureType.equalsIgnoreCase(SHIELD.string())) {
return SHIELD;
} else if (featureType.equalsIgnoreCase(MARVEL.string())) {
return MARVEL;
} else {
throw new IllegalArgumentException("Invalid FeatureType=" + featureType);
}
}
}
/** /**
* Interface representing all the license fields * Interface representing all the license fields
*/ */
@ -159,7 +132,7 @@ public interface ESLicenses extends Iterable<ESLicenses.ESLicense> {
/** /**
* @return the featureType for the license [shield, marvel] * @return the featureType for the license [shield, marvel]
*/ */
public FeatureType feature(); public String feature();
/** /**
* @return the expiry date in milliseconds * @return the expiry date in milliseconds

18
src/main/java/org/elasticsearch/license/core/LicenseBuilders.java
View File

@ -49,7 +49,7 @@ public class LicenseBuilders {
} }
} }
public static ESLicenses removeFeatures(ESLicenses licenses, Set<FeatureType> featureTypesToDelete) { public static ESLicenses removeFeatures(ESLicenses licenses, Set<String> featureTypesToDelete) {
final LicensesBuilder licensesBuilder = licensesBuilder(); final LicensesBuilder licensesBuilder = licensesBuilder();
for (ESLicense license : licenses) { for (ESLicense license : licenses) {
if (!featureTypesToDelete.contains(license.feature())) { if (!featureTypesToDelete.contains(license.feature())) {
@ -60,7 +60,7 @@ public class LicenseBuilders {
} }
public static class LicensesBuilder { public static class LicensesBuilder {
private Map<FeatureType, ESLicense> licenseMap = new HashMap<>(); private Map<String, ESLicense> licenseMap = new HashMap<>();
public LicensesBuilder() { public LicensesBuilder() {
} }
@ -98,13 +98,13 @@ public class LicenseBuilders {
} }
@Override @Override
public Set<FeatureType> features() { public Set<String> features() {
return licenseMap.keySet(); return licenseMap.keySet();
} }
@Override @Override
public ESLicense get(FeatureType featureType) { public ESLicense get(String feature) {
return licenseMap.get(featureType); return licenseMap.get(feature);
} }
@Override @Override
@ -124,7 +124,7 @@ public class LicenseBuilders {
* @param license license in question * @param license license in question
*/ */
private void putIfAppropriate(ESLicense license) { private void putIfAppropriate(ESLicense license) {
final FeatureType featureType = license.feature(); final String featureType = license.feature();
if (licenseMap.containsKey(featureType)) { if (licenseMap.containsKey(featureType)) {
final ESLicense previousLicense = licenseMap.get(featureType); final ESLicense previousLicense = licenseMap.get(featureType);
if (license.expiryDate() > previousLicense.expiryDate()) { if (license.expiryDate() > previousLicense.expiryDate()) {
@ -143,7 +143,7 @@ public class LicenseBuilders {
private long issueDate = -1; private long issueDate = -1;
private Type type; private Type type;
private SubscriptionType subscriptionType = SubscriptionType.DEFAULT; private SubscriptionType subscriptionType = SubscriptionType.DEFAULT;
private FeatureType feature; private String feature;
private String signature; private String signature;
private long expiryDate = -1; private long expiryDate = -1;
private int maxNodes; private int maxNodes;
@ -185,7 +185,7 @@ public class LicenseBuilders {
return this; return this;
} }
public LicenseBuilder feature(FeatureType feature) { public LicenseBuilder feature(String feature) {
this.feature = feature; this.feature = feature;
return this; return this;
} }
@ -251,7 +251,7 @@ public class LicenseBuilders {
} }
@Override @Override
public FeatureType feature() { public String feature() {
return feature; return feature;
} }

6
src/main/java/org/elasticsearch/license/core/LicenseUtils.java
View File

@ -34,7 +34,7 @@ public class LicenseUtils {
generator.writeStringField("issued_to", esLicense.issuedTo()); generator.writeStringField("issued_to", esLicense.issuedTo());
generator.writeStringField("issue_date", DateUtils.dateStringFromLongDate(esLicense.issueDate())); generator.writeStringField("issue_date", DateUtils.dateStringFromLongDate(esLicense.issueDate()));
generator.writeStringField("expiry_date", DateUtils.dateStringFromLongDate(esLicense.expiryDate())); generator.writeStringField("expiry_date", DateUtils.dateStringFromLongDate(esLicense.expiryDate()));
generator.writeStringField("feature", esLicense.feature().string()); generator.writeStringField("feature", esLicense.feature());
generator.writeNumberField("max_nodes", esLicense.maxNodes()); generator.writeNumberField("max_nodes", esLicense.maxNodes());
generator.writeStringField("signature", esLicense.signature()); generator.writeStringField("signature", esLicense.signature());
} }
@ -101,7 +101,7 @@ public class LicenseUtils {
.issueDate(getValueAsDate(licenseNode, "issue_date")) .issueDate(getValueAsDate(licenseNode, "issue_date"))
.type(ESLicenses.Type.fromString(getValueAsString(licenseNode, "type"))) .type(ESLicenses.Type.fromString(getValueAsString(licenseNode, "type")))
.subscriptionType(ESLicenses.SubscriptionType.fromString(getValueAsString(licenseNode, "subscription_type"))) .subscriptionType(ESLicenses.SubscriptionType.fromString(getValueAsString(licenseNode, "subscription_type")))
.feature(ESLicenses.FeatureType.fromString(getValueAsString(licenseNode, "feature"))) .feature(getValueAsString(licenseNode, "feature"))
.expiryDate(getValueAsExpiryDate(licenseNode, "expiry_date")) .expiryDate(getValueAsExpiryDate(licenseNode, "expiry_date"))
.maxNodes(getValueAsInt(licenseNode, "max_nodes")) .maxNodes(getValueAsInt(licenseNode, "max_nodes"))
.signature(getValueAsString(licenseNode, "signature", true)) .signature(getValueAsString(licenseNode, "signature", true))
@ -168,7 +168,7 @@ public class LicenseUtils {
printValue(" subscription_type", license.subscriptionType().string()); printValue(" subscription_type", license.subscriptionType().string());
printValue(" issueDate", DateUtils.dateStringFromLongDate(license.issueDate())); printValue(" issueDate", DateUtils.dateStringFromLongDate(license.issueDate()));
printValue(" issuedTo", license.issuedTo()); printValue(" issuedTo", license.issuedTo());
printValue(" feature", license.feature().string()); printValue(" feature", license.feature());
printValue(" maxNodes", license.maxNodes()); printValue(" maxNodes", license.maxNodes());
printValue(" expiryDate", DateUtils.dateStringFromLongDate(license.expiryDate())); printValue(" expiryDate", DateUtils.dateStringFromLongDate(license.expiryDate()));
printValue(" signature", license.signature()); printValue(" signature", license.signature());

6
src/main/java/org/elasticsearch/license/licensor/ESLicenseSigner.java
View File

@ -6,6 +6,7 @@
package org.elasticsearch.license.licensor; package org.elasticsearch.license.licensor;
import net.nicholaswilliams.java.licensing.License; import net.nicholaswilliams.java.licensing.License;
import net.nicholaswilliams.java.licensing.SignedLicense;
import net.nicholaswilliams.java.licensing.encryption.Hasher; import net.nicholaswilliams.java.licensing.encryption.Hasher;
import net.nicholaswilliams.java.licensing.encryption.PasswordProvider; import net.nicholaswilliams.java.licensing.encryption.PasswordProvider;
import net.nicholaswilliams.java.licensing.encryption.PrivateKeyDataProvider; import net.nicholaswilliams.java.licensing.encryption.PrivateKeyDataProvider;
@ -91,7 +92,7 @@ public class ESLicenseSigner {
.withProductKey(esLicense.uid()) .withProductKey(esLicense.uid())
.withHolder(esLicense.issuedTo()) .withHolder(esLicense.issuedTo())
.withIssuer(esLicense.issuer()) .withIssuer(esLicense.issuer())
.addFeature(esLicense.feature().string(), esLicense.expiryDate()) .addFeature("feature:" + esLicense.feature(), esLicense.expiryDate())
.addFeature("maxNodes:" + String.valueOf(esLicense.maxNodes())) .addFeature("maxNodes:" + String.valueOf(esLicense.maxNodes()))
.addFeature("type:" + esLicense.type().string()) .addFeature("type:" + esLicense.type().string())
.addFeature("subscription_type:" + esLicense.subscriptionType().string()); .addFeature("subscription_type:" + esLicense.subscriptionType().string());
@ -101,7 +102,8 @@ public class ESLicenseSigner {
final byte[] magic = new byte[MAGIC_LENGTH]; final byte[] magic = new byte[MAGIC_LENGTH];
Random random = new Random(); Random random = new Random();
random.nextBytes(magic); random.nextBytes(magic);
final byte[] licenseSignature = licenseCreator.signAndSerializeLicense(license); //final SignedLicense signedLicense = licenseCreator.signLicense(license);
final byte[] licenseSignature = licenseCreator.signAndSerializeLicense(license);//signedLicense.getSignatureContent();
final byte[] hash = Hasher.hash(Base64.encodeBase64String( final byte[] hash = Hasher.hash(Base64.encodeBase64String(
Files.readAllBytes(publicKeyPath)) Files.readAllBytes(publicKeyPath))
).getBytes(Charset.forName("UTF-8")); ).getBytes(Charset.forName("UTF-8"));

4
src/main/java/org/elasticsearch/license/licensor/tools/FileBasedESLicenseProvider.java
View File

@ -25,8 +25,8 @@ public class FileBasedESLicenseProvider implements ESLicenseProvider {
} }
@Override @Override
public ESLicenses.ESLicense getESLicense(ESLicenses.FeatureType featureType) { public ESLicenses.ESLicense getESLicense(String feature) {
return esLicenses.get(featureType); return esLicenses.get(feature);
} }
@Override @Override

43
src/main/java/org/elasticsearch/license/manager/ESLicenseManager.java
View File

@ -80,8 +80,8 @@ public class ESLicenseManager {
public void verifyLicenses(ESLicenses esLicenses) { public void verifyLicenses(ESLicenses esLicenses) {
try { try {
for (FeatureType featureType : esLicenses.features()) { for (String feature : esLicenses.features()) {
ESLicense esLicense = esLicenses.get(featureType); ESLicense esLicense = esLicenses.get(feature);
// verify signature // verify signature
final License license = this.licenseManager.decryptAndVerifyLicense( final License license = this.licenseManager.decryptAndVerifyLicense(
extractSignedLicence(esLicense.signature())); extractSignedLicence(esLicense.signature()));
@ -94,7 +94,7 @@ public class ESLicenseManager {
} catch (ExpiredLicenseException e) { } catch (ExpiredLicenseException e) {
throw new InvalidLicenseException("Expired License"); throw new InvalidLicenseException("Expired License");
} catch (InvalidLicenseException e) { } catch (InvalidLicenseException e) {
throw new InvalidLicenseException("Invalid License"); throw new InvalidLicenseException("Invalid License: " + e.getCause());
} }
} }
@ -132,6 +132,7 @@ public class ESLicenseManager {
String maxNodesPrefix = "maxNodes:"; String maxNodesPrefix = "maxNodes:";
String typePrefix = "type:"; String typePrefix = "type:";
String subscriptionTypePrefix = "subscription_type:"; String subscriptionTypePrefix = "subscription_type:";
String featurePrefix = "feature:";
boolean maxNodesValid = false; boolean maxNodesValid = false;
boolean featureValid = false; boolean featureValid = false;
boolean typeValid = false; boolean typeValid = false;
@ -145,8 +146,9 @@ public class ESLicenseManager {
typeValid = eslicense.type() == Type.fromString(featureName.substring(typePrefix.length())); typeValid = eslicense.type() == Type.fromString(featureName.substring(typePrefix.length()));
} else if (featureName.startsWith(subscriptionTypePrefix)) { } else if (featureName.startsWith(subscriptionTypePrefix)) {
subscriptionTypeValid = eslicense.subscriptionType() == SubscriptionType.fromString(featureName.substring(subscriptionTypePrefix.length())); subscriptionTypeValid = eslicense.subscriptionType() == SubscriptionType.fromString(featureName.substring(subscriptionTypePrefix.length()));
} else { } else if (featureName.startsWith(featurePrefix)) {
featureValid = feature.getName().equals(eslicense.feature().string()) String featureValue = featureName.substring(featurePrefix.length());
featureValid = featureValue.equals(eslicense.feature())
&& feature.getGoodBeforeDate() == eslicense.expiryDate(); && feature.getGoodBeforeDate() == eslicense.expiryDate();
} }
} }
@ -160,8 +162,8 @@ public class ESLicenseManager {
throw new InvalidLicenseException("Invalid License"); throw new InvalidLicenseException("Invalid License");
} }
} }
private License getLicense(FeatureType featureType) { private License getLicense(String feature) {
ESLicense esLicense = licenseProvider.getESLicense(featureType); ESLicense esLicense = licenseProvider.getESLicense(feature);
if (esLicense != null) { if (esLicense != null) {
String signature = esLicense.signature(); String signature = esLicense.signature();
License license = this.licenseManager.decryptAndVerifyLicense(extractSignedLicence(signature)); License license = this.licenseManager.decryptAndVerifyLicense(extractSignedLicence(signature));
@ -173,11 +175,11 @@ public class ESLicenseManager {
//TODO wrap License validation methods so a plugin does not have to provide featureType param //TODO wrap License validation methods so a plugin does not have to provide featureType param
public boolean hasLicenseForFeature(FeatureType featureType) { public boolean hasLicenseForFeature(String feature) {
try { try {
final License license = getLicense(featureType); final License license = getLicense(feature);
if (license != null) { if (license != null) {
return license.hasLicenseForFeature(featureType.string()); return license.hasLicenseForFeature("feature:" + feature);
} }
return false; return false;
} catch (ExpiredLicenseException e) { } catch (ExpiredLicenseException e) {
@ -187,42 +189,42 @@ public class ESLicenseManager {
} }
} }
public boolean hasLicenseForNodes(FeatureType featureType, int nodes) { public boolean hasLicenseForNodes(String featureType, int nodes) {
ESLicense esLicense = getESLicense(featureType); ESLicense esLicense = getESLicense(featureType);
return esLicense.maxNodes() >= nodes; return esLicense.maxNodes() >= nodes;
} }
public String getIssuerForLicense(FeatureType featureType) { public String getIssuerForLicense(String featureType) {
final License license = getLicense(featureType); final License license = getLicense(featureType);
return license.getIssuer(); return license.getIssuer();
} }
public long getIssueDateForLicense(FeatureType featureType) { public long getIssueDateForLicense(String featureType) {
final License license = getLicense(featureType); final License license = getLicense(featureType);
return license.getIssueDate(); return license.getIssueDate();
} }
public long getExpiryDateForLicense(FeatureType featureType) { public long getExpiryDateForLicense(String featureType) {
final License license = getLicense(featureType); final License license = getLicense(featureType);
return license.getGoodBeforeDate(); return license.getGoodBeforeDate();
} }
public String getIssuedToForLicense(FeatureType featureType) { public String getIssuedToForLicense(String featureType) {
final License license = getLicense(featureType); final License license = getLicense(featureType);
return license.getHolder(); return license.getHolder();
} }
public Type getTypeForLicense(FeatureType featureType) { public Type getTypeForLicense(String featureType) {
ESLicense esLicense = getESLicense(featureType); ESLicense esLicense = getESLicense(featureType);
return esLicense.type(); return esLicense.type();
} }
public SubscriptionType getSubscriptionTypeForLicense(FeatureType featureType) { public SubscriptionType getSubscriptionTypeForLicense(String featureType) {
ESLicense esLicense = getESLicense(featureType); ESLicense esLicense = getESLicense(featureType);
return esLicense.subscriptionType(); return esLicense.subscriptionType();
} }
ESLicense getESLicense(FeatureType featureType) { ESLicense getESLicense(String featureType) {
final License license = getLicense(featureType); final License license = getLicense(featureType);
return convertToESLicense(license); return convertToESLicense(license);
} }
@ -252,6 +254,7 @@ public class ESLicenseManager {
String maxNodesPrefix = "maxNodes:"; String maxNodesPrefix = "maxNodes:";
String typePrefix = "type:"; String typePrefix = "type:";
String subscriptionTypePrefix = "subscription_type:"; String subscriptionTypePrefix = "subscription_type:";
String featurePrefix = "feature:";
for (License.Feature feature : license.getFeatures()) { for (License.Feature feature : license.getFeatures()) {
String featureName = feature.getName(); String featureName = feature.getName();
if (featureName.startsWith(maxNodesPrefix)) { if (featureName.startsWith(maxNodesPrefix)) {
@ -260,8 +263,8 @@ public class ESLicenseManager {
licenseBuilder.type(Type.fromString(featureName.substring(typePrefix.length()))); licenseBuilder.type(Type.fromString(featureName.substring(typePrefix.length())));
} else if (featureName.startsWith(subscriptionTypePrefix)) { } else if (featureName.startsWith(subscriptionTypePrefix)) {
licenseBuilder.subscriptionType(SubscriptionType.fromString(featureName.substring(subscriptionTypePrefix.length()))); licenseBuilder.subscriptionType(SubscriptionType.fromString(featureName.substring(subscriptionTypePrefix.length())));
} else { } else if (featureName.startsWith(featurePrefix)) {
licenseBuilder.feature(FeatureType.fromString(featureName)); licenseBuilder.feature(featureName.substring(featurePrefix.length()));
} }
} }
return licenseBuilder.build(); return licenseBuilder.build();

3
src/main/java/org/elasticsearch/license/manager/ESLicenseProvider.java
View File

@ -8,11 +8,10 @@ package org.elasticsearch.license.manager;
import org.elasticsearch.license.core.ESLicenses; import org.elasticsearch.license.core.ESLicenses;
import static org.elasticsearch.license.core.ESLicenses.ESLicense; import static org.elasticsearch.license.core.ESLicenses.ESLicense;
import static org.elasticsearch.license.core.ESLicenses.FeatureType;
public interface ESLicenseProvider { public interface ESLicenseProvider {
ESLicense getESLicense(FeatureType featureType); ESLicense getESLicense(String feature);
ESLicenses getEffectiveLicenses(); ESLicenses getEffectiveLicenses();
} }

4
src/main/java/org/elasticsearch/license/plugin/action/Utils.java
View File

@ -60,7 +60,7 @@ public class Utils {
builder.put(LicenseFields.TYPE, esLicense.type().string()); builder.put(LicenseFields.TYPE, esLicense.type().string());
builder.put(LicenseFields.SUBSCRIPTION_TYPE, esLicense.subscriptionType().string()); builder.put(LicenseFields.SUBSCRIPTION_TYPE, esLicense.subscriptionType().string());
builder.put(LicenseFields.ISSUE_DATE, esLicense.issueDate()); builder.put(LicenseFields.ISSUE_DATE, esLicense.issueDate());
builder.put(LicenseFields.FEATURE, esLicense.feature().string()); builder.put(LicenseFields.FEATURE, esLicense.feature());
builder.put(LicenseFields.EXPIRY_DATE, esLicense.expiryDate()); builder.put(LicenseFields.EXPIRY_DATE, esLicense.expiryDate());
builder.put(LicenseFields.MAX_NODES, esLicense.maxNodes()); builder.put(LicenseFields.MAX_NODES, esLicense.maxNodes());
builder.put(LicenseFields.ISSUED_TO, esLicense.issuedTo()); builder.put(LicenseFields.ISSUED_TO, esLicense.issuedTo());
@ -74,7 +74,7 @@ public class Utils {
.type(Type.fromString((String) map.get(LicenseFields.TYPE))) .type(Type.fromString((String) map.get(LicenseFields.TYPE)))
.subscriptionType(SubscriptionType.fromString((String) map.get(LicenseFields.SUBSCRIPTION_TYPE))) .subscriptionType(SubscriptionType.fromString((String) map.get(LicenseFields.SUBSCRIPTION_TYPE)))
.issueDate((long) map.get(LicenseFields.ISSUE_DATE)) .issueDate((long) map.get(LicenseFields.ISSUE_DATE))
.feature(FeatureType.fromString((String) map.get(LicenseFields.FEATURE))) .feature((String) map.get(LicenseFields.FEATURE))
.expiryDate((long) map.get(LicenseFields.EXPIRY_DATE)) .expiryDate((long) map.get(LicenseFields.EXPIRY_DATE))
.maxNodes((int) map.get(LicenseFields.MAX_NODES)) .maxNodes((int) map.get(LicenseFields.MAX_NODES))
.issuedTo((String) map.get(LicenseFields.ISSUED_TO)) .issuedTo((String) map.get(LicenseFields.ISSUED_TO))

4
src/main/java/org/elasticsearch/license/plugin/core/LicensesManagerService.java
View File

@ -11,6 +11,8 @@ import org.elasticsearch.common.inject.ImplementedBy;
import org.elasticsearch.common.inject.Singleton; import org.elasticsearch.common.inject.Singleton;
import org.elasticsearch.license.core.ESLicenses; import org.elasticsearch.license.core.ESLicenses;
import java.util.Set;
import static org.elasticsearch.license.plugin.core.LicensesService.DeleteLicenseRequestHolder; import static org.elasticsearch.license.plugin.core.LicensesService.DeleteLicenseRequestHolder;
import static org.elasticsearch.license.plugin.core.LicensesService.PutLicenseRequestHolder; import static org.elasticsearch.license.plugin.core.LicensesService.PutLicenseRequestHolder;
@ -22,4 +24,6 @@ public interface LicensesManagerService {
public void unregisterLicenses(final DeleteLicenseRequestHolder requestHolder, final ActionListener<ClusterStateUpdateResponse> listener); public void unregisterLicenses(final DeleteLicenseRequestHolder requestHolder, final ActionListener<ClusterStateUpdateResponse> listener);
public LicensesStatus checkLicenses(ESLicenses licenses); public LicensesStatus checkLicenses(ESLicenses licenses);
public Set<String> enabledFeatures();
} }

126
src/main/java/org/elasticsearch/license/plugin/core/LicensesService.java
View File

@ -36,16 +36,13 @@ import org.elasticsearch.license.plugin.core.trial.TrialLicensesBuilder;
import org.elasticsearch.threadpool.ThreadPool; import org.elasticsearch.threadpool.ThreadPool;
import java.util.Collections; import java.util.Collections;
import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ScheduledFuture; import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicBoolean;
import static org.elasticsearch.license.core.ESLicenses.FeatureType;
import static org.elasticsearch.license.plugin.core.trial.TrialLicenses.TrialLicense; import static org.elasticsearch.license.plugin.core.trial.TrialLicenses.TrialLicense;
import static org.elasticsearch.license.plugin.core.trial.TrialLicensesBuilder.trialLicensesBuilder;
/** /**
* Service responsible for managing {@link org.elasticsearch.license.plugin.core.LicensesMetaData} * Service responsible for managing {@link org.elasticsearch.license.plugin.core.LicensesMetaData}
@ -110,20 +107,6 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
return ClusterState.builder(currentState).metaData(mdBuilder).build(); return ClusterState.builder(currentState).metaData(mdBuilder).build();
} }
/**
* If signed license is found for any feature, remove the trial license for it
* NOTE: not used
* TODO: figure out desired behaviour for deleting trial licenses
*/
private TrialLicenses reduceTrialLicenses(ESLicenses currentLicenses, TrialLicenses currentTrialLicenses) {
TrialLicensesBuilder builder = trialLicensesBuilder();
for (TrialLicense currentTrialLicense : currentTrialLicenses) {
if (currentLicenses.get(currentTrialLicense.feature()) == null) {
builder.license(currentTrialLicense);
}
}
return builder.build();
}
}); });
return LicensesStatus.VALID; return LicensesStatus.VALID;
} }
@ -131,7 +114,6 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
@Override @Override
public void unregisterLicenses(final DeleteLicenseRequestHolder requestHolder, final ActionListener<ClusterStateUpdateResponse> listener) { public void unregisterLicenses(final DeleteLicenseRequestHolder requestHolder, final ActionListener<ClusterStateUpdateResponse> listener) {
final DeleteLicenseRequest request = requestHolder.request; final DeleteLicenseRequest request = requestHolder.request;
final Set<FeatureType> featuresToDelete = asFeatureTypes(request.features());
clusterService.submitStateUpdateTask(requestHolder.source, new AckedClusterStateUpdateTask<ClusterStateUpdateResponse>(request, listener) { clusterService.submitStateUpdateTask(requestHolder.source, new AckedClusterStateUpdateTask<ClusterStateUpdateResponse>(request, listener) {
@Override @Override
protected ClusterStateUpdateResponse newResponse(boolean acknowledged) { protected ClusterStateUpdateResponse newResponse(boolean acknowledged) {
@ -144,7 +126,7 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
MetaData.Builder mdBuilder = MetaData.builder(currentState.metaData()); MetaData.Builder mdBuilder = MetaData.builder(currentState.metaData());
LicensesMetaData currentLicenses = metaData.custom(LicensesMetaData.TYPE); LicensesMetaData currentLicenses = metaData.custom(LicensesMetaData.TYPE);
final LicensesWrapper licensesWrapper = LicensesWrapper.wrap(currentLicenses); final LicensesWrapper licensesWrapper = LicensesWrapper.wrap(currentLicenses);
licensesWrapper.removeFeatures(esLicenseManager, featuresToDelete); licensesWrapper.removeFeatures(esLicenseManager, request.features());
mdBuilder.putCustom(LicensesMetaData.TYPE, licensesWrapper.createLicensesMetaData()); mdBuilder.putCustom(LicensesMetaData.TYPE, licensesWrapper.createLicensesMetaData());
return ClusterState.builder(currentState).metaData(mdBuilder).build(); return ClusterState.builder(currentState).metaData(mdBuilder).build();
} }
@ -164,12 +146,24 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
return status; return status;
} }
@Override
public Set<String> enabledFeatures() {
Set<String> enabledFeatures = Sets.newHashSet();
if (registeredListeners != null) {
for (ListenerHolder holder : registeredListeners) {
if (holder.enabled.get()) {
enabledFeatures.add(holder.feature);
}
}
}
return enabledFeatures;
}
private void registerTrialLicense(final TrialLicense trialLicense) { private void registerTrialLicense(final TrialLicense trialLicense) {
clusterService.submitStateUpdateTask("register trial license []", new ProcessedClusterStateUpdateTask() { clusterService.submitStateUpdateTask("register trial license []", new ProcessedClusterStateUpdateTask() {
@Override @Override
public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) { public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {
} }
@Override @Override
@ -178,7 +172,8 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
MetaData.Builder mdBuilder = MetaData.builder(currentState.metaData()); MetaData.Builder mdBuilder = MetaData.builder(currentState.metaData());
LicensesMetaData currentLicenses = metaData.custom(LicensesMetaData.TYPE); LicensesMetaData currentLicenses = metaData.custom(LicensesMetaData.TYPE);
final LicensesWrapper licensesWrapper = LicensesWrapper.wrap(currentLicenses); final LicensesWrapper licensesWrapper = LicensesWrapper.wrap(currentLicenses);
if (trialLicenseCheck(trialLicense.feature().string())) { // do not generate a trial license for a feature that already has a signed license
if (!esLicenseManager.hasLicenseForFeature(trialLicense.feature())) {
licensesWrapper.addTrialLicense(trialLicense); licensesWrapper.addTrialLicense(trialLicense);
} }
mdBuilder.putCustom(LicensesMetaData.TYPE, licensesWrapper.createLicensesMetaData()); mdBuilder.putCustom(LicensesMetaData.TYPE, licensesWrapper.createLicensesMetaData());
@ -187,24 +182,7 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
@Override @Override
public void onFailure(String source, @Nullable Throwable t) { public void onFailure(String source, @Nullable Throwable t) {
//TODO logger.info("LicensesService: " + source, t);
logger.info("LICENSING" + source, t);
}
private boolean trialLicenseCheck(String feature) {
// check if actual license exists
if (esLicenseManager.hasLicenseForFeature(FeatureType.fromString(feature))) {
return false;
}
// check if trial license for feature exists
for (ListenerHolder holder : registeredListeners) {
if (holder.feature.equals(feature) && holder.registered.get()) {
if (holder.trialLicenseGenerated.compareAndSet(false, true)) {
return true;
}
}
}
return false;
} }
}); });
} }
@ -228,7 +206,15 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
notificationScheduler = null; notificationScheduler = null;
} }
clusterService.remove(this); clusterService.remove(this);
registeredListeners.clear();
if (registeredListeners != null) {
// notify features to be disabled
for (ListenerHolder holder : registeredListeners) {
holder.disableFeatureIfNeeded();
}
// clear all handlers
registeredListeners.clear();
}
} }
@Override @Override
@ -259,7 +245,7 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
private void registerListeners(LicensesMetaData currentMetaData) { private void registerListeners(LicensesMetaData currentMetaData) {
for (ListenerHolder listenerHolder : registeredListeners) { for (ListenerHolder listenerHolder : registeredListeners) {
if (listenerHolder.registered.compareAndSet(false, true)) { if (listenerHolder.registered.compareAndSet(false, true)) {
if (!esLicenseManager.hasLicenseForFeature(FeatureType.fromString(listenerHolder.feature))) { if (!esLicenseManager.hasLicenseForFeature(listenerHolder.feature)) {
// does not have actual license so generate a trial license // does not have actual license so generate a trial license
TrialLicenseOptions options = listenerHolder.trialLicenseOptions; TrialLicenseOptions options = listenerHolder.trialLicenseOptions;
if (options != null) { if (options != null) {
@ -298,8 +284,8 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
} }
@Override @Override
public ESLicenses.ESLicense getESLicense(FeatureType featureType) { public ESLicenses.ESLicense getESLicense(String feature) {
return getEffectiveLicenses().get(featureType); return getEffectiveLicenses().get(feature);
} }
@Override @Override
@ -378,10 +364,10 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
long offset = TimeValue.timeValueMinutes(1).getMillis(); long offset = TimeValue.timeValueMinutes(1).getMillis();
for (ListenerHolder listenerHolder : registeredListeners) { for (ListenerHolder listenerHolder : registeredListeners) {
long expiryDate = -1l; long expiryDate = -1l;
if (esLicenseManager.hasLicenseForFeature(FeatureType.fromString(listenerHolder.feature))) { if (esLicenseManager.hasLicenseForFeature(listenerHolder.feature)) {
expiryDate = esLicenseManager.getExpiryDateForLicense(FeatureType.fromString(listenerHolder.feature)); expiryDate = esLicenseManager.getExpiryDateForLicense(listenerHolder.feature);
} else { } else {
final TrialLicense trialLicense = licensesWrapper.trialLicenses().getTrialLicense(FeatureType.fromString(listenerHolder.feature)); final TrialLicense trialLicense = licensesWrapper.trialLicenses().getTrialLicense(listenerHolder.feature);
if (trialLicense != null) { if (trialLicense != null) {
expiryDate = trialLicense.expiryDate(); expiryDate = trialLicense.expiryDate();
} }
@ -406,14 +392,6 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
return nextScheduleFrequency; return nextScheduleFrequency;
} }
private static Set<FeatureType> asFeatureTypes(Set<String> featureTypeStrings) {
Set<FeatureType> featureTypes = new HashSet<>(featureTypeStrings.size());
for (String featureString : featureTypeStrings) {
featureTypes.add(FeatureType.fromString(featureString));
}
return featureTypes;
}
public static class PutLicenseRequestHolder { public static class PutLicenseRequestHolder {
private final PutLicenseRequest request; private final PutLicenseRequest request;
private final String source; private final String source;
@ -439,7 +417,7 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
.issuedTo(clusterService.state().getClusterName().value()) .issuedTo(clusterService.state().getClusterName().value())
.issueDate(System.currentTimeMillis()) .issueDate(System.currentTimeMillis())
.durationInDays(durationInDays) .durationInDays(durationInDays)
.feature(FeatureType.fromString(feature)) .feature(feature)
.maxNodes(maxNodes) .maxNodes(maxNodes)
.build(); .build();
} }
@ -460,10 +438,8 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
final TrialLicenseOptions trialLicenseOptions; final TrialLicenseOptions trialLicenseOptions;
final Listener listener; final Listener listener;
final AtomicBoolean registered = new AtomicBoolean(false); final AtomicBoolean registered = new AtomicBoolean(false);
final AtomicBoolean trialLicenseGenerated = new AtomicBoolean(false);
final AtomicBoolean toggle = new AtomicBoolean(false); final AtomicBoolean enabled = new AtomicBoolean(false); // by default, a consumer plugin should be disabled
final AtomicBoolean initialState = new AtomicBoolean(true);
private ListenerHolder(String feature, TrialLicenseOptions trialLicenseOptions, Listener listener) { private ListenerHolder(String feature, TrialLicenseOptions trialLicenseOptions, Listener listener) {
this.feature = feature; this.feature = feature;
@ -472,18 +448,14 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
} }
private void enableFeatureIfNeeded() { private void enableFeatureIfNeeded() {
if (toggle.compareAndSet(false, true) || initialState.compareAndSet(true, false)) { if (enabled.compareAndSet(false, true)) {
listener.onEnabled(); listener.onEnabled();
// needed as toggle may not be set
toggle.set(true);
} }
} }
private void disableFeatureIfNeeded() { private void disableFeatureIfNeeded() {
if (toggle.compareAndSet(true, false) || initialState.compareAndSet(true, false)) { if (enabled.compareAndSet(true, false)) {
listener.onDisabled(); listener.onDisabled();
// needed as toggle may not be set
toggle.set(false);
} }
} }
} }
@ -512,19 +484,34 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
return TrialLicenseUtils.fromEncodedTrialLicenses(encodedTrialLicenses); return TrialLicenseUtils.fromEncodedTrialLicenses(encodedTrialLicenses);
} }
/**
* Check if any trial license for the feature exists,
* if no trial license for feature exists, add new
* trial license for feature
* @param trialLicense to add
*/
public void addTrialLicense(TrialLicense trialLicense) { public void addTrialLicense(TrialLicense trialLicense) {
this.encodedTrialLicenses = ImmutableSet.copyOf(Sets.union(encodedTrialLicenses, boolean featureTrialLicenseExists = false;
Collections.singleton(TrialLicenseUtils.toEncodedTrialLicense(trialLicense)))); for (TrialLicense currentTrialLicense : trialLicenses()) {
if (currentTrialLicense.feature().equals(trialLicense.feature())) {
featureTrialLicenseExists = true;
break;
}
}
if (!featureTrialLicenseExists) {
this.encodedTrialLicenses = ImmutableSet.copyOf(Sets.union(encodedTrialLicenses,
Collections.singleton(TrialLicenseUtils.toEncodedTrialLicense(trialLicense))));
}
} }
public void addSignedLicenses(ESLicenseManager licenseManage, ESLicenses licenses) { public void addSignedLicenses(ESLicenseManager licenseManager, ESLicenses licenses) {
ESLicenses currentSignedLicenses = signedLicenses(licenseManage); ESLicenses currentSignedLicenses = signedLicenses(licenseManager);
final ESLicenses mergedLicenses = LicenseBuilders.merge(currentSignedLicenses, licenses); final ESLicenses mergedLicenses = LicenseBuilders.merge(currentSignedLicenses, licenses);
Set<String> newSignatures = Sets.newHashSet(Utils.toSignatures(mergedLicenses)); Set<String> newSignatures = Sets.newHashSet(Utils.toSignatures(mergedLicenses));
this.signatures = ImmutableSet.copyOf(Sets.union(signatures, newSignatures)); this.signatures = ImmutableSet.copyOf(Sets.union(signatures, newSignatures));
} }
public void removeFeatures(ESLicenseManager licenseManage, Set<FeatureType> featuresToDelete) { public void removeFeatures(ESLicenseManager licenseManage, Set<String> featuresToDelete) {
ESLicenses currentSignedLicenses = signedLicenses(licenseManage); ESLicenses currentSignedLicenses = signedLicenses(licenseManage);
final ESLicenses reducedLicenses = LicenseBuilders.removeFeatures(currentSignedLicenses, featuresToDelete); final ESLicenses reducedLicenses = LicenseBuilders.removeFeatures(currentSignedLicenses, featuresToDelete);
Set<String> reducedSignatures = Sets.newHashSet(Utils.toSignatures(reducedLicenses)); Set<String> reducedSignatures = Sets.newHashSet(Utils.toSignatures(reducedLicenses));
@ -536,6 +523,7 @@ public class LicensesService extends AbstractLifecycleComponent<LicensesService>
} }
} }
//Should not be exposed; used by testing only
public void clear() { public void clear() {
if (notificationScheduler != null) { if (notificationScheduler != null) {
notificationScheduler.cancel(true); notificationScheduler.cancel(true);

9
src/main/java/org/elasticsearch/license/plugin/core/trial/TrialLicenseUtils.java
View File

@ -48,7 +48,7 @@ public class TrialLicenseUtils {
return TrialLicensesBuilder.trialLicenseBuilder() return TrialLicensesBuilder.trialLicenseBuilder()
.uid(uid) .uid(uid)
.issuedTo(issuedTo) .issuedTo(issuedTo)
.feature(ESLicenses.FeatureType.fromString(feature)) .feature(feature)
.maxNodes(maxNodes) .maxNodes(maxNodes)
.issueDate(issueDate) .issueDate(issueDate)
.expiryDate(expiryDate) .expiryDate(expiryDate)
@ -57,8 +57,7 @@ public class TrialLicenseUtils {
public static String toEncodedTrialLicense(TrialLicenses.TrialLicense trialLicense) { public static String toEncodedTrialLicense(TrialLicenses.TrialLicense trialLicense) {
byte[] uidBytes = trialLicense.uid().getBytes(Charset.forName("UTF-8")); byte[] uidBytes = trialLicense.uid().getBytes(Charset.forName("UTF-8"));
String feature = trialLicense.feature().string(); byte[] featureBytes = trialLicense.feature().getBytes(Charset.forName("UTF-8"));
byte[] featureBytes = feature.getBytes(Charset.forName("UTF-8"));
byte[] issuedToBytes = trialLicense.issuedTo().getBytes(Charset.forName("UTF-8")); byte[] issuedToBytes = trialLicense.issuedTo().getBytes(Charset.forName("UTF-8"));
// uid len + uid bytes + issuedTo len + issuedTo bytes + feature bytes length + feature bytes + maxNodes + issueDate + expiryDate // uid len + uid bytes + issuedTo len + issuedTo bytes + feature bytes length + feature bytes + maxNodes + issueDate + expiryDate
@ -134,7 +133,7 @@ public class TrialLicenseUtils {
builder.put(TrialLicenseFields.TYPE, ESLicenses.Type.TRIAL.string()); builder.put(TrialLicenseFields.TYPE, ESLicenses.Type.TRIAL.string());
builder.put(TrialLicenseFields.SUBSCRIPTION_TYPE, ESLicenses.SubscriptionType.NONE.string()); builder.put(TrialLicenseFields.SUBSCRIPTION_TYPE, ESLicenses.SubscriptionType.NONE.string());
builder.put(TrialLicenseFields.ISSUE_DATE, trialLicense.issueDate()); builder.put(TrialLicenseFields.ISSUE_DATE, trialLicense.issueDate());
builder.put(TrialLicenseFields.FEATURE, trialLicense.feature().string()); builder.put(TrialLicenseFields.FEATURE, trialLicense.feature());
builder.put(TrialLicenseFields.EXPIRY_DATE, trialLicense.expiryDate()); builder.put(TrialLicenseFields.EXPIRY_DATE, trialLicense.expiryDate());
builder.put(TrialLicenseFields.MAX_NODES, trialLicense.maxNodes()); builder.put(TrialLicenseFields.MAX_NODES, trialLicense.maxNodes());
builder.put(TrialLicenseFields.ISSUED_TO, trialLicense.issuedTo()); builder.put(TrialLicenseFields.ISSUED_TO, trialLicense.issuedTo());
@ -146,7 +145,7 @@ public class TrialLicenseUtils {
.uid((String) map.get(TrialLicenseFields.UID)) .uid((String) map.get(TrialLicenseFields.UID))
.issuedTo((String) map.get(TrialLicenseFields.ISSUED_TO)) .issuedTo((String) map.get(TrialLicenseFields.ISSUED_TO))
.maxNodes((int) map.get(TrialLicenseFields.MAX_NODES)) .maxNodes((int) map.get(TrialLicenseFields.MAX_NODES))
.feature(ESLicenses.FeatureType.fromString((String) map.get(TrialLicenseFields.FEATURE))) .feature((String) map.get(TrialLicenseFields.FEATURE))
.issueDate((long) map.get(TrialLicenseFields.ISSUE_DATE)) .issueDate((long) map.get(TrialLicenseFields.ISSUE_DATE))
.expiryDate((long) map.get(TrialLicenseFields.EXPIRY_DATE)) .expiryDate((long) map.get(TrialLicenseFields.EXPIRY_DATE))
.build(); .build();

6
src/main/java/org/elasticsearch/license/plugin/core/trial/TrialLicenses.java
View File

@ -7,19 +7,17 @@ package org.elasticsearch.license.plugin.core.trial;
import java.util.Collection; import java.util.Collection;
import static org.elasticsearch.license.core.ESLicenses.FeatureType;
public interface TrialLicenses extends Iterable<TrialLicenses.TrialLicense> { public interface TrialLicenses extends Iterable<TrialLicenses.TrialLicense> {
public Collection<TrialLicense> trialLicenses(); public Collection<TrialLicense> trialLicenses();
public TrialLicense getTrialLicense(FeatureType featureType); public TrialLicense getTrialLicense(String feature);
public interface TrialLicense { public interface TrialLicense {
public String issuedTo(); public String issuedTo();
public FeatureType feature(); public String feature();
public long issueDate(); public long issueDate();

15
src/main/java/org/elasticsearch/license/plugin/core/trial/TrialLicensesBuilder.java
View File

@ -7,7 +7,6 @@ package org.elasticsearch.license.plugin.core.trial;
import org.elasticsearch.common.collect.ImmutableMap; import org.elasticsearch.common.collect.ImmutableMap;
import org.elasticsearch.license.core.DateUtils; import org.elasticsearch.license.core.DateUtils;
import org.elasticsearch.license.core.ESLicenses;
import java.util.*; import java.util.*;
@ -41,7 +40,7 @@ public class TrialLicensesBuilder {
} }
} }
private final ImmutableMap.Builder<ESLicenses.FeatureType, TrialLicense> licenseBuilder; private final ImmutableMap.Builder<String, TrialLicense> licenseBuilder;
public TrialLicensesBuilder() { public TrialLicensesBuilder() {
licenseBuilder = ImmutableMap.builder(); licenseBuilder = ImmutableMap.builder();
@ -64,7 +63,7 @@ public class TrialLicensesBuilder {
} }
public TrialLicenses build() { public TrialLicenses build() {
final ImmutableMap<ESLicenses.FeatureType, TrialLicense> licenseMap = licenseBuilder.build(); final ImmutableMap<String, TrialLicense> licenseMap = licenseBuilder.build();
return new TrialLicenses() { return new TrialLicenses() {
@Override @Override
@ -73,8 +72,8 @@ public class TrialLicensesBuilder {
} }
@Override @Override
public TrialLicense getTrialLicense(ESLicenses.FeatureType featureType) { public TrialLicense getTrialLicense(String feature) {
return licenseMap.get(featureType); return licenseMap.get(feature);
} }
@Override @Override
@ -85,7 +84,7 @@ public class TrialLicensesBuilder {
} }
public static class TrialLicenseBuilder { public static class TrialLicenseBuilder {
private ESLicenses.FeatureType featureType; private String featureType;
private long expiryDate = -1; private long expiryDate = -1;
private long issueDate = -1; private long issueDate = -1;
private int durationInDays = -1; private int durationInDays = -1;
@ -111,7 +110,7 @@ public class TrialLicensesBuilder {
return this; return this;
} }
public TrialLicenseBuilder feature(ESLicenses.FeatureType featureType) { public TrialLicenseBuilder feature(String featureType) {
this.featureType = featureType; this.featureType = featureType;
return this; return this;
} }
@ -148,7 +147,7 @@ public class TrialLicensesBuilder {
} }
@Override @Override
public ESLicenses.FeatureType feature() { public String feature() {
return featureType; return featureType;
} }

23
src/main/java/org/elasticsearch/license/plugin/rest/RestDeleteLicenseAction.java
View File

@ -19,10 +19,6 @@ import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest; import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.support.AcknowledgedRestListener; import org.elasticsearch.rest.action.support.AcknowledgedRestListener;
import java.util.HashSet;
import java.util.Set;
import static org.elasticsearch.license.core.ESLicenses.FeatureType;
import static org.elasticsearch.rest.RestRequest.Method.DELETE; import static org.elasticsearch.rest.RestRequest.Method.DELETE;
public class RestDeleteLicenseAction extends BaseRestHandler { public class RestDeleteLicenseAction extends BaseRestHandler {
@ -38,25 +34,10 @@ public class RestDeleteLicenseAction extends BaseRestHandler {
public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) { public void handleRequest(final RestRequest request, final RestChannel channel, final Client client) {
final String[] features = Strings.splitStringByCommaToArray(request.param("features")); final String[] features = Strings.splitStringByCommaToArray(request.param("features"));
if (features.length == 0) { if (features.length == 0) {
throw new ElasticsearchIllegalArgumentException("no features specified for license deletion"); throw new ElasticsearchIllegalArgumentException("no feature specified for license deletion");
} }
DeleteLicenseRequest deleteLicenseRequest = new DeleteLicenseRequest(getFeaturesToDelete(features)); DeleteLicenseRequest deleteLicenseRequest = new DeleteLicenseRequest(features);
deleteLicenseRequest.listenerThreaded(false); deleteLicenseRequest.listenerThreaded(false);
client.admin().cluster().execute(DeleteLicenseAction.INSTANCE, deleteLicenseRequest, new AcknowledgedRestListener<DeleteLicenseResponse>(channel)); client.admin().cluster().execute(DeleteLicenseAction.INSTANCE, deleteLicenseRequest, new AcknowledgedRestListener<DeleteLicenseResponse>(channel));
} }
private static String[] getFeaturesToDelete(String[] features) {
Set<String> result = new HashSet<>();
for (String feature : features) {
if (feature.equalsIgnoreCase("_all")) {
for (FeatureType featureType : FeatureType.values()) {
result.add(featureType.string());
}
break;
} else {
result.add(FeatureType.fromString(feature).string());
}
}
return result.toArray(new String[result.size()]);
}
} }

2
src/test/java/org/elasticsearch/license/AbstractLicensingTestBase.java
View File

@ -31,7 +31,7 @@ public class AbstractLicensingTestBase {
return url.toURI().getPath(); return url.toURI().getPath();
} }
public String generateSignedLicenses(Map<ESLicenses.FeatureType, TestUtils.FeatureAttributes> map) throws IOException { public String generateSignedLicenses(Map<String, TestUtils.FeatureAttributes> map) throws IOException {
String licenseString = TestUtils.generateESLicenses(map); String licenseString = TestUtils.generateESLicenses(map);
return TestUtils.runLicenseGenerationTool(licenseString, pubKeyPath, priKeyPath); return TestUtils.runLicenseGenerationTool(licenseString, pubKeyPath, priKeyPath);
} }

18
src/test/java/org/elasticsearch/license/TestUtils.java
View File

@ -21,8 +21,10 @@ import static org.junit.Assert.assertTrue;
public class TestUtils { public class TestUtils {
public final static String SHIELD = "shield";
public final static String MARVEL = "marvel";
public static String generateESLicenses(Map<ESLicenses.FeatureType, FeatureAttributes> featureAttributes) { public static String generateESLicenses(Map<String, FeatureAttributes> featureAttributes) {
StringBuilder licenseBuilder = new StringBuilder(); StringBuilder licenseBuilder = new StringBuilder();
int size = featureAttributes.values().size(); int size = featureAttributes.values().size();
int i = 0; int i = 0;
@ -70,17 +72,17 @@ public class TestUtils {
return FileUtils.readFileToString(temp); return FileUtils.readFileToString(temp);
} }
public static void verifyESLicenses(ESLicenses esLicenses, Map<ESLicenses.FeatureType, FeatureAttributes> featureAttributes) throws ParseException { public static void verifyESLicenses(ESLicenses esLicenses, Map<String, FeatureAttributes> featureAttributes) throws ParseException {
assertTrue("Number of feature licenses should be " + featureAttributes.size(), esLicenses.features().size() == featureAttributes.size()); assertTrue("Number of feature licenses should be " + featureAttributes.size(), esLicenses.features().size() == featureAttributes.size());
for (Map.Entry<ESLicenses.FeatureType, FeatureAttributes> featureAttrTuple : featureAttributes.entrySet()) { for (Map.Entry<String, FeatureAttributes> featureAttrTuple : featureAttributes.entrySet()) {
ESLicenses.FeatureType featureType = featureAttrTuple.getKey(); String featureType = featureAttrTuple.getKey();
FeatureAttributes attributes = featureAttrTuple.getValue(); FeatureAttributes attributes = featureAttrTuple.getValue();
final ESLicenses.ESLicense esLicense = esLicenses.get(featureType); final ESLicenses.ESLicense esLicense = esLicenses.get(featureType);
assertTrue("license for " + featureType.string() + " should be present", esLicense != null); assertTrue("license for " + featureType + " should be present", esLicense != null);
assertTrue("expected value for issuedTo was: " + attributes.issuedTo + " but got: " + esLicense.issuedTo(), esLicense.issuedTo().equals(attributes.issuedTo)); assertTrue("expected value for issuedTo was: " + attributes.issuedTo + " but got: " + esLicense.issuedTo(), esLicense.issuedTo().equals(attributes.issuedTo));
assertTrue("expected value for type was: " + attributes.type + " but got: " + esLicense.type().string(), esLicense.type().string().equals(attributes.type)); assertTrue("expected value for type was: " + attributes.type + " but got: " + esLicense.type().string(), esLicense.type().string().equals(attributes.type));
assertTrue("expected value for subscriptionType was: " + attributes.subscriptionType + " but got: " + esLicense.subscriptionType().string(), esLicense.subscriptionType().string().equals(attributes.subscriptionType)); assertTrue("expected value for subscriptionType was: " + attributes.subscriptionType + " but got: " + esLicense.subscriptionType().string(), esLicense.subscriptionType().string().equals(attributes.subscriptionType));
assertTrue("expected value for feature was: " + attributes.featureType + " but got: " + esLicense.feature().string(), esLicense.feature().string().equals(attributes.featureType)); assertTrue("expected value for feature was: " + attributes.featureType + " but got: " + esLicense.feature(), esLicense.feature().equals(attributes.featureType));
assertTrue("expected value for issueDate was: " + DateUtils.longFromDateString(attributes.issueDate) + " but got: " + esLicense.issueDate(), esLicense.issueDate() == DateUtils.longFromDateString(attributes.issueDate)); assertTrue("expected value for issueDate was: " + DateUtils.longFromDateString(attributes.issueDate) + " but got: " + esLicense.issueDate(), esLicense.issueDate() == DateUtils.longFromDateString(attributes.issueDate));
assertTrue("expected value for expiryDate: " + DateUtils.longExpiryDateFromString(attributes.expiryDate) + " but got: " + esLicense.expiryDate(), esLicense.expiryDate() == DateUtils.longExpiryDateFromString(attributes.expiryDate)); assertTrue("expected value for expiryDate: " + DateUtils.longExpiryDateFromString(attributes.expiryDate) + " but got: " + esLicense.expiryDate(), esLicense.expiryDate() == DateUtils.longExpiryDateFromString(attributes.expiryDate));
assertTrue("expected value for maxNodes: " + attributes.maxNodes + " but got: " + esLicense.maxNodes(), esLicense.maxNodes() == attributes.maxNodes); assertTrue("expected value for maxNodes: " + attributes.maxNodes + " but got: " + esLicense.maxNodes(), esLicense.maxNodes() == attributes.maxNodes);
@ -102,7 +104,7 @@ public class TestUtils {
// for every feature license, check if all the attributes are the same // for every feature license, check if all the attributes are the same
for (ESLicenses.FeatureType featureType : licenses1.features()) { for (String featureType : licenses1.features()) {
ESLicenses.ESLicense license1 = licenses1.get(featureType); ESLicenses.ESLicense license1 = licenses1.get(featureType);
ESLicenses.ESLicense license2 = licenses2.get(featureType); ESLicenses.ESLicense license2 = licenses2.get(featureType);
@ -114,7 +116,7 @@ public class TestUtils {
public static void isSame(ESLicenses.ESLicense license1, ESLicenses.ESLicense license2) { public static void isSame(ESLicenses.ESLicense license1, ESLicenses.ESLicense license2) {
assertTrue("Should have same uid; got: " + license1.uid() + " and " + license2.uid(), license1.uid().equals(license2.uid())); assertTrue("Should have same uid; got: " + license1.uid() + " and " + license2.uid(), license1.uid().equals(license2.uid()));
assertTrue("Should have same feature; got: " + license1.feature().string() + " and " + license2.feature().string(), license1.feature().string().equals(license2.feature().string())); assertTrue("Should have same feature; got: " + license1.feature() + " and " + license2.feature(), license1.feature().equals(license2.feature()));
assertTrue("Should have same subscriptType; got: " + license1.subscriptionType().string() + " and " + license2.subscriptionType().string(), license1.subscriptionType().string().equals(license2.subscriptionType().string())); assertTrue("Should have same subscriptType; got: " + license1.subscriptionType().string() + " and " + license2.subscriptionType().string(), license1.subscriptionType().string().equals(license2.subscriptionType().string()));
assertTrue("Should have same type; got: " + license1.type().string() + " and " + license2.type().string(), license1.type().string().equals(license2.type().string())); assertTrue("Should have same type; got: " + license1.type().string() + " and " + license2.type().string(), license1.type().string().equals(license2.type().string()));
assertTrue("Should have same issuedTo; got: " + license1.issuedTo() + " and " + license2.issuedTo(), license1.issuedTo().equals(license2.issuedTo())); assertTrue("Should have same issuedTo; got: " + license1.issuedTo() + " and " + license2.issuedTo(), license1.issuedTo().equals(license2.issuedTo()));

51
src/test/java/org/elasticsearch/license/licensor/LicenseGenerationTests.java
View File

@ -16,7 +16,6 @@ import java.text.ParseException;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import static org.elasticsearch.license.core.ESLicenses.FeatureType;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail; import static org.junit.Assert.fail;
@ -24,10 +23,10 @@ public class LicenseGenerationTests extends AbstractLicensingTestBase {
@Test @Test
public void testSimpleLicenseGeneration() throws ParseException, IOException { public void testSimpleLicenseGeneration() throws ParseException, IOException {
Map<FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes featureAttributes = TestUtils.FeatureAttributes featureAttributes =
new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-12-13"); new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-12-13");
map.put(FeatureType.SHIELD, featureAttributes); map.put(TestUtils.SHIELD, featureAttributes);
String licenseOutput = generateSignedLicenses(map); String licenseOutput = generateSignedLicenses(map);
@ -37,15 +36,15 @@ public class LicenseGenerationTests extends AbstractLicensingTestBase {
} }
@Test @Test
public void testMultipleFeatureTypes() throws ParseException, IOException { public void testMultipleStrings() throws ParseException, IOException {
Map<FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes shildFeatureAttributes = TestUtils.FeatureAttributes shildFeatureAttributes =
new TestUtils.FeatureAttributes("shield", "trial", "none", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-12-13"); new TestUtils.FeatureAttributes("shield", "trial", "none", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-12-13");
TestUtils.FeatureAttributes marvelFeatureAttributes = TestUtils.FeatureAttributes marvelFeatureAttributes =
new TestUtils.FeatureAttributes("marvel", "subscription", "silver", "foo1 bar Inc.", "elasticsearc3h", 10, "2014-01-13", "2014-12-13"); new TestUtils.FeatureAttributes("marvel", "subscription", "silver", "foo1 bar Inc.", "elasticsearc3h", 10, "2014-01-13", "2014-12-13");
map.put(FeatureType.SHIELD, shildFeatureAttributes); map.put(TestUtils.SHIELD, shildFeatureAttributes);
map.put(FeatureType.MARVEL, marvelFeatureAttributes); map.put(TestUtils.MARVEL, marvelFeatureAttributes);
String licenseOutput = generateSignedLicenses(map); String licenseOutput = generateSignedLicenses(map);
@ -57,10 +56,10 @@ public class LicenseGenerationTests extends AbstractLicensingTestBase {
@Test @Test
public void testMissingCLTArgs() throws ParseException, IOException { public void testMissingCLTArgs() throws ParseException, IOException {
Map<FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes featureAttributes = TestUtils.FeatureAttributes featureAttributes =
new TestUtils.FeatureAttributes("shiedgdsld", "internal", "none", "foo bar Inc.", "elasticsearch", 23, "2014-12-13", "2015-12-13"); new TestUtils.FeatureAttributes("shiedgdsld", "internal", "none", "foo bar Inc.", "elasticsearch", 23, "2014-12-13", "2015-12-13");
map.put(FeatureType.SHIELD, featureAttributes); map.put(TestUtils.SHIELD, featureAttributes);
String licenseString = TestUtils.generateESLicenses(map); String licenseString = TestUtils.generateESLicenses(map);
@ -80,38 +79,12 @@ public class LicenseGenerationTests extends AbstractLicensingTestBase {
} }
} }
@Test
public void testInvalidFeatureType() throws ParseException, IOException {
Map<FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes featureAttributes =
new TestUtils.FeatureAttributes("shiedgdsld", "internal", "none", "foo bar Inc.", "elasticsearch", 23, "2014-12-13", "2015-12-13");
map.put(FeatureType.SHIELD, featureAttributes);
String licenseString = TestUtils.generateESLicenses(map);
String[] args = new String[6];
args[0] = "--license";
args[1] = licenseString;
args[2] = "--publicKeyPath";
args[3] = pubKeyPath;
args[4] = "--privateKeyPath";
args[5] = priKeyPath;
try {
String licenseOutput = TestUtils.runLicenseGenerationTool(args);
fail();
} catch (IllegalArgumentException e) {
assertTrue("Exception should indicate invalid FeatureType, got: " + e.getMessage(), e.getMessage().contains("Invalid FeatureType"));
}
}
@Test @Test
public void testInvalidSubscriptionType() throws ParseException, IOException { public void testInvalidSubscriptionType() throws ParseException, IOException {
Map<FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes featureAttributes = TestUtils.FeatureAttributes featureAttributes =
new TestUtils.FeatureAttributes("shield", "trial", "nodavne", "foo bar Inc.", "elasticsearch", 25, "2014-12-13", "2015-12-13"); new TestUtils.FeatureAttributes("shield", "trial", "nodavne", "foo bar Inc.", "elasticsearch", 25, "2014-12-13", "2015-12-13");
map.put(FeatureType.SHIELD, featureAttributes); map.put(TestUtils.SHIELD, featureAttributes);
String licenseString = TestUtils.generateESLicenses(map); String licenseString = TestUtils.generateESLicenses(map);
@ -134,10 +107,10 @@ public class LicenseGenerationTests extends AbstractLicensingTestBase {
@Test @Test
public void testInvalidType() throws ParseException, IOException { public void testInvalidType() throws ParseException, IOException {
Map<FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes featureAttributes = TestUtils.FeatureAttributes featureAttributes =
new TestUtils.FeatureAttributes("shield", "inininternal", "gold", "foo bar Inc.", "elasticsearch", 12, "2014-12-13", "2015-12-13"); new TestUtils.FeatureAttributes("shield", "inininternal", "gold", "foo bar Inc.", "elasticsearch", 12, "2014-12-13", "2015-12-13");
map.put(FeatureType.SHIELD, featureAttributes); map.put(TestUtils.SHIELD, featureAttributes);
String licenseString = TestUtils.generateESLicenses(map); String licenseString = TestUtils.generateESLicenses(map);

28
src/test/java/org/elasticsearch/license/licensor/LicenseVerificationToolTests.java
View File

@ -23,17 +23,17 @@ public class LicenseVerificationToolTests extends AbstractLicensingTestBase {
@Test @Test
public void testEffectiveLicenseGeneration() throws Exception { public void testEffectiveLicenseGeneration() throws Exception {
Map<ESLicenses.FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes featureWithLongerExpiryDate = TestUtils.FeatureAttributes featureWithLongerExpiryDate =
new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 10, "2014-12-13", "2015-12-13"); new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 10, "2014-12-13", "2015-12-13");
map.put(ESLicenses.FeatureType.SHIELD, featureWithLongerExpiryDate); map.put(TestUtils.SHIELD, featureWithLongerExpiryDate);
String signedLicense = runLicenseGenerationTool(TestUtils.generateESLicenses(map)); String signedLicense = runLicenseGenerationTool(TestUtils.generateESLicenses(map));
String firstLicenseFile = getAsFilePath(signedLicense); String firstLicenseFile = getAsFilePath(signedLicense);
TestUtils.FeatureAttributes featureWithShorterExpiryDate = TestUtils.FeatureAttributes featureWithShorterExpiryDate =
new TestUtils.FeatureAttributes("shield", "trial", "none", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-01-13"); new TestUtils.FeatureAttributes("shield", "trial", "none", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-01-13");
map.put(ESLicenses.FeatureType.SHIELD, featureWithShorterExpiryDate); map.put(TestUtils.SHIELD, featureWithShorterExpiryDate);
signedLicense = runLicenseGenerationTool(TestUtils.generateESLicenses(map)); signedLicense = runLicenseGenerationTool(TestUtils.generateESLicenses(map));
String secondLicenseFile = getAsFilePath(signedLicense); String secondLicenseFile = getAsFilePath(signedLicense);
@ -41,7 +41,7 @@ public class LicenseVerificationToolTests extends AbstractLicensingTestBase {
String effectiveLicenseStr = runLicenseVerificationTool(new String[]{firstLicenseFile, secondLicenseFile}); String effectiveLicenseStr = runLicenseVerificationTool(new String[]{firstLicenseFile, secondLicenseFile});
ESLicenses effectiveLicense = LicenseUtils.readLicensesFromString(effectiveLicenseStr); ESLicenses effectiveLicense = LicenseUtils.readLicensesFromString(effectiveLicenseStr);
map.put(ESLicenses.FeatureType.SHIELD, featureWithLongerExpiryDate); map.put(TestUtils.SHIELD, featureWithLongerExpiryDate);
// verify that the effective license strips out license for the same feature with earlier expiry dates // verify that the effective license strips out license for the same feature with earlier expiry dates
TestUtils.verifyESLicenses(effectiveLicense, map); TestUtils.verifyESLicenses(effectiveLicense, map);
@ -49,17 +49,17 @@ public class LicenseVerificationToolTests extends AbstractLicensingTestBase {
@Test @Test
public void testEffectiveLicenseForMultiFeatures() throws Exception { public void testEffectiveLicenseForMultiFeatures() throws Exception {
Map<ESLicenses.FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes shieldFeatureWithLongerExpiryDate = TestUtils.FeatureAttributes shieldFeatureWithLongerExpiryDate =
new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 10, "2014-12-13", "2015-12-13"); new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 10, "2014-12-13", "2015-12-13");
map.put(ESLicenses.FeatureType.SHIELD, shieldFeatureWithLongerExpiryDate); map.put(TestUtils.SHIELD, shieldFeatureWithLongerExpiryDate);
String signedLicense = runLicenseGenerationTool(TestUtils.generateESLicenses(map)); String signedLicense = runLicenseGenerationTool(TestUtils.generateESLicenses(map));
String firstLicenseFile = getAsFilePath(signedLicense); String firstLicenseFile = getAsFilePath(signedLicense);
TestUtils.FeatureAttributes marvelFeatureWithShorterExpiryDate = TestUtils.FeatureAttributes marvelFeatureWithShorterExpiryDate =
new TestUtils.FeatureAttributes("marvel", "trial", "none", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-01-13"); new TestUtils.FeatureAttributes("marvel", "trial", "none", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-01-13");
map.put(ESLicenses.FeatureType.MARVEL, marvelFeatureWithShorterExpiryDate); map.put(TestUtils.MARVEL, marvelFeatureWithShorterExpiryDate);
signedLicense = runLicenseGenerationTool(TestUtils.generateESLicenses(map)); signedLicense = runLicenseGenerationTool(TestUtils.generateESLicenses(map));
String secondLicenseFile = getAsFilePath(signedLicense); String secondLicenseFile = getAsFilePath(signedLicense);
@ -73,15 +73,15 @@ public class LicenseVerificationToolTests extends AbstractLicensingTestBase {
@Test @Test
public void testEffectiveLicenseForMultiFeatures2() throws Exception { public void testEffectiveLicenseForMultiFeatures2() throws Exception {
Map<ESLicenses.FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes shieldFeatureWithLongerExpiryDate = TestUtils.FeatureAttributes shieldFeatureWithLongerExpiryDate =
new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 10, "2014-12-13", "2015-12-13"); new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 10, "2014-12-13", "2015-12-13");
TestUtils.FeatureAttributes marvelFeatureWithShorterExpiryDate = TestUtils.FeatureAttributes marvelFeatureWithShorterExpiryDate =
new TestUtils.FeatureAttributes("marvel", "trial", "none", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-01-13"); new TestUtils.FeatureAttributes("marvel", "trial", "none", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-01-13");
map.put(ESLicenses.FeatureType.SHIELD, shieldFeatureWithLongerExpiryDate); map.put(TestUtils.SHIELD, shieldFeatureWithLongerExpiryDate);
map.put(ESLicenses.FeatureType.MARVEL, marvelFeatureWithShorterExpiryDate); map.put(TestUtils.MARVEL, marvelFeatureWithShorterExpiryDate);
String signedLicense = runLicenseGenerationTool(TestUtils.generateESLicenses(map)); String signedLicense = runLicenseGenerationTool(TestUtils.generateESLicenses(map));
String firstLicenseFile = getAsFilePath(signedLicense); String firstLicenseFile = getAsFilePath(signedLicense);
@ -91,8 +91,8 @@ public class LicenseVerificationToolTests extends AbstractLicensingTestBase {
TestUtils.FeatureAttributes marvelFeatureWithLongerExpiryDate = TestUtils.FeatureAttributes marvelFeatureWithLongerExpiryDate =
new TestUtils.FeatureAttributes("marvel", "trial", "none", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-11-13"); new TestUtils.FeatureAttributes("marvel", "trial", "none", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-11-13");
map.put(ESLicenses.FeatureType.SHIELD, shieldFeatureWithShorterExpiryDate); map.put(TestUtils.SHIELD, shieldFeatureWithShorterExpiryDate);
map.put(ESLicenses.FeatureType.MARVEL, marvelFeatureWithLongerExpiryDate); map.put(TestUtils.MARVEL, marvelFeatureWithLongerExpiryDate);
signedLicense = runLicenseGenerationTool(TestUtils.generateESLicenses(map)); signedLicense = runLicenseGenerationTool(TestUtils.generateESLicenses(map));
String secondLicenseFile = getAsFilePath(signedLicense); String secondLicenseFile = getAsFilePath(signedLicense);
@ -100,8 +100,8 @@ public class LicenseVerificationToolTests extends AbstractLicensingTestBase {
String effectiveLicenseStr = runLicenseVerificationTool(new String[]{firstLicenseFile, secondLicenseFile}); String effectiveLicenseStr = runLicenseVerificationTool(new String[]{firstLicenseFile, secondLicenseFile});
ESLicenses effectiveLicense = LicenseUtils.readLicensesFromString(effectiveLicenseStr); ESLicenses effectiveLicense = LicenseUtils.readLicensesFromString(effectiveLicenseStr);
map.put(ESLicenses.FeatureType.SHIELD, shieldFeatureWithLongerExpiryDate); map.put(TestUtils.SHIELD, shieldFeatureWithLongerExpiryDate);
map.put(ESLicenses.FeatureType.MARVEL, marvelFeatureWithLongerExpiryDate); map.put(TestUtils.MARVEL, marvelFeatureWithLongerExpiryDate);
// verify that the generated effective license is generated from choosing individual licences from multiple files // verify that the generated effective license is generated from choosing individual licences from multiple files
TestUtils.verifyESLicenses(effectiveLicense, map); TestUtils.verifyESLicenses(effectiveLicense, map);

40
src/test/java/org/elasticsearch/license/manager/LicenseVerificationTests.java
View File

@ -19,7 +19,6 @@ import org.junit.Test;
import java.text.ParseException; import java.text.ParseException;
import java.util.*; import java.util.*;
import static org.elasticsearch.license.core.ESLicenses.FeatureType;
import static org.elasticsearch.license.core.LicenseUtils.readLicensesFromString; import static org.elasticsearch.license.core.LicenseUtils.readLicensesFromString;
import static org.junit.Assert.*; import static org.junit.Assert.*;
@ -49,10 +48,10 @@ public class LicenseVerificationTests extends AbstractLicensingTestBase {
Date issueDate = new Date(); Date issueDate = new Date();
String issueDateStr = DateUtils.dateStringFromLongDate(issueDate.getTime()); String issueDateStr = DateUtils.dateStringFromLongDate(issueDate.getTime());
String expiryDateStr = DateUtils.dateStringFromLongDate(DateUtils.longExpiryDateFromDate(issueDate.getTime() + 24 * 60 * 60l)); String expiryDateStr = DateUtils.dateStringFromLongDate(DateUtils.longExpiryDateFromDate(issueDate.getTime() + 24 * 60 * 60l));
Map<FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes featureAttributes = TestUtils.FeatureAttributes featureAttributes =
new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, issueDateStr, expiryDateStr); new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, issueDateStr, expiryDateStr);
map.put(FeatureType.SHIELD, featureAttributes); map.put(TestUtils.SHIELD, featureAttributes);
ESLicenses esLicensesOutput = readLicensesFromString(generateSignedLicenses(map)); ESLicenses esLicensesOutput = readLicensesFromString(generateSignedLicenses(map));
@ -70,13 +69,13 @@ public class LicenseVerificationTests extends AbstractLicensingTestBase {
String issueDateStr = DateUtils.dateStringFromLongDate(issueDate.getTime()); String issueDateStr = DateUtils.dateStringFromLongDate(issueDate.getTime());
String expiryDateStr = DateUtils.dateStringFromLongDate(DateUtils.longExpiryDateFromDate(issueDate.getTime() + 24 * 60 * 60 * 1000l)); String expiryDateStr = DateUtils.dateStringFromLongDate(DateUtils.longExpiryDateFromDate(issueDate.getTime() + 24 * 60 * 60 * 1000l));
Map<FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes shildFeatureAttributes = TestUtils.FeatureAttributes shildFeatureAttributes =
new TestUtils.FeatureAttributes("shield", "trial", "none", "foo bar Inc.", "elasticsearch", 2, issueDateStr, expiryDateStr); new TestUtils.FeatureAttributes("shield", "trial", "none", "foo bar Inc.", "elasticsearch", 2, issueDateStr, expiryDateStr);
TestUtils.FeatureAttributes marvelFeatureAttributes = TestUtils.FeatureAttributes marvelFeatureAttributes =
new TestUtils.FeatureAttributes("marvel", "subscription", "silver", "foo1 bar Inc.", "elasticsearc3h", 10, issueDateStr, expiryDateStr); new TestUtils.FeatureAttributes("marvel", "subscription", "silver", "foo1 bar Inc.", "elasticsearc3h", 10, issueDateStr, expiryDateStr);
map.put(FeatureType.SHIELD, shildFeatureAttributes); map.put(TestUtils.SHIELD, shildFeatureAttributes);
map.put(FeatureType.MARVEL, marvelFeatureAttributes); map.put(TestUtils.MARVEL, marvelFeatureAttributes);
ESLicenses esLicensesOutput = readLicensesFromString(generateSignedLicenses(map)); ESLicenses esLicensesOutput = readLicensesFromString(generateSignedLicenses(map));
@ -127,22 +126,23 @@ public class LicenseVerificationTests extends AbstractLicensingTestBase {
assert longExpiryDateFromDate < System.currentTimeMillis(); assert longExpiryDateFromDate < System.currentTimeMillis();
String expiredExpiryDateStr = DateUtils.dateStringFromLongDate(longExpiryDateFromDate); String expiredExpiryDateStr = DateUtils.dateStringFromLongDate(longExpiryDateFromDate);
Map<FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes shildFeatureAttributes = TestUtils.FeatureAttributes shildFeatureAttributes =
new TestUtils.FeatureAttributes("shield", "trial", "none", "foo bar Inc.", "elasticsearch", 2, issueDateStr, expiryDateStr); new TestUtils.FeatureAttributes("shield", "trial", "none", "foo bar Inc.", "elasticsearch", 2, issueDateStr, expiryDateStr);
TestUtils.FeatureAttributes marvelFeatureAttributes = TestUtils.FeatureAttributes marvelFeatureAttributes =
new TestUtils.FeatureAttributes("marvel", "internal", "silver", "foo1 bar Inc.", "elasticsearc3h", 10, issueDateStr, expiredExpiryDateStr); new TestUtils.FeatureAttributes("marvel", "internal", "silver", "foo1 bar Inc.", "elasticsearc3h", 10, issueDateStr, expiredExpiryDateStr);
map.put(FeatureType.SHIELD, shildFeatureAttributes); map.put(TestUtils.SHIELD, shildFeatureAttributes);
map.put(FeatureType.MARVEL, marvelFeatureAttributes); map.put(TestUtils.MARVEL, marvelFeatureAttributes);
ESLicenses esLicensesOutput = readLicensesFromString(generateSignedLicenses(map)); ESLicenses esLicensesOutput = readLicensesFromString(generateSignedLicenses(map));
esLicenseProvider.setLicenses(esLicensesOutput); esLicenseProvider.setLicenses(esLicensesOutput);
// All validation for shield license should be normal as expected // All validation for shield license should be normal as expected
verifyLicenseManager(esLicenseManager, Collections.singletonMap(FeatureType.SHIELD, shildFeatureAttributes));
assertFalse("license for marvel should not be valid due to expired expiry date", esLicenseManager.hasLicenseForFeature(FeatureType.MARVEL)); verifyLicenseManager(esLicenseManager, Collections.singletonMap(TestUtils.SHIELD, shildFeatureAttributes));
assertFalse("license for marvel should not be valid due to expired expiry date", esLicenseManager.hasLicenseForFeature(TestUtils.MARVEL));
} }
@Test @Test
@ -151,20 +151,20 @@ public class LicenseVerificationTests extends AbstractLicensingTestBase {
Date issueDate = new Date(); Date issueDate = new Date();
String issueDateStr = DateUtils.dateStringFromLongDate(issueDate.getTime()); String issueDateStr = DateUtils.dateStringFromLongDate(issueDate.getTime());
String expiryDateStr = DateUtils.dateStringFromLongDate(DateUtils.longExpiryDateFromDate(issueDate.getTime() + 24 * 60 * 60l)); String expiryDateStr = DateUtils.dateStringFromLongDate(DateUtils.longExpiryDateFromDate(issueDate.getTime() + 24 * 60 * 60l));
Map<FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes featureAttributes = TestUtils.FeatureAttributes featureAttributes =
new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, issueDateStr, expiryDateStr); new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, issueDateStr, expiryDateStr);
map.put(FeatureType.SHIELD, featureAttributes); map.put(TestUtils.SHIELD, featureAttributes);
ESLicenses esLicensesOutput = readLicensesFromString(generateSignedLicenses(map)); ESLicenses esLicensesOutput = readLicensesFromString(generateSignedLicenses(map));
ESLicenses.ESLicense esLicense = esLicensesOutput.get(FeatureType.SHIELD); ESLicenses.ESLicense esLicense = esLicensesOutput.get(TestUtils.SHIELD);
long originalExpiryDate = esLicense.expiryDate(); long originalExpiryDate = esLicense.expiryDate();
final ESLicenses.ESLicense tamperedLicense = LicenseBuilders.licenseBuilder(true) final ESLicenses.ESLicense tamperedLicense = LicenseBuilders.licenseBuilder(true)
.fromLicense(esLicense) .fromLicense(esLicense)
.expiryDate(esLicense.expiryDate() + 10 * 24 * 60 * 60 * 1000l) .expiryDate(esLicense.expiryDate() + 10 * 24 * 60 * 60 * 1000l)
.feature(FeatureType.SHIELD) .feature(TestUtils.SHIELD)
.issuer("elasticsqearch") .issuer("elasticsqearch")
.build(); .build();
@ -172,7 +172,7 @@ public class LicenseVerificationTests extends AbstractLicensingTestBase {
try { try {
esLicenseProvider.setLicenses(tamperedLicenses); esLicenseProvider.setLicenses(tamperedLicenses);
assertTrue("License manager should always report the original (signed) expiry date of: " + originalExpiryDate + " but got: " + esLicenseManager.getExpiryDateForLicense(FeatureType.SHIELD), esLicenseManager.getExpiryDateForLicense(FeatureType.SHIELD) == originalExpiryDate); assertTrue("License manager should always report the original (signed) expiry date of: " + originalExpiryDate + " but got: " + esLicenseManager.getExpiryDateForLicense(TestUtils.SHIELD), esLicenseManager.getExpiryDateForLicense(TestUtils.SHIELD) == originalExpiryDate);
esLicenseManager.verifyLicenses(); esLicenseManager.verifyLicenses();
fail(); fail();
} catch (InvalidLicenseException e) { } catch (InvalidLicenseException e) {
@ -180,11 +180,11 @@ public class LicenseVerificationTests extends AbstractLicensingTestBase {
} }
} }
public static void verifyLicenseManager(ESLicenseManager esLicenseManager, Map<ESLicenses.FeatureType, TestUtils.FeatureAttributes> featureAttributeMap) throws ParseException { public static void verifyLicenseManager(ESLicenseManager esLicenseManager, Map<String, TestUtils.FeatureAttributes> featureAttributeMap) throws ParseException {
for (Map.Entry<FeatureType, TestUtils.FeatureAttributes> entry : featureAttributeMap.entrySet()) { for (Map.Entry<String, TestUtils.FeatureAttributes> entry : featureAttributeMap.entrySet()) {
TestUtils.FeatureAttributes featureAttributes = entry.getValue(); TestUtils.FeatureAttributes featureAttributes = entry.getValue();
FeatureType featureType = entry.getKey(); String featureType = entry.getKey();
assertTrue("License should have issuedTo of " + featureAttributes.issuedTo, esLicenseManager.getIssuedToForLicense(featureType).equals(featureAttributes.issuedTo)); assertTrue("License should have issuedTo of " + featureAttributes.issuedTo, esLicenseManager.getIssuedToForLicense(featureType).equals(featureAttributes.issuedTo));
assertTrue("License should have issuer of " + featureAttributes.issuer, esLicenseManager.getIssuerForLicense(featureType).equals(featureAttributes.issuer)); assertTrue("License should have issuer of " + featureAttributes.issuer, esLicenseManager.getIssuerForLicense(featureType).equals(featureAttributes.issuer));
assertTrue("License should have issue date of " + DateUtils.longFromDateString(featureAttributes.issueDate), esLicenseManager.getIssueDateForLicense(featureType) == DateUtils.longFromDateString(featureAttributes.issueDate)); assertTrue("License should have issue date of " + DateUtils.longFromDateString(featureAttributes.issueDate), esLicenseManager.getIssueDateForLicense(featureType) == DateUtils.longFromDateString(featureAttributes.issueDate));
@ -193,7 +193,7 @@ public class LicenseVerificationTests extends AbstractLicensingTestBase {
assertTrue("License should have subscription type of " + featureAttributes.subscriptionType, esLicenseManager.getSubscriptionTypeForLicense(featureType) == ESLicenses.SubscriptionType.fromString(featureAttributes.subscriptionType)); assertTrue("License should have subscription type of " + featureAttributes.subscriptionType, esLicenseManager.getSubscriptionTypeForLicense(featureType) == ESLicenses.SubscriptionType.fromString(featureAttributes.subscriptionType));
assertTrue("License should be valid for " + featureType.string(), esLicenseManager.hasLicenseForFeature(featureType)); assertTrue("License should be valid for " + featureType, esLicenseManager.hasLicenseForFeature(featureType));
assertTrue("License should be valid for maxNodes = " + (featureAttributes.maxNodes - 1), esLicenseManager.hasLicenseForNodes(featureType, featureAttributes.maxNodes - 1)); assertTrue("License should be valid for maxNodes = " + (featureAttributes.maxNodes - 1), esLicenseManager.hasLicenseForNodes(featureType, featureAttributes.maxNodes - 1));
assertTrue("License should be valid for maxNodes = " + (featureAttributes.maxNodes), esLicenseManager.hasLicenseForNodes(featureType, featureAttributes.maxNodes)); assertTrue("License should be valid for maxNodes = " + (featureAttributes.maxNodes), esLicenseManager.hasLicenseForNodes(featureType, featureAttributes.maxNodes));
assertFalse("License should not be valid for maxNodes = " + (featureAttributes.maxNodes + 1), esLicenseManager.hasLicenseForNodes(featureType, featureAttributes.maxNodes + 1)); assertFalse("License should not be valid for maxNodes = " + (featureAttributes.maxNodes + 1), esLicenseManager.hasLicenseForNodes(featureType, featureAttributes.maxNodes + 1));

10
src/test/java/org/elasticsearch/license/plugin/LicenseTransportTests.java
View File

@ -88,10 +88,10 @@ public class LicenseTransportTests extends ElasticsearchIntegrationTest {
@Test @Test
public void testPutLicense() throws ParseException, ExecutionException, InterruptedException, IOException { public void testPutLicense() throws ParseException, ExecutionException, InterruptedException, IOException {
Map<ESLicenses.FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes featureAttributes = TestUtils.FeatureAttributes featureAttributes =
new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-12-13"); new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-12-13");
map.put(ESLicenses.FeatureType.SHIELD, featureAttributes); map.put(TestUtils.SHIELD, featureAttributes);
String licenseString = TestUtils.generateESLicenses(map); String licenseString = TestUtils.generateESLicenses(map);
String licenseOutput = TestUtils.runLicenseGenerationTool(licenseString, pubKeyPath, priKeyPath); String licenseOutput = TestUtils.runLicenseGenerationTool(licenseString, pubKeyPath, priKeyPath);
@ -129,16 +129,16 @@ public class LicenseTransportTests extends ElasticsearchIntegrationTest {
@Test @Test
public void testPutInvalidLicense() throws Exception { public void testPutInvalidLicense() throws Exception {
Map<ESLicenses.FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes featureAttributes = TestUtils.FeatureAttributes featureAttributes =
new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-12-13"); new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-12-13");
map.put(ESLicenses.FeatureType.SHIELD, featureAttributes); map.put(TestUtils.SHIELD, featureAttributes);
String licenseString = TestUtils.generateESLicenses(map); String licenseString = TestUtils.generateESLicenses(map);
String licenseOutput = TestUtils.runLicenseGenerationTool(licenseString, pubKeyPath, priKeyPath); String licenseOutput = TestUtils.runLicenseGenerationTool(licenseString, pubKeyPath, priKeyPath);
ESLicenses esLicenses = readLicensesFromString(licenseOutput); ESLicenses esLicenses = readLicensesFromString(licenseOutput);
ESLicenses.ESLicense esLicense = esLicenses.get(ESLicenses.FeatureType.SHIELD); ESLicenses.ESLicense esLicense = esLicenses.get(TestUtils.SHIELD);
ESLicenses.ESLicense tamperedLicense = LicenseBuilders.licenseBuilder(true) ESLicenses.ESLicense tamperedLicense = LicenseBuilders.licenseBuilder(true)
.fromLicense(esLicense) .fromLicense(esLicense)
.expiryDate(esLicense.expiryDate() + 10 * 24 * 60 * 60 * 1000l) .expiryDate(esLicense.expiryDate() + 10 * 24 * 60 * 60 * 1000l)

57
src/test/java/org/elasticsearch/license/plugin/LicensesPluginIntegrationTests.java Normal file
View File

@ -0,0 +1,57 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the Elastic License;
* you may not use this file except in compliance with the Elastic License.
*/
package org.elasticsearch.license.plugin;
import org.elasticsearch.common.settings.ImmutableSettings;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.license.plugin.core.LicensesManagerService;
import org.elasticsearch.test.ElasticsearchIntegrationTest;
import org.elasticsearch.test.InternalTestCluster;
import org.junit.Test;
import static org.elasticsearch.test.ElasticsearchIntegrationTest.*;
import static org.elasticsearch.test.ElasticsearchIntegrationTest.Scope.SUITE;
@ClusterScope(scope = SUITE, numDataNodes = 10)
public class LicensesPluginIntegrationTests extends ElasticsearchIntegrationTest {
@Override
protected Settings nodeSettings(int nodeOrdinal) {
return ImmutableSettings.settingsBuilder()
.put("plugins.load_classpath_plugins", false)
.put("plugin.types", LicensePlugin.class.getName() + "," + TestConsumerPlugin.class.getName())
.build();
}
@Override
protected Settings transportClientSettings() {
// Plugin should be loaded on the transport client as well
return nodeSettings(0);
}
@Test
public void testLicenseRegistration() throws Exception {
LicensesManagerService managerService = licensesManagerService();
assertTrue(managerService.enabledFeatures().contains(TestPluginService.FEATURE_NAME));
}
@Test
public void testFeatureActivation() throws Exception {
TestPluginService pluginService = consumerPluginService();
assertTrue(pluginService.enabled());
}
private TestPluginService consumerPluginService() {
final InternalTestCluster clients = internalCluster();
return clients.getInstance(TestPluginService.class, clients.getMasterName());
}
private LicensesManagerService licensesManagerService() {
final InternalTestCluster clients = internalCluster();
return clients.getInstance(LicensesManagerService.class, clients.getMasterName());
}
}

68
src/test/java/org/elasticsearch/license/plugin/LicensesServiceTests.java
View File

@ -25,6 +25,7 @@ import org.elasticsearch.test.ElasticsearchIntegrationTest;
import org.elasticsearch.test.InternalTestCluster; import org.elasticsearch.test.InternalTestCluster;
import org.junit.After; import org.junit.After;
import org.junit.BeforeClass; import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test; import org.junit.Test;
import java.io.IOException; import java.io.IOException;
@ -32,6 +33,7 @@ import java.net.URISyntaxException;
import java.nio.file.Paths; import java.nio.file.Paths;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import java.util.Set;
import java.util.concurrent.CountDownLatch; import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicBoolean;
@ -89,6 +91,8 @@ public class LicensesServiceTests extends ElasticsearchIntegrationTest {
}); });
latch.await(); latch.await();
clear(); clear();
masterClusterService().remove(licensesService());
masterClusterService().add(licensesService());
} }
@ -102,10 +106,10 @@ public class LicensesServiceTests extends ElasticsearchIntegrationTest {
public void testInvalidSignedLicenseCheck() throws Exception { public void testInvalidSignedLicenseCheck() throws Exception {
LicensesManagerService licensesManagerService = licensesManagerService(); LicensesManagerService licensesManagerService = licensesManagerService();
Map<ESLicenses.FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes featureAttributes = TestUtils.FeatureAttributes featureAttributes =
new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-12-13"); new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-12-13");
map.put(ESLicenses.FeatureType.SHIELD, featureAttributes); map.put(TestUtils.SHIELD, featureAttributes);
String licenseString = TestUtils.generateESLicenses(map); String licenseString = TestUtils.generateESLicenses(map);
String licenseOutput = TestUtils.runLicenseGenerationTool(licenseString, pubKeyPath, priKeyPath); String licenseOutput = TestUtils.runLicenseGenerationTool(licenseString, pubKeyPath, priKeyPath);
ESLicenses licenses = LicenseUtils.readLicensesFromString(licenseOutput); ESLicenses licenses = LicenseUtils.readLicensesFromString(licenseOutput);
@ -113,8 +117,8 @@ public class LicensesServiceTests extends ElasticsearchIntegrationTest {
assertTrue(LicensesStatus.VALID == licensesManagerService.checkLicenses(licenses)); assertTrue(LicensesStatus.VALID == licensesManagerService.checkLicenses(licenses));
ESLicenses.ESLicense tamperedLicense = LicenseBuilders.licenseBuilder(true) ESLicenses.ESLicense tamperedLicense = LicenseBuilders.licenseBuilder(true)
.fromLicense(licenses.get(ESLicenses.FeatureType.SHIELD)) .fromLicense(licenses.get(TestUtils.SHIELD))
.expiryDate(licenses.get(ESLicenses.FeatureType.SHIELD).expiryDate() + 5 * 24 * 60 * 60 * 1000l) .expiryDate(licenses.get(TestUtils.SHIELD).expiryDate() + 5 * 24 * 60 * 60 * 1000l)
.issuer("elasticsearch") .issuer("elasticsearch")
.build(); .build();
@ -125,10 +129,10 @@ public class LicensesServiceTests extends ElasticsearchIntegrationTest {
@Test @Test
public void testStoringLicenses() throws Exception { public void testStoringLicenses() throws Exception {
Map<ESLicenses.FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes featureAttributes1 = TestUtils.FeatureAttributes featureAttributes1 =
new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-12-13"); new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-12-13");
map.put(ESLicenses.FeatureType.SHIELD, featureAttributes1); map.put(TestUtils.SHIELD, featureAttributes1);
String licenseString = TestUtils.generateESLicenses(map); String licenseString = TestUtils.generateESLicenses(map);
String licenseOutput = TestUtils.runLicenseGenerationTool(licenseString, pubKeyPath, priKeyPath); String licenseOutput = TestUtils.runLicenseGenerationTool(licenseString, pubKeyPath, priKeyPath);
ESLicenses licenses = LicenseUtils.readLicensesFromString(licenseOutput); ESLicenses licenses = LicenseUtils.readLicensesFromString(licenseOutput);
@ -158,7 +162,7 @@ public class LicensesServiceTests extends ElasticsearchIntegrationTest {
TestUtils.FeatureAttributes featureAttributes2 = TestUtils.FeatureAttributes featureAttributes2 =
new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2016-12-13"); new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2016-12-13");
map.put(ESLicenses.FeatureType.SHIELD, featureAttributes2); map.put(TestUtils.SHIELD, featureAttributes2);
licenseString = TestUtils.generateESLicenses(map); licenseString = TestUtils.generateESLicenses(map);
licenseOutput = TestUtils.runLicenseGenerationTool(licenseString, pubKeyPath, priKeyPath); licenseOutput = TestUtils.runLicenseGenerationTool(licenseString, pubKeyPath, priKeyPath);
ESLicenses licenses2 = LicenseUtils.readLicensesFromString(licenseOutput); ESLicenses licenses2 = LicenseUtils.readLicensesFromString(licenseOutput);
@ -209,18 +213,20 @@ public class LicensesServiceTests extends ElasticsearchIntegrationTest {
private class TestLicenseClientListener implements LicensesClientService.Listener { private class TestLicenseClientListener implements LicensesClientService.Listener {
AtomicBoolean shouldBeEnabled = new AtomicBoolean(false); AtomicBoolean shouldBeEnabled = new AtomicBoolean(false);
CountDownLatch latch = new CountDownLatch(2);
AtomicBoolean processed = new AtomicBoolean(false); AtomicBoolean processed = new AtomicBoolean(false);
private TestLicenseClientListener(boolean shouldBeEnabled) { private TestLicenseClientListener(boolean shouldBeEnabled) {
this.shouldBeEnabled.getAndSet(shouldBeEnabled); this.shouldBeEnabled.getAndSet(shouldBeEnabled);
} }
private void reset() {
processed.set(false);
}
@Override @Override
public void onEnabled() { public void onEnabled() {
if (this.shouldBeEnabled.get()) { if (this.shouldBeEnabled.get()) {
latch.countDown(); processed.set(true);
processed.getAndSet(true);
} else { } else {
fail("onEnabled should not have been called"); fail("onEnabled should not have been called");
} }
@ -230,12 +236,10 @@ public class LicensesServiceTests extends ElasticsearchIntegrationTest {
@Override @Override
public void onDisabled() { public void onDisabled() {
if (!this.shouldBeEnabled.get()) { if (!this.shouldBeEnabled.get()) {
latch.countDown(); processed.set(true);
processed.getAndSet(true);
} else { } else {
fail("onDisabled should not have been called"); fail("onDisabled should not have been called");
} }
} }
} }
@ -247,18 +251,22 @@ public class LicensesServiceTests extends ElasticsearchIntegrationTest {
// feature should be onEnabled // feature should be onEnabled
LicensesClientService clientService = licensesClientService(); LicensesClientService clientService = licensesClientService();
LicensesManagerService managerService = licensesManagerService();
final TestLicenseClientListener testLicenseClientListener = new TestLicenseClientListener(false); final TestLicenseClientListener testLicenseClientListener = new TestLicenseClientListener(false);
clientService.register("shield", null, testLicenseClientListener); clientService.register("shield", null, testLicenseClientListener);
while(!testLicenseClientListener.processed.get()) {} for (String enabledFeature : managerService.enabledFeatures()) {
assertFalse(enabledFeature.equals("shield"));
}
logger.info("pass initial check");
testLicenseClientListener.shouldBeEnabled.getAndSet(true); assertFalse(testLicenseClientListener.processed.get());
testLicenseClientListener.processed.getAndSet(false); testLicenseClientListener.shouldBeEnabled.set(true);
Map<ESLicenses.FeatureType, TestUtils.FeatureAttributes> map = new HashMap<>(); Map<String, TestUtils.FeatureAttributes> map = new HashMap<>();
TestUtils.FeatureAttributes featureAttributes1 = TestUtils.FeatureAttributes featureAttributes1 =
new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-12-13"); new TestUtils.FeatureAttributes("shield", "subscription", "platinum", "foo bar Inc.", "elasticsearch", 2, "2014-12-13", "2015-12-13");
map.put(ESLicenses.FeatureType.SHIELD, featureAttributes1); map.put(TestUtils.SHIELD, featureAttributes1);
String licenseString = TestUtils.generateESLicenses(map); String licenseString = TestUtils.generateESLicenses(map);
String licenseOutput = TestUtils.runLicenseGenerationTool(licenseString, pubKeyPath, priKeyPath); String licenseOutput = TestUtils.runLicenseGenerationTool(licenseString, pubKeyPath, priKeyPath);
ESLicenses licenses = LicenseUtils.readLicensesFromString(licenseOutput); ESLicenses licenses = LicenseUtils.readLicensesFromString(licenseOutput);
@ -281,13 +289,17 @@ public class LicensesServiceTests extends ElasticsearchIntegrationTest {
latch1.await(); latch1.await();
testLicenseClientListener.latch.await(); logger.info("waiting for onEnabled");
while(!testLicenseClientListener.processed.get()) {}
Set<String> enabledFeatures = licensesManagerService.enabledFeatures();
assertTrue(enabledFeatures.contains("shield"));
} }
@Test @Test
public void testFeatureWithoutLicense() throws Exception { public void testFeatureWithoutLicense() throws Exception {
LicensesClientService clientService = licensesClientService(); LicensesClientService clientService = licensesClientService();
final CountDownLatch latch = new CountDownLatch(1);
clientService.register("marvel", null, new LicensesClientService.Listener() { clientService.register("marvel", null, new LicensesClientService.Listener() {
@Override @Override
public void onEnabled() { public void onEnabled() {
@ -296,10 +308,16 @@ public class LicensesServiceTests extends ElasticsearchIntegrationTest {
@Override @Override
public void onDisabled() { public void onDisabled() {
latch.countDown();
} }
}); });
latch.await();
LicensesManagerService managerService = licensesManagerService();
assertFalse("feature should not be enabled: no licenses registered", managerService.enabledFeatures().contains("marvel"));
}
@Test @Ignore
public void testLicenseExpiry() throws Exception {
//TODO, first figure out how to generate a license with a quick expiry in matter of seconds
} }
@ -313,6 +331,11 @@ public class LicensesServiceTests extends ElasticsearchIntegrationTest {
return clients.getInstance(LicensesClientService.class, clients.getMasterName()); return clients.getInstance(LicensesClientService.class, clients.getMasterName());
} }
private LicensesService licensesService() {
final InternalTestCluster clients = internalCluster();
return clients.getInstance(LicensesService.class, clients.getMasterName());
}
private ClusterService masterClusterService() { private ClusterService masterClusterService() {
final InternalTestCluster clients = internalCluster(); final InternalTestCluster clients = internalCluster();
return clients.getInstance(ClusterService.class, clients.getMasterName()); return clients.getInstance(ClusterService.class, clients.getMasterName());
@ -324,4 +347,5 @@ public class LicensesServiceTests extends ElasticsearchIntegrationTest {
service.clear(); service.clear();
} }
} }

49
src/test/java/org/elasticsearch/license/plugin/TestConsumerPlugin.java Normal file
View File

@ -0,0 +1,49 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the Elastic License;
* you may not use this file except in compliance with the Elastic License.
*/
package org.elasticsearch.license.plugin;
import org.elasticsearch.common.collect.ImmutableSet;
import org.elasticsearch.common.component.LifecycleComponent;
import org.elasticsearch.common.inject.Module;
import org.elasticsearch.plugins.AbstractPlugin;
import java.util.Collection;
public class TestConsumerPlugin extends AbstractPlugin {
public TestConsumerPlugin() {
}
@Override
public String name() {
return "test_plugin";
}
@Override
public String description() {
return "test licensing consumer plugin";
}
@Override
public Collection<Class<? extends LifecycleComponent>> services() {
return ImmutableSet.<Class<? extends LifecycleComponent>>of(TestPluginService.class);
}
/*
@Override
public Collection<Class<? extends Module>> modules() {
return ImmutableSet.<Class<? extends Module>>of(TestPluginServiceModule.class);
}
public class TestPluginServiceModule extends AbstractModule {
@Override
protected void configure() {
bind(TestPluginService.class).in(Scopes.SINGLETON);
}
}
*/
}

70
src/test/java/org/elasticsearch/license/plugin/TestPluginService.java Normal file
View File

@ -0,0 +1,70 @@
/*
* Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
* or more contributor license agreements. Licensed under the Elastic License;
* you may not use this file except in compliance with the Elastic License.
*/
package org.elasticsearch.license.plugin;
import org.elasticsearch.ElasticsearchException;
import org.elasticsearch.common.component.AbstractLifecycleComponent;
import org.elasticsearch.common.inject.Inject;
import org.elasticsearch.common.inject.Singleton;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.license.plugin.core.LicensesClientService;
import org.elasticsearch.license.plugin.core.LicensesService;
import java.util.concurrent.atomic.AtomicBoolean;
@Singleton
public class TestPluginService extends AbstractLifecycleComponent<TestPluginService> {
private LicensesClientService licensesClientService;
// should be the same string used by the license Manger to generate
// signed license
static final String FEATURE_NAME = "shield";
// specify the trial license spec for the feature
// example: 30 day trial on 1000 nodes
final LicensesService.TrialLicenseOptions trialLicenseOptions = new LicensesService.TrialLicenseOptions(30, 1000);
private AtomicBoolean enabled = new AtomicBoolean(false);
@Inject
public TestPluginService(Settings settings, LicensesClientService licensesClientService) {
super(settings);
this.licensesClientService = licensesClientService;
}
// check if feature is enabled
public boolean enabled() {
return enabled.get();
}
protected void doStart() throws ElasticsearchException {
licensesClientService.register(FEATURE_NAME,
trialLicenseOptions,
new LicensingClientListener());
}
@Override
protected void doStop() throws ElasticsearchException {
}
@Override
protected void doClose() throws ElasticsearchException {
}
private class LicensingClientListener implements LicensesClientService.Listener {
@Override
public void onEnabled() {
enabled.set(true);
}
@Override
public void onDisabled() {
enabled.set(false);
}
}
}