hugegraph-common/src/test/java/com/baidu/hugegraph/unit/license/LicenseManagerTest.java - incubator-hugegraph-commons - Git at Google

 /*
  * Copyright 2017 HugeGraph Authors
  *
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements. See the NOTICE file distributed with this
  * work for additional information regarding copyright ownership. The ASF
  * licenses this file to You under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations
  * under the License.
  */

 package com.baidu.hugegraph.unit.license;

 import java.io.File;
 import java.io.IOException;
 import java.nio.charset.Charset;
 import java.util.List;
 import java.util.prefs.Preferences;

 import javax.security.auth.x500.X500Principal;

 import org.apache.commons.codec.Charsets;
 import org.apache.commons.io.FileUtils;
 import org.junit.After;
 import org.junit.Test;

 import com.baidu.hugegraph.license.CommonLicenseManager;
 import com.baidu.hugegraph.license.ExtraParam;
 import com.baidu.hugegraph.license.FileKeyStoreParam;
 import com.baidu.hugegraph.license.LicenseCreateParam;
 import com.baidu.hugegraph.license.LicenseVerifyParam;
 import com.baidu.hugegraph.testutil.Assert;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;

 import de.schlichtherle.license.CipherParam;
 import de.schlichtherle.license.DefaultCipherParam;
 import de.schlichtherle.license.DefaultLicenseParam;
 import de.schlichtherle.license.KeyStoreParam;
 import de.schlichtherle.license.LicenseContent;
 import de.schlichtherle.license.LicenseContentException;
 import de.schlichtherle.license.LicenseManager;
 import de.schlichtherle.license.LicenseParam;
 import de.schlichtherle.license.NoLicenseInstalledException;

 public class LicenseManagerTest {

     private static final Charset CHARSET = Charsets.UTF_8;
     private static final ObjectMapper MAPPER = new ObjectMapper();

     @After
     public void teardown() throws IOException {
         File lic = new File("src/test/resources/hugegraph-evaluation.license");
         FileUtils.forceDelete(lic);
     }

     @Test
     public void testCreateInstallVerifyLicense() throws IOException {
         String createConfigPath = "src/test/resources/create-license.json";
         LicenseCreator creator = LicenseCreator.build(createConfigPath);
         creator.create();

         String verifyConfigPath = "src/test/resources/verify-license.json";
         LicenseVerifier verifier = LicenseVerifier.build(verifyConfigPath);
         verifier.install();
         verifier.verify();
     }

     @Test
     public void testCreateVerifyLicenseWithoutInstall() throws IOException {
         String createConfigPath = "src/test/resources/create-license.json";
         LicenseCreator creator = LicenseCreator.build(createConfigPath);
         creator.create();

         String verifyConfigPath = "src/test/resources/verify-license.json";
         LicenseVerifier verifier = LicenseVerifier.build(verifyConfigPath);
         verifier.uninstall();
         Assert.assertThrows(RuntimeException.class, () -> {
             verifier.verify();
         }, e -> {
             Assert.assertEquals(NoLicenseInstalledException.class,
                                 e.getCause().getClass());
         });
     }

     private static class LicenseCreator {

         private static final X500Principal DEFAULT_ISSUER = new X500Principal(
                 "CN=localhost, OU=localhost, O=localhost, L=SH, ST=SH, C=CN");

         private final LicenseCreateParam param;

         public LicenseCreator(LicenseCreateParam param) {
             this.param = param;
         }

         public static LicenseCreator build(String path) throws IOException {
             File file = FileUtils.getFile(path);
             String json;
             try {
                 json = FileUtils.readFileToString(file, CHARSET);
             } catch (IOException e) {
                 throw new RuntimeException(String.format(
                           "Failed to read file '%s'", path));
             }
             LicenseCreateParam param = MAPPER.readValue(
                                        json, LicenseCreateParam.class);
             return new LicenseCreator(param);
         }

         public void create(){
             try {
                 LicenseParam licenseParam = this.initLicenseParam();
                 LicenseManager manager = new LicenseCreateManager(licenseParam);
                 LicenseContent licenseContent = this.initLicenseContent();
                 File licenseFile = new File(this.param.licensePath());
                 manager.store(licenseContent, licenseFile);
             } catch (Exception e){
                 throw new RuntimeException("Generate license failed", e);
             }
         }

         private LicenseParam initLicenseParam(){
             Preferences preferences = Preferences.userNodeForPackage(
                                       LicenseCreator.class);
             CipherParam cipherParam = new DefaultCipherParam(
                                       this.param.storePassword());
             KeyStoreParam keyStoreParam;
             keyStoreParam = new FileKeyStoreParam(LicenseCreator.class,
                                                   this.param.privateKeyPath(),
                                                   this.param.privateAlias(),
                                                   this.param.storePassword(),
                                                   this.param.keyPassword());
             return new DefaultLicenseParam(this.param.subject(), preferences,
                                            keyStoreParam, cipherParam);
         }

         private LicenseContent initLicenseContent(){
             LicenseContent content = new LicenseContent();
             content.setHolder(DEFAULT_ISSUER);
             content.setIssuer(DEFAULT_ISSUER);
             content.setSubject(this.param.subject());
             content.setIssued(this.param.issuedTime());
             content.setNotBefore(this.param.notBefore());
             content.setNotAfter(this.param.notAfter());
             content.setConsumerType(this.param.consumerType());
             content.setConsumerAmount(this.param.consumerAmount());
             content.setInfo(this.param.description());
             // Customized verification params
             String json;
             try {
                 json = MAPPER.writeValueAsString(this.param.extraParams());
             } catch (JsonProcessingException e) {
                 throw new RuntimeException("Failed to write extra params", e);
             }
             content.setExtra(json);
             return content;
         }
     }

     private static class LicenseCreateManager extends CommonLicenseManager {

         public LicenseCreateManager(LicenseParam param) {
             super(param);
         }

         @Override
         protected synchronized void validateCreate(LicenseContent content)
                   throws LicenseContentException {
             super.validateCreate(content);
         }
     }

     private static class LicenseVerifier {

         private final LicenseVerifyParam param;
         private final LicenseVerifyManager manager;

         public LicenseVerifier(LicenseVerifyParam param) {
             this.param = param;
             LicenseParam licenseParam = this.initLicenseParam(param);
             this.manager = new LicenseVerifyManager(licenseParam);
         }

         public static LicenseVerifier build(String path) throws IOException {
             File file = FileUtils.getFile(path);
             String json;
             try {
                 json = FileUtils.readFileToString(file, CHARSET);
             } catch (IOException e) {
                 throw new RuntimeException(String.format(
                           "Failed to read file '%s'", path));
             }
             LicenseVerifyParam param = MAPPER.readValue(
                                        json, LicenseVerifyParam.class);
             return new LicenseVerifier(param);
         }

         public synchronized void install() {
             try {
                 this.manager.uninstall();
                 File licenseFile = new File(this.param.licensePath());
                 this.manager.install(licenseFile);
             } catch (Exception e) {
                 throw new RuntimeException("Failed to install license", e);
             }
         }

         public synchronized void uninstall() {
             try {
                 this.manager.uninstall();
             } catch (Exception e) {
                 throw new RuntimeException("Failed to uninstall license", e);
             }
         }

         public void verify() {
             try {
                 this.manager.verify();
             } catch (Exception e) {
                 throw new RuntimeException("The license verify failed", e);
             }
         }

         private LicenseParam initLicenseParam(LicenseVerifyParam param) {
             Preferences preferences = Preferences.userNodeForPackage(
                                       LicenseVerifier.class);
             CipherParam cipherParam = new DefaultCipherParam(
                                       param.storePassword());
             KeyStoreParam keyStoreParam = new FileKeyStoreParam(
                                           LicenseVerifier.class,
                                           param.publicKeyPath(),
                                           param.publicAlias(),
                                           param.storePassword(),
                                           null);
             return new DefaultLicenseParam(param.subject(), preferences,
                                            keyStoreParam, cipherParam);
         }
     }

     private static class LicenseVerifyManager extends CommonLicenseManager {

         private final String serverId = "server-1";

         public LicenseVerifyManager(LicenseParam param) {
             super(param);
         }

         @Override
         protected synchronized void validate(LicenseContent content)
                   throws LicenseContentException {
             // Call super validate firstly, will verify expired
             super.validate(content);

             // Verify the customized license parameters
             String extra = (String) content.getExtra();
             List<ExtraParam> extraParams;
             try {
                 TypeReference<List<ExtraParam>> type;
                 type = new TypeReference<List<ExtraParam>>() {};
                 extraParams = MAPPER.readValue(extra, type);
             } catch (IOException e) {
                 throw new RuntimeException("Failed to read extra params", e);
             }
             ExtraParam param = this.matchParam(this.serverId, extraParams);
             if (param == null) {
                 throw newLicenseException("The current server's id '%s' " +
                                           "is not authorized");
             }
             if (this.usingGraphs() > param.graphs()) {
                 throw newLicenseException("The using graphs exceeded '%s'" +
                                           "authorized limit '%s'",
                                           this.usingGraphs(), param.graphs());
             }
         }

         private int usingGraphs() {
             // Assume
             return 2;
         }

         private ExtraParam matchParam(String id, List<ExtraParam> extraParams) {
             for (ExtraParam param : extraParams) {
                 if (param.id().equals(id)) {
                     return param;
                 }
             }
             return null;
         }

         private LicenseContentException newLicenseException(String message,
                                                             Object... args) {
             return new LicenseContentException(String.format(message, args));
         }
     }
 }
	/*
	* Copyright 2017 HugeGraph Authors
	*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with this
	* work for additional information regarding copyright ownership. The ASF
	* licenses this file to You under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations
	* under the License.
	*/

	package com.baidu.hugegraph.unit.license;

	import java.io.File;
	import java.io.IOException;
	import java.nio.charset.Charset;
	import java.util.List;
	import java.util.prefs.Preferences;

	import javax.security.auth.x500.X500Principal;

	import org.apache.commons.codec.Charsets;
	import org.apache.commons.io.FileUtils;
	import org.junit.After;
	import org.junit.Test;

	import com.baidu.hugegraph.license.CommonLicenseManager;
	import com.baidu.hugegraph.license.ExtraParam;
	import com.baidu.hugegraph.license.FileKeyStoreParam;
	import com.baidu.hugegraph.license.LicenseCreateParam;
	import com.baidu.hugegraph.license.LicenseVerifyParam;
	import com.baidu.hugegraph.testutil.Assert;
	import com.fasterxml.jackson.core.JsonProcessingException;
	import com.fasterxml.jackson.core.type.TypeReference;
	import com.fasterxml.jackson.databind.ObjectMapper;

	import de.schlichtherle.license.CipherParam;
	import de.schlichtherle.license.DefaultCipherParam;
	import de.schlichtherle.license.DefaultLicenseParam;
	import de.schlichtherle.license.KeyStoreParam;
	import de.schlichtherle.license.LicenseContent;
	import de.schlichtherle.license.LicenseContentException;
	import de.schlichtherle.license.LicenseManager;
	import de.schlichtherle.license.LicenseParam;
	import de.schlichtherle.license.NoLicenseInstalledException;

	public class LicenseManagerTest {

	private static final Charset CHARSET = Charsets.UTF_8;
	private static final ObjectMapper MAPPER = new ObjectMapper();

	@After
	public void teardown() throws IOException {
	File lic = new File("src/test/resources/hugegraph-evaluation.license");
	FileUtils.forceDelete(lic);
	}

	@Test
	public void testCreateInstallVerifyLicense() throws IOException {
	String createConfigPath = "src/test/resources/create-license.json";
	LicenseCreator creator = LicenseCreator.build(createConfigPath);
	creator.create();

	String verifyConfigPath = "src/test/resources/verify-license.json";
	LicenseVerifier verifier = LicenseVerifier.build(verifyConfigPath);
	verifier.install();
	verifier.verify();
	}

	@Test
	public void testCreateVerifyLicenseWithoutInstall() throws IOException {
	String createConfigPath = "src/test/resources/create-license.json";
	LicenseCreator creator = LicenseCreator.build(createConfigPath);
	creator.create();

	String verifyConfigPath = "src/test/resources/verify-license.json";
	LicenseVerifier verifier = LicenseVerifier.build(verifyConfigPath);
	verifier.uninstall();
	Assert.assertThrows(RuntimeException.class, () -> {
	verifier.verify();
	}, e -> {
	Assert.assertEquals(NoLicenseInstalledException.class,
	e.getCause().getClass());
	});
	}

	private static class LicenseCreator {

	private static final X500Principal DEFAULT_ISSUER = new X500Principal(
	"CN=localhost, OU=localhost, O=localhost, L=SH, ST=SH, C=CN");

	private final LicenseCreateParam param;

	public LicenseCreator(LicenseCreateParam param) {
	this.param = param;
	}

	public static LicenseCreator build(String path) throws IOException {
	File file = FileUtils.getFile(path);
	String json;
	try {
	json = FileUtils.readFileToString(file, CHARSET);
	} catch (IOException e) {
	throw new RuntimeException(String.format(
	"Failed to read file '%s'", path));
	}
	LicenseCreateParam param = MAPPER.readValue(
	json, LicenseCreateParam.class);
	return new LicenseCreator(param);
	}

	public void create(){
	try {
	LicenseParam licenseParam = this.initLicenseParam();
	LicenseManager manager = new LicenseCreateManager(licenseParam);
	LicenseContent licenseContent = this.initLicenseContent();
	File licenseFile = new File(this.param.licensePath());
	manager.store(licenseContent, licenseFile);
	} catch (Exception e){
	throw new RuntimeException("Generate license failed", e);
	}
	}

	private LicenseParam initLicenseParam(){
	Preferences preferences = Preferences.userNodeForPackage(
	LicenseCreator.class);
	CipherParam cipherParam = new DefaultCipherParam(
	this.param.storePassword());
	KeyStoreParam keyStoreParam;
	keyStoreParam = new FileKeyStoreParam(LicenseCreator.class,
	this.param.privateKeyPath(),
	this.param.privateAlias(),
	this.param.storePassword(),
	this.param.keyPassword());
	return new DefaultLicenseParam(this.param.subject(), preferences,
	keyStoreParam, cipherParam);
	}

	private LicenseContent initLicenseContent(){
	LicenseContent content = new LicenseContent();
	content.setHolder(DEFAULT_ISSUER);
	content.setIssuer(DEFAULT_ISSUER);
	content.setSubject(this.param.subject());
	content.setIssued(this.param.issuedTime());
	content.setNotBefore(this.param.notBefore());
	content.setNotAfter(this.param.notAfter());
	content.setConsumerType(this.param.consumerType());
	content.setConsumerAmount(this.param.consumerAmount());
	content.setInfo(this.param.description());
	// Customized verification params
	String json;
	try {
	json = MAPPER.writeValueAsString(this.param.extraParams());
	} catch (JsonProcessingException e) {
	throw new RuntimeException("Failed to write extra params", e);
	}
	content.setExtra(json);
	return content;
	}
	}

	private static class LicenseCreateManager extends CommonLicenseManager {

	public LicenseCreateManager(LicenseParam param) {
	super(param);
	}

	@Override
	protected synchronized void validateCreate(LicenseContent content)
	throws LicenseContentException {
	super.validateCreate(content);
	}
	}

	private static class LicenseVerifier {

	private final LicenseVerifyParam param;
	private final LicenseVerifyManager manager;

	public LicenseVerifier(LicenseVerifyParam param) {
	this.param = param;
	LicenseParam licenseParam = this.initLicenseParam(param);
	this.manager = new LicenseVerifyManager(licenseParam);
	}

	public static LicenseVerifier build(String path) throws IOException {
	File file = FileUtils.getFile(path);
	String json;
	try {
	json = FileUtils.readFileToString(file, CHARSET);
	} catch (IOException e) {
	throw new RuntimeException(String.format(
	"Failed to read file '%s'", path));
	}
	LicenseVerifyParam param = MAPPER.readValue(
	json, LicenseVerifyParam.class);
	return new LicenseVerifier(param);
	}

	public synchronized void install() {
	try {
	this.manager.uninstall();
	File licenseFile = new File(this.param.licensePath());
	this.manager.install(licenseFile);
	} catch (Exception e) {
	throw new RuntimeException("Failed to install license", e);
	}
	}

	public synchronized void uninstall() {
	try {
	this.manager.uninstall();
	} catch (Exception e) {
	throw new RuntimeException("Failed to uninstall license", e);
	}
	}

	public void verify() {
	try {
	this.manager.verify();
	} catch (Exception e) {
	throw new RuntimeException("The license verify failed", e);
	}
	}

	private LicenseParam initLicenseParam(LicenseVerifyParam param) {
	Preferences preferences = Preferences.userNodeForPackage(
	LicenseVerifier.class);
	CipherParam cipherParam = new DefaultCipherParam(
	param.storePassword());
	KeyStoreParam keyStoreParam = new FileKeyStoreParam(
	LicenseVerifier.class,
	param.publicKeyPath(),
	param.publicAlias(),
	param.storePassword(),
	null);
	return new DefaultLicenseParam(param.subject(), preferences,
	keyStoreParam, cipherParam);
	}
	}

	private static class LicenseVerifyManager extends CommonLicenseManager {

	private final String serverId = "server-1";

	public LicenseVerifyManager(LicenseParam param) {
	super(param);
	}

	@Override
	protected synchronized void validate(LicenseContent content)
	throws LicenseContentException {
	// Call super validate firstly, will verify expired
	super.validate(content);

	// Verify the customized license parameters
	String extra = (String) content.getExtra();
	List<ExtraParam> extraParams;
	try {
	TypeReference<List<ExtraParam>> type;
	type = new TypeReference<List<ExtraParam>>() {};
	extraParams = MAPPER.readValue(extra, type);
	} catch (IOException e) {
	throw new RuntimeException("Failed to read extra params", e);
	}
	ExtraParam param = this.matchParam(this.serverId, extraParams);
	if (param == null) {
	throw newLicenseException("The current server's id '%s' " +
	"is not authorized");
	}
	if (this.usingGraphs() > param.graphs()) {
	throw newLicenseException("The using graphs exceeded '%s'" +
	"authorized limit '%s'",
	this.usingGraphs(), param.graphs());
	}
	}

	private int usingGraphs() {
	// Assume
	return 2;
	}

	private ExtraParam matchParam(String id, List<ExtraParam> extraParams) {
	for (ExtraParam param : extraParams) {
	if (param.id().equals(id)) {
	return param;
	}
	}
	return null;
	}

	private LicenseContentException newLicenseException(String message,
	Object... args) {
	return new LicenseContentException(String.format(message, args));
	}
	}
	}