diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 00000000..18634199
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,11 @@
+language: java
+jdk:
+ - openjdk8
+
+before_install:
+ - cd ./tools
+ - mvn install:install-file -Dfile=core-0.1.4.jar -DgroupId=com.yahoo.ycsb -DartifactId=core -Dversion=0.1.4 -Dpackaging=jar -DgeneratePom=true -DcreateChecksum=true
+ - cd ../source
+
+script:
+ - mvn clean package
\ No newline at end of file
diff --git a/README.md b/README.md
index 6b98db84..675472d0 100644
--- a/README.md
+++ b/README.md
@@ -1,626 +1,120 @@
[TOC]
#JD区块链
-
[![License](https://img.shields.io/badge/license-Apache%202-4EB1BA.svg)](https://www.apache.org/licenses/LICENSE-2.0.html)
+[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.jd.blockchain/sdk-pack/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.jd.blockchain/sdk-pack/)
+[![Build Status](https://travis-ci.com/blockchain-jd-com/jdchain.svg?branch=master)](https://travis-ci.org/blockchain-jd-com/jdchain)
-------------------------------------------------------------------------
-### 版本修订历史
-
-
- 版本号 |
- 作 者 |
- 修改日期 |
- 备 注 |
-
-
- 0.0.6 |
- 黄海泉 |
- 2017-11-10 |
-
- 定义JD区块链项目的目标与关键能力;
- 定义JD区块链的核心对象模型;
- 定义“账户”的生成算法和“区块/交易/操作/账户”的关键属性;
- 描述了编程接口的示例代码;
- |
-
-
- 0.0.7 |
- 黄海泉 |
- 2017-11-17 |
-
- 丰富了对“节点共识”、“节点分区”两项关键能力的详细描述;
- |
-
-
- 0.0.8 |
- 黄海泉 |
- 2018-07-17 |
-
- 增加部署图;增加智能合约开发的示例;
- |
-
-
------------------------------------------------------------------------
-## 一、概述
-JD区块链项目的目标是提供一个面向广泛的应用场景、满足企业核心需求的灵活和易用的区块链系统。
-以下是 JD 区块链用以满足企业核心需求的关键能力,也是显著区别于其它区块链的重要特征:
-
- - 快速共识
- - 节点分区
- - 并行多账本
- - 大数据伸缩存储
- - 条件检索
- - 面向对象的合约代码编程模型
- - 节点快速部署
- - 多终端灵活接入
- - 分布式自治的账户权限管理模型
-
-JD区块链对于关键能力的定义是建立在深入理解和抽象各种多样化需求的基础上的。
-
- - 快速共识(Efficient Consensus)
- 我们认为,“快速”不仅仅体现在“用更短时间”达成共识,还要体现在交易(Transaction)要得到可靠地执行。
- 需要在算法和实现层面做出保障,确保所有提交的合法的交易会被系统在一个“确定性”和“足够短”的时间之内被严格地执行,系统不主动作出随机性地丢弃(不包括系统故障因素)。注:POW类算法产生的链分叉处理是一种系统随机性地丢弃交易的行为。
- 从使用者的视角来看,这种能力就是区块链系统的“可靠性”,这对于企业、金融场景而言尤其重要。
-
- - 节点分区(Peer Partition)
- “分区”是一种分布式系统架构原则,通过将大范围目标按照某种相似特征分隔为一个个小范围目标,分别进行更高效地处理,这能从整体上提升整个系统的处理能力。
- 区块链系统也是一种分布式系统,沿用“分区”的思想这点来自以往的系统架构实践的经验,是有可能让区块链系统获得可媲美现有系统的处理能力。这种能力将可以无障碍地把区块链在应用于广泛的企业场景中。
- 在此,我们所说的“节点分区(Peer Partition)” 是共识过程中的物理通讯层面的分区,在共识过程中只有相关的物理节点才会建立通讯链路并复制和存储共识的状态数据。在一个区块链系统中,可以从节点全集中选择一个或多个节点子集,分别组成一个或多个节点分区(Peer Partition)
-
- - 并行多账本
- 账本(Ledger)
- - 大数据伸缩存储
- - 条件检索
- - 面向对象的合约代码编程模型
- - 节点快速部署
- - 多终端灵活接入
- - 分布式自治的账户权限管理模型
-
-## 二、对象模型
-JD区块链的核心对象包括:
-
- - 账本(Ledger)
- 一份账本(Ledger)实质上是由两部分组成:
- - 一组以“账户(Account)”表示的状态数据;
- - 以“区块的链条(Block-chain)”表示的状态数据的变更历史;
-
- JD区块链的“账本(Ledger)”是一个最顶层的管理数据的逻辑单元。在一个区块链节点构成的共识网络中,可以维护多套并行的“账本(Ledger)”。
-
- - 账户(Account)
- - 在JD区块链中,账户(Account)被设计为包含“身份(Identity)”、“权限(Privilege)”、“状态(State)”、“控制规则(Control Rule)” 这4种属性的对象。
- - 其中,“身份(Identity)”、“权限(Privilege)”这两种属性是一个面向应用的系统的基本功能;
- - “状态(State)”、“控制规则(Control Rule)” 这两种属性这是一个具备“图灵完备性”的系统的基本属性,使系统可以处理任意多样化的任务;
- - 在这里,“身份(Identity)”是一个抽象表述,其形式上就是一个“区块链地址(Address)”和相应的“非对称秘钥钥对(KeyPair)”/证书。 简单来说,一个“账户(Account)”就是一个区块链地址、公私钥对以及一套的权限配置.
- - 一个“账户(Account)”的“状态(State)”、“控制规则(Control Rule)” 这2种属性则是可选的,这提供了不同于其它区块链的账户/合约的一种新的使用方式,即一种数据和逻辑分离的应用设计思路(这在传统的web应用编程中被称为“贫血模型”)。同时,也意味着一个特定“账户”中的数据状态是可以跨账户/合约代码进行共享访问的。
- - 从应用的视角来看,对“账户”的使用方式可以有几种模式:
- - 用于表示业务角色/用户:
- - 用于表示业务数据:仅有“状态(State)”没有“控制规则(Control Rule)”的账户,可称为数据账户,就有些类似于关系数据库中的“表(Table)”的作用,不同业务类别的数据则使用不同的账户来管理。
- - 用于表示业务逻辑:仅有“控制规则(Control Rule)”没有“状态(State)”的账户,即所谓的合约账户,可表示某种用于处理数据的通用逻辑,可被授权访问特定的数据账户。
-
- - 区块(Block)
- 在概念上,与通常所说的区块的概念是一致的。
- 在实现上,一个区块的主要内容是包含了某一时刻提交的所有交易以及交易执行之后的状态数据的快照的hash,而不存储具体的交易操作和状态数据。
-
- - 交易(Transaction)
- 在概念上,与通常所说的Transaction的概念是一致的,表示一组需要原子执行的操作。
-
- - 操作(Operation)
- 操作是针对“账户(Account)”的“写”指令,包括以下几类:
- - 注册账户
- - 更新账户的状态数据
- - 更新账户的合约代码定义
- - 调用账户的合约代码
-
- - 合约代码(Contract Code)
- 合约代码是一段用于对“账户(Account)”的状态数据执行操作的代码程序。
-
-## 三、部署模型
-
- 1. 总体部署
-![deployment architecture](docs/images/deployment.png)
-
- 2. 系统组件
- - 共识节点
- - 复制节点
- - SDK
- - 网关
- - 终端
-
- 3. 配置和管理
-
-## 四、账本结构
-
-### 1. 账户生成算法
-
- - 公私钥对
- - 算法:默认ED25519 ,支持 SM2、CA;
- - 公钥存储格式:版本 + 算法标识 + 公私钥原始内容 + 校验码
- - 字符编码方式:Base64
- - 地址
- - 算法
- - 给定公钥 P (或由私钥 R 算出公钥 P)
- - 中间值 H1 = SHA256( P )
- - 中间值 H2 = RIPEMD-160( H1 )
- - 中间值 X = 版本 + 公钥算法标识 + H2
- - 校验和 C = 前4字节( SHA256( SHA256( X )) )
- - 地址 Address = Base58( X + C )
-
-### 2. 区块
-
-
- 属性 |
- 名称 |
- 说明 |
-
-
- BlockHash |
- 当前区块 hash |
- 对区块中除此之外的其它所有属性一起进行哈希运算生成 |
-
-
- BlockVersion |
- 区块版本 |
- 表示区块-交易的属性结构的版本号; |
-
-
- PreviousBlockHash |
- 上一区块 hash |
- |
-
-
- BlockNumber |
- 区块高度 |
- 区块高度是一个区块在链中的序号; 创始区块的高度为 0,每个新区块的高度依次递增; |
-
-
- AccountHash |
- 账户树hash |
- 账户的 Merkle Tree 根的 hash |
-
-
- AccountCount |
- 账户数量 |
- 区块生成时账本中的全部账户的总数 |
-
-
- TxTreeHash |
- 交易树 hash |
- 本区块的交易集合的 Merkle Tree 根的 hash |
-
-
- TxCount |
- 区块交易数量 |
- 当前区块包含的交易的数量; |
-
-
- TxTotalCount |
- 账本交易总数 |
- 截止到当前区块为止当前账本的所有交易的总数量; |
-
-
- CloseTime |
- 区块关闭时间 |
- 生成当前区块时的区块链节点的网络时间; |
-
-
-
-### 3. 交易
-
-
- 属性 |
- 名称 |
- 说明 |
-
-
- Hash |
- 当前交易 hash |
- 对交易中除此之外的其它所有属性一起进行哈希运算生成 |
-
-
- LedgerNumber |
- 区块高度 |
- 交易被包含的区块高度 |
-
-
- BlobHash |
- 交易数据块hash |
- 交易的数据块是交易的原始数据,包含客户端提交的交易的全部操作及其参数;
- 交易的参与者需要使用私钥对交易数据块进行签名; |
-
-
- Operations |
- 操作列表 |
- 交易的操作列表; |
-
-
- Sponsor |
- 交易发起人 |
- 交易发起人的账户地址; |
-
-
- SequenceNumber |
- 交易序号 |
- 交易序号记录了一个特定的发起人的交易的顺序号,等同于该发起人历史上发起的交易的总数; |
-
-
- Signatures |
- 签名列表 |
- 由交易发起人和其它参与者对交易数据块的签名的列表; |
-
-
- Result |
- 交易结果 |
- 0 - 表示执行成功;非零表示执行失败; 注:最终的账本只包含成功的交易; |
-
-
-
-### 4. 操作
-
-
- 属性 |
- 名称 |
- 说明 |
-
-
- OpType |
- 操作类型 |
-
- 一级操作类型包括:注册账户、配置权限、写入键值数据、写入对象数据、定义合约代码、调用合约代码;
- “键值数据写入”操作的子操作类型包括:填入键值、移除键、数值增加、数值减少;
- “对象数据写入”操作的自操作类型包括:插入对象、更新对象、移除对象;
- |
-
-
- Args |
- 参数列表 |
- 与操作类型相对应的参数列表; |
-
-
- SubOps |
- 子操作列表 |
- “子操作”是“操作”的递归定义,由“操作类型”来标识; |
-
-
-
-### 5. 账户
-
-
- 属性 |
- 名称 |
- 说明 |
-
-
- Address |
- 地址 |
- 账户的唯一标识 |
-
-
- RegNumber |
- 注册号 |
- 账户被注册到区块链的区块高度; |
-
-
- TxSquenceNumber |
- 交易序列号 |
- 由账户发起的交易的序列号,初始为 0,账户每发起一个交易则增加1; |
-
-
- ModelVersion |
- 账户模型版本 |
- 表示构成一个账户结构的属性模型的程序版本号; |
-
-
- Version |
- 账户版本 |
- 初始为 0,对账户的每一次变更(包括对权限设置、状态和合约代码的变更)都会使账户状态版本增加 1 ; 注:交易序号的改变不会导致账户版本的增加; |
-
-
- PrivilegeHash |
- 权限 hash |
- 权限树的根hash; |
-
-
- PrivilegeVersion |
- 权限版本 |
- 初始为 0, 每次对权限的变更都导致版本号加 1; |
-
-
- StateType |
- 状态类型 |
- 账户的状态类型有3种:空类型(NIL);键值类型;对象类型; |
-
-
- StateVersion |
- 状态版本 |
- 账户的状态类型有3种:空类型(NIL);键值类型;对象类型; |
-
-
- StateHash |
- 状态哈希 |
- 数据状态的 merkle tree 的根hash; |
-
-
- CodeHash |
- 合约代码哈希 |
- 由“账户地址+合约代码版本号+合约代码内容”生成的哈希; |
-
-
- CodeVersion |
- 代码版本 |
- 初始为 0,每次对代码的变更都使版本加 1 ; |
-
-
-
-## 五、编程接口
-
-### 1. 服务连接
-
-
-```java
- //创建服务代理
- public static BlockchainKeyPair CLIENT_CERT = BlockchainKeyGenerator.getInstance().generate();
- final String GATEWAY_IP = "127.0.0.1";
- final int GATEWAY_PORT = 80;
- final boolean SECURE = false;
- GatewayServiceFactory serviceFactory = GatewayServiceFactory.connect(GATEWAY_IP, GATEWAY_PORT, SECURE,
- CLIENT_CERT);
- // 创建服务代理;
- BlockchainService service = serviceFactory.getBlockchainService();
-```
+## 一、项目介绍
+JD Chain 的目标是实现一个面向企业应用场景的通用区块链框架系统,能够作为企业级基础设施,为业务创新提供高效、灵活和安全的解决方案。
-### 2. 用户注册
+## 二、部署模型
+JD Chain 主要部署组件包括以下几种:
-```java
- // 创建服务代理;
- BlockchainService service = serviceFactory.getBlockchainService();
- // 在本地定义注册账号的 TX;
- TransactionTemplate txTemp = service.newTransaction(ledgerHash);
- SignatureFunction signatureFunction = asymmetricCryptography.getSignatureFunction(CryptoAlgorithm.ED25519);
- CryptoKeyPair cryptoKeyPair = signatureFunction.generateKeyPair();
- BlockchainKeyPair user = new BlockchainKeyPair(cryptoKeyPair.getPubKey(), cryptoKeyPair.getPrivKey());
-
- txTemp.users().register(user.getIdentity());
+- 共识节点
- // TX 准备就绪;
- PreparedTransaction prepTx = txTemp.prepare();
- // 使用私钥进行签名;
- CryptoKeyPair keyPair = getSponsorKey();
- prepTx.sign(keyPair);
+ 共识节点即参与共识的节点,这是系统的核心组件,承担了运行共识协议、管理账本数据、运行智能合约的职责。
- // 提交交易;
- prepTx.commit();
-```
+ 一个区块链网络由多个共识节点组成,共识节点的数量范围由选择的共识协议决定。
+ 共识节点和账本是两个不同的概念,共识节点是个物理上的概念,账本是个逻辑上的概念。JD Chain 是一个多账本区块链系统,一个共识节点上可以装载运行多个账本。账本是数据维度的独立管理单元。共识节点和账本的关系,就像关系数据库系统中,数据库服务器和数据库实例的关系。
-### 3. 数据账户注册
+ 共识节点通常都部署在参与方的内部网络中,通过由网络管理员指定的安全的网络出口与其它的共识节点建立通讯连接。
+ 共识节点在形态上是服务器中的一个处理进程,背后需要连接一个本地或者内网的NoSQL数据库系统作为账本的存储。当前版本,共识节点目前是单进程的,未来版本将实现多进程以及多服务器集群模式。
-```java
- // 创建服务代理;
- BlockchainService service = serviceFactory.getBlockchainService();
- // 在本地定义注册账号的 TX;
- TransactionTemplate txTemp = service.newTransaction(ledgerHash);
- SignatureFunction signatureFunction = asymmetricCryptography.getSignatureFunction(CryptoAlgorithm.ED25519);
- CryptoKeyPair cryptoKeyPair = signatureFunction.generateKeyPair();
- BlockchainKeyPair dataAccount = new BlockchainKeyPair(cryptoKeyPair.getPubKey(), cryptoKeyPair.getPrivKey());
-
- txTemp.dataAccounts().register(dataAccount.getIdentity());
-
- // TX 准备就绪;
- PreparedTransaction prepTx = txTemp.prepare();
- // 使用私钥进行签名;
- CryptoKeyPair keyPair = getSponsorKey();
- prepTx.sign(keyPair);
-
- // 提交交易;
- prepTx.commit();
-```
+- 网关节点
-### 4. 写入数据
+ 网关节点是负责终端接入的节点,负责终端连接、协议转换、交易准入、本地密码运算、密钥管理等职责。
-```java
- // 创建服务代理;
- BlockchainService service = serviceFactory.getBlockchainService();
-
- HashDigest ledgerHash = getLedgerHash();
- // 在本地定义注册账号的 TX;
- TransactionTemplate txTemp = service.newTransaction(ledgerHash);
-
- // --------------------------------------
- // 将商品信息写入到指定的账户中;
- // 对象将被序列化为 JSON 形式存储,并基于 JSON 结构建立查询索引;
- String commodityDataAccount = "GGhhreGeasdfasfUUfehf9932lkae99ds66jf==";
- Commodity commodity1 = new Commodity();
- txTemp.dataAccount(commodityDataAccount).set("ASSET_CODE", commodity1.getCode().getBytes(), -1);
-
- // TX 准备就绪;
- PreparedTransaction prepTx = txTemp.prepare();
-
- String txHash = ByteArray.toBase64(prepTx.getHash().toBytes());
- // 使用私钥进行签名;
- CryptoKeyPair keyPair = getSponsorKey();
- prepTx.sign(keyPair);
-
- // 提交交易;
- prepTx.commit();
-```
+ 网关节点是一种轻量节点,需要绑定一个特定参与方的密钥对,连接到一个或多个共识节点。
-
-### 5. 查询数据
+ 网关节点向共识节点的连接是需要通过认证的,绑定的参与方的密钥对必须事先已经注册到区块链账本中,且得到接入授权。
-> 注:详细的查询可参考模块sdk-samples中SDK_GateWay_Query_Test_相关测试用例
+- 终端
-```java
- // 创建服务代理;
- BlockchainService service = serviceFactory.getBlockchainService();
-
- // 查询区块信息;
- // 区块高度;
- long ledgerNumber = service.getLedger(LEDGER_HASH).getLatestBlockHeight();
- // 最新区块;
- LedgerBlock latestBlock = service.getBlock(LEDGER_HASH, ledgerNumber);
- // 区块中的交易的数量;
- long txCount = service.getTransactionCount(LEDGER_HASH, latestBlock.getHash());
- // 获取交易列表;
- LedgerTransaction[] txList = service.getTransactions(LEDGER_HASH, ledgerNumber, 0, 100);
- // 遍历交易列表
- for (LedgerTransaction ledgerTransaction : txList) {
- TransactionContent txContent = ledgerTransaction.getTransactionContent();
- Operation[] operations = txContent.getOperations();
- if (operations != null && operations.length > 0) {
- for (Operation operation : operations) {
- operation = ClientOperationUtil.read(operation);
- // 操作类型:数据账户注册操作
- if (operation instanceof DataAccountRegisterOperation) {
- DataAccountRegisterOperation daro = (DataAccountRegisterOperation) operation;
- BlockchainIdentity blockchainIdentity = daro.getAccountID();
- }
- // 操作类型:用户注册操作
- else if (operation instanceof UserRegisterOperation) {
- UserRegisterOperation uro = (UserRegisterOperation) operation;
- BlockchainIdentity blockchainIdentity = uro.getUserID();
- }
- // 操作类型:账本注册操作
- else if (operation instanceof LedgerInitOperation) {
-
- LedgerInitOperation ledgerInitOperation = (LedgerInitOperation)operation;
- LedgerInitSetting ledgerInitSetting = ledgerInitOperation.getInitSetting();
-
- ParticipantNode[] participantNodes = ledgerInitSetting.getConsensusParticipants();
- }
- // 操作类型:合约发布操作
- else if (operation instanceof ContractCodeDeployOperation) {
- ContractCodeDeployOperation ccdo = (ContractCodeDeployOperation) operation;
- BlockchainIdentity blockchainIdentity = ccdo.getContractID();
- }
- // 操作类型:合约执行操作
- else if (operation instanceof ContractEventSendOperation) {
- ContractEventSendOperation ceso = (ContractEventSendOperation) operation;
- }
- // 操作类型:KV存储操作
- else if (operation instanceof DataAccountKVSetOperation) {
- DataAccountKVSetOperation.KVWriteEntry[] kvWriteEntries =
- ((DataAccountKVSetOperation) operation).getWriteSet();
- if (kvWriteEntries != null && kvWriteEntries.length > 0) {
- for (DataAccountKVSetOperation.KVWriteEntry kvWriteEntry : kvWriteEntries) {
- BytesValue bytesValue = kvWriteEntry.getValue();
- DataType dataType = bytesValue.getType();
- Object showVal = ClientOperationUtil.readValueByBytesValue(bytesValue);
- System.out.println("writeSet.key=" + kvWriteEntry.getKey());
- System.out.println("writeSet.value=" + showVal);
- System.out.println("writeSet.type=" + dataType);
- System.out.println("writeSet.version=" + kvWriteEntry.getExpectedVersion());
- }
- }
- }
- }
- }
- }
-
- // 根据交易的 hash 获得交易;注:客户端生成 PrepareTransaction 时得到交易hash;
- HashDigest txHash = txList[0].getTransactionContent().getHash();
- Transaction tx = service.getTransactionByContentHash(LEDGER_HASH, txHash);
- // 获取数据;
- String commerceAccount = "GGhhreGeasdfasfUUfehf9932lkae99ds66jf==";
- String[] objKeys = new String[] { "x001", "x002" };
- KVDataEntry[] kvData = service.getDataEntries(LEDGER_HASH, commerceAccount, objKeys);
-
- long payloadVersion = kvData[0].getVersion();
-
- // 获取数据账户下所有的KV列表
- KVDataEntry[] kvData = service.getDataEntries(ledgerHash, commerceAccount, 0, 100);
- if (kvData != null && kvData.length > 0) {
- for (KVDataEntry kvDatum : kvData) {
- System.out.println("kvData.key=" + kvDatum.getKey());
- System.out.println("kvData.version=" + kvDatum.getVersion());
- System.out.println("kvData.type=" + kvDatum.getType());
- System.out.println("kvData.value=" + kvDatum.getValue());
- }
- }
-```
+ 终端泛指可以提交交易的客户端,典型来说,包括人、自动化设备、链外的信息系统等。
+ 终端只能通过网关节点来提交交易。终端提交的交易需要用体现该终端身份的私钥来签署,产生一份电子签名。随后当交易提交给网关节点时,网关节点需要在把交易提交到共识节点之前,对交易请求以网关节点绑定的私钥追加一项“节点签名”。
-### 6. 合约发布
+- 备份节点
-```java
-
- // 创建服务代理;
- BlockchainService service = serviceFactory.getBlockchainService();
-
- // 在本地定义TX模板
- TransactionTemplate txTemp = service.newTransaction(ledgerHash);
+ 仅对账本数据提供备份,但不参与交易共识的节点。(注:目前版本中尚未实现,将在后续版本中提供)
- // 合约内容读取
- byte[] contractBytes = FileUtils.readBytes(new File(CONTRACT_FILE));
- // 生成用户
- BlockchainIdentityData blockchainIdentity = new BlockchainIdentityData(getSponsorKey().getPubKey());
+![](docs/images/deployment.jpg)
- // 发布合约
- txTemp.contracts().deploy(blockchainIdentity, contractBytes);
- // TX 准备就绪;
- PreparedTransaction prepTx = txTemp.prepare();
+## 三、编译源代码
- // 使用私钥进行签名;
- CryptoKeyPair keyPair = getSponsorKey();
+ 1. 安装 Maven 环境
- prepTx.sign(keyPair);
+ JD Chain 当前版本以 Java 语言开发,需要安装配置 JVM 和 Maven,JDK 版本不低于1.8 。(没有特殊要求,请按标准方法安装,此处不赘述)
+
+ 2. 安装 Git 工具
+
+ 为了能够执行 git clone 命令获取代码仓库。 (没有特殊要求,请按标准方法安装,此处不赘述)
+
+ 3. 工程代码
- // 提交交易;
- TransactionResponse transactionResponse = prepTx.commit();
+ JD Chain 源代码包括 3 个代码仓库
- assertTrue(transactionResponse.isSuccess());
+ - jdchain
+ - 这是当前仓库,也是核心仓库,包含了共识节点、网关节点、SDK等一切部署组件。依赖于 explorer 和 bftsmart 这两个仓库先进行编译安装;
+
+ - explorer
+ - 这是区块链浏览器的前端Web页面的工程,需要编译成静态资源包,由网关节点集成到一起部署。
+ - 地址:git@github.com:blockchain-jd-com/explorer.git
- // 打印合约地址
- System.out.println(blockchainIdentity.getAddress().toBase58());
+ - bftsmart
+ - 这是bftsmart共识协议的工程,需要先编译安装到本地 maven 仓库;
-```
-### 7. 合约执行
+4. 命令操作
-```java
+- 编译安装 explorer 到本地 maven 仓库;
+```sh
+ $ git clone git@github.com:blockchain-jd-com/explorer.git explorer
- // 创建服务代理;
- BlockchainService service = serviceFactory.getBlockchainService();
+ $ cd explorer
- // 在本地定义TX模板
- TransactionTemplate txTemp = service.newTransaction(ledgerHash);
+ $ git checkout master
- // 合约地址
- String contractAddressBase58 = "";
-
- // 使用接口方式调用合约
- TransferContract transferContract = txTpl.contract(contractAddress, TransferContract.class);
-
- // 使用decode方式调用合约内部方法(create方法)
- // 返回GenericValueHolder可通过get方法获取结果,但get方法需要在commit调用后执行
- GenericValueHolder result = ContractReturnValue.decode(transferContract.create(address, account, money));
-
- PreparedTransaction ptx = txTpl.prepare();
-
- ptx.sign(adminKey);
-
- TransactionResponse transactionResponse = ptx.commit();
+ $ mvn clean install
- String cotractExecResult = result.get();
-
- // TransactionResponse也提供了可供查询结果的接口
- OperationResult[] operationResults = transactionResponse.getOperationResults();
+```
+- 编译安装 bftsmart 到本地 maven 仓库;
+ - 需要手动先安装一个第三方包,位于仓库根目录下 lib/core-0.1.4.jar
+```sh
+ $ git clone git@github.com:blockchain-jd-com/bftsmart.git bftsmart
+
+ $ cd bftsmart
+
+ $ git checkout master
- // 通过OperationResult获取结果
- for (int i = 0; i < operationResults.length; i++) {
- OperationResult opResult = operationResults[i];
- System.out.printf("Operation[%s].result = %s \r\n",
- opResult.getIndex(), BytesValueEncoding.decode(opResult.getResult()));
- }
+ $ mvn install:install-file -Dfile=lib/core-0.1.4.jar -DgroupId=com.yahoo.ycsb -DartifactId=core -Dversion=0.1.4 -Dpackaging=jar
+
+ $ mvn clean install
+```
+- 编译 jdchain 工程;
+ - 当编译完成后,共识节点的安装包位于 "仓库根目录"/source/deployment/deployment-peer/target/jdchain-peer-1.0.1.RELEASE.zip
+ - 当编译完成后,网关节点的安装包位于 "仓库根目录"/source/deployment/deployment-gateway/target/jdchain-gateway-1.0.1.RELEASE.zip
-```
\ No newline at end of file
+```sh
+ $ git clone git@github.com:blockchain-jd-com/jdchain.git jdchain
+
+ $ cd jdchain/source
+
+ $ git checkout master
+
+ $ mvn clean package
+
+```
diff --git a/docs/design.md b/docs/design.md
new file mode 100644
index 00000000..7cea13d1
--- /dev/null
+++ b/docs/design.md
@@ -0,0 +1,630 @@
+[TOC]
+#JD区块链
+
+
+[![License](https://img.shields.io/badge/license-Apache%202-4EB1BA.svg)](https://www.apache.org/licenses/LICENSE-2.0.html)
+
+
+------------------------------------------------------------------------
+### 版本修订历史
+
+
+ 版本号 |
+ 作 者 |
+ 修改日期 |
+ 备 注 |
+
+
+ 0.0.6 |
+ 黄海泉 |
+ 2017-11-10 |
+
+ 定义JD区块链项目的目标与关键能力;
+ 定义JD区块链的核心对象模型;
+ 定义“账户”的生成算法和“区块/交易/操作/账户”的关键属性;
+ 描述了编程接口的示例代码;
+ |
+
+
+ 0.0.7 |
+ 黄海泉 |
+ 2017-11-17 |
+
+ 丰富了对“节点共识”、“节点分区”两项关键能力的详细描述;
+ |
+
+
+ 0.0.8 |
+ 黄海泉 |
+ 2018-07-17 |
+
+ 增加部署图;增加智能合约开发的示例;
+ |
+
+
+
+------------------------------------------------------------------------
+
+## 一、概述
+JD Chain 的目标是实现一个面向企业应用场景的通用区块链框架系统,能够作为企业级基础设施,为业务创新提供高效、灵活和安全的解决方案。
+
+区块链本质上是一种新的分布式架构,以密码学和分布式技术为核心,旨在实现无需借助“第三方” 就能在多个业务方之间进行安全、可信、直接的信息和价值交换。从点对点的信息和价值交换的角度看,区块链发挥了“协议”的作用。
+
+
+以下是 JD 区块链用以满足企业核心需求的关键能力,也是显著区别于其它区块链的重要特征:
+
+ - 快速共识
+ - 节点分区
+ - 并行多账本
+ - 大数据伸缩存储
+ - 条件检索
+ - 面向对象的合约代码编程模型
+ - 节点快速部署
+ - 多终端灵活接入
+ - 分布式自治的账户权限管理模型
+
+JD区块链对于关键能力的定义是建立在深入理解和抽象各种多样化需求的基础上的。
+
+ - 快速共识(Efficient Consensus)
+ 我们认为,“快速”不仅仅体现在“用更短时间”达成共识,还要体现在交易(Transaction)要得到可靠地执行。
+ 需要在算法和实现层面做出保障,确保所有提交的合法的交易会被系统在一个“确定性”和“足够短”的时间之内被严格地执行,系统不主动作出随机性地丢弃(不包括系统故障因素)。注:POW类算法产生的链分叉处理是一种系统随机性地丢弃交易的行为。
+ 从使用者的视角来看,这种能力就是区块链系统的“可靠性”,这对于企业、金融场景而言尤其重要。
+
+ - 节点分区(Peer Partition)
+ “分区”是一种分布式系统架构原则,通过将大范围目标按照某种相似特征分隔为一个个小范围目标,分别进行更高效地处理,这能从整体上提升整个系统的处理能力。
+ 区块链系统也是一种分布式系统,沿用“分区”的思想这点来自以往的系统架构实践的经验,是有可能让区块链系统获得可媲美现有系统的处理能力。这种能力将可以无障碍地把区块链在应用于广泛的企业场景中。
+ 在此,我们所说的“节点分区(Peer Partition)” 是共识过程中的物理通讯层面的分区,在共识过程中只有相关的物理节点才会建立通讯链路并复制和存储共识的状态数据。在一个区块链系统中,可以从节点全集中选择一个或多个节点子集,分别组成一个或多个节点分区(Peer Partition)
+
+ - 并行多账本
+ 账本(Ledger)
+ - 大数据伸缩存储
+ - 条件检索
+ - 面向对象的合约代码编程模型
+ - 节点快速部署
+ - 多终端灵活接入
+ - 分布式自治的账户权限管理模型
+
+## 二、对象模型
+JD区块链的核心对象包括:
+
+ - 账本(Ledger)
+ 一份账本(Ledger)实质上是由两部分组成:
+ - 一组以“账户(Account)”表示的状态数据;
+ - 以“区块的链条(Block-chain)”表示的状态数据的变更历史;
+
+ JD区块链的“账本(Ledger)”是一个最顶层的管理数据的逻辑单元。在一个区块链节点构成的共识网络中,可以维护多套并行的“账本(Ledger)”。
+
+ - 账户(Account)
+ - 在JD区块链中,账户(Account)被设计为包含“身份(Identity)”、“权限(Privilege)”、“状态(State)”、“控制规则(Control Rule)” 这4种属性的对象。
+ - 其中,“身份(Identity)”、“权限(Privilege)”这两种属性是一个面向应用的系统的基本功能;
+ - “状态(State)”、“控制规则(Control Rule)” 这两种属性这是一个具备“图灵完备性”的系统的基本属性,使系统可以处理任意多样化的任务;
+ - 在这里,“身份(Identity)”是一个抽象表述,其形式上就是一个“区块链地址(Address)”和相应的“非对称秘钥钥对(KeyPair)”/证书。 简单来说,一个“账户(Account)”就是一个区块链地址、公私钥对以及一套的权限配置.
+ - 一个“账户(Account)”的“状态(State)”、“控制规则(Control Rule)” 这2种属性则是可选的,这提供了不同于其它区块链的账户/合约的一种新的使用方式,即一种数据和逻辑分离的应用设计思路(这在传统的web应用编程中被称为“贫血模型”)。同时,也意味着一个特定“账户”中的数据状态是可以跨账户/合约代码进行共享访问的。
+ - 从应用的视角来看,对“账户”的使用方式可以有几种模式:
+ - 用于表示业务角色/用户:
+ - 用于表示业务数据:仅有“状态(State)”没有“控制规则(Control Rule)”的账户,可称为数据账户,就有些类似于关系数据库中的“表(Table)”的作用,不同业务类别的数据则使用不同的账户来管理。
+ - 用于表示业务逻辑:仅有“控制规则(Control Rule)”没有“状态(State)”的账户,即所谓的合约账户,可表示某种用于处理数据的通用逻辑,可被授权访问特定的数据账户。
+
+ - 区块(Block)
+ 在概念上,与通常所说的区块的概念是一致的。
+ 在实现上,一个区块的主要内容是包含了某一时刻提交的所有交易以及交易执行之后的状态数据的快照的hash,而不存储具体的交易操作和状态数据。
+
+ - 交易(Transaction)
+ 在概念上,与通常所说的Transaction的概念是一致的,表示一组需要原子执行的操作。
+
+ - 操作(Operation)
+ 操作是针对“账户(Account)”的“写”指令,包括以下几类:
+ - 注册账户
+ - 更新账户的状态数据
+ - 更新账户的合约代码定义
+ - 调用账户的合约代码
+
+ - 合约代码(Contract Code)
+ 合约代码是一段用于对“账户(Account)”的状态数据执行操作的代码程序。
+
+## 三、部署模型
+
+ 1. 总体部署
+![deployment architecture](docs/images/deployment.png)
+
+ 2. 系统组件
+ - 共识节点
+ - 复制节点
+ - SDK
+ - 网关
+ - 终端
+
+ 3. 配置和管理
+
+## 四、账本结构
+
+### 1. 账户生成算法
+
+ - 公私钥对
+ - 算法:默认ED25519 ,支持 SM2、CA;
+ - 公钥存储格式:版本 + 算法标识 + 公私钥原始内容 + 校验码
+ - 字符编码方式:Base64
+ - 地址
+ - 算法
+ - 给定公钥 P (或由私钥 R 算出公钥 P)
+ - 中间值 H1 = SHA256( P )
+ - 中间值 H2 = RIPEMD-160( H1 )
+ - 中间值 X = 版本 + 公钥算法标识 + H2
+ - 校验和 C = 前4字节( SHA256( SHA256( X )) )
+ - 地址 Address = Base58( X + C )
+
+### 2. 区块
+
+
+ 属性 |
+ 名称 |
+ 说明 |
+
+
+ BlockHash |
+ 当前区块 hash |
+ 对区块中除此之外的其它所有属性一起进行哈希运算生成 |
+
+
+ BlockVersion |
+ 区块版本 |
+ 表示区块-交易的属性结构的版本号; |
+
+
+ PreviousBlockHash |
+ 上一区块 hash |
+ |
+
+
+ BlockNumber |
+ 区块高度 |
+ 区块高度是一个区块在链中的序号; 创始区块的高度为 0,每个新区块的高度依次递增; |
+
+
+ AccountHash |
+ 账户树hash |
+ 账户的 Merkle Tree 根的 hash |
+
+
+ AccountCount |
+ 账户数量 |
+ 区块生成时账本中的全部账户的总数 |
+
+
+ TxTreeHash |
+ 交易树 hash |
+ 本区块的交易集合的 Merkle Tree 根的 hash |
+
+
+ TxCount |
+ 区块交易数量 |
+ 当前区块包含的交易的数量; |
+
+
+ TxTotalCount |
+ 账本交易总数 |
+ 截止到当前区块为止当前账本的所有交易的总数量; |
+
+
+ CloseTime |
+ 区块关闭时间 |
+ 生成当前区块时的区块链节点的网络时间; |
+
+
+
+### 3. 交易
+
+
+ 属性 |
+ 名称 |
+ 说明 |
+
+
+ Hash |
+ 当前交易 hash |
+ 对交易中除此之外的其它所有属性一起进行哈希运算生成 |
+
+
+ LedgerNumber |
+ 区块高度 |
+ 交易被包含的区块高度 |
+
+
+ BlobHash |
+ 交易数据块hash |
+ 交易的数据块是交易的原始数据,包含客户端提交的交易的全部操作及其参数;
+ 交易的参与者需要使用私钥对交易数据块进行签名; |
+
+
+ Operations |
+ 操作列表 |
+ 交易的操作列表; |
+
+
+ Sponsor |
+ 交易发起人 |
+ 交易发起人的账户地址; |
+
+
+ SequenceNumber |
+ 交易序号 |
+ 交易序号记录了一个特定的发起人的交易的顺序号,等同于该发起人历史上发起的交易的总数; |
+
+
+ Signatures |
+ 签名列表 |
+ 由交易发起人和其它参与者对交易数据块的签名的列表; |
+
+
+ Result |
+ 交易结果 |
+ 0 - 表示执行成功;非零表示执行失败; 注:最终的账本只包含成功的交易; |
+
+
+
+### 4. 操作
+
+
+ 属性 |
+ 名称 |
+ 说明 |
+
+
+ OpType |
+ 操作类型 |
+
+ 一级操作类型包括:注册账户、配置权限、写入键值数据、写入对象数据、定义合约代码、调用合约代码;
+ “键值数据写入”操作的子操作类型包括:填入键值、移除键、数值增加、数值减少;
+ “对象数据写入”操作的自操作类型包括:插入对象、更新对象、移除对象;
+ |
+
+
+ Args |
+ 参数列表 |
+ 与操作类型相对应的参数列表; |
+
+
+ SubOps |
+ 子操作列表 |
+ “子操作”是“操作”的递归定义,由“操作类型”来标识; |
+
+
+
+### 5. 账户
+
+
+ 属性 |
+ 名称 |
+ 说明 |
+
+
+ Address |
+ 地址 |
+ 账户的唯一标识 |
+
+
+ RegNumber |
+ 注册号 |
+ 账户被注册到区块链的区块高度; |
+
+
+ TxSquenceNumber |
+ 交易序列号 |
+ 由账户发起的交易的序列号,初始为 0,账户每发起一个交易则增加1; |
+
+
+ ModelVersion |
+ 账户模型版本 |
+ 表示构成一个账户结构的属性模型的程序版本号; |
+
+
+ Version |
+ 账户版本 |
+ 初始为 0,对账户的每一次变更(包括对权限设置、状态和合约代码的变更)都会使账户状态版本增加 1 ; 注:交易序号的改变不会导致账户版本的增加; |
+
+
+ PrivilegeHash |
+ 权限 hash |
+ 权限树的根hash; |
+
+
+ PrivilegeVersion |
+ 权限版本 |
+ 初始为 0, 每次对权限的变更都导致版本号加 1; |
+
+
+ StateType |
+ 状态类型 |
+ 账户的状态类型有3种:空类型(NIL);键值类型;对象类型; |
+
+
+ StateVersion |
+ 状态版本 |
+ 账户的状态类型有3种:空类型(NIL);键值类型;对象类型; |
+
+
+ StateHash |
+ 状态哈希 |
+ 数据状态的 merkle tree 的根hash; |
+
+
+ CodeHash |
+ 合约代码哈希 |
+ 由“账户地址+合约代码版本号+合约代码内容”生成的哈希; |
+
+
+ CodeVersion |
+ 代码版本 |
+ 初始为 0,每次对代码的变更都使版本加 1 ; |
+
+
+
+## 五、编程接口
+
+### 1. 服务连接
+
+
+```java
+ //创建服务代理
+ public static BlockchainKeyPair CLIENT_CERT = BlockchainKeyGenerator.getInstance().generate();
+ final String GATEWAY_IP = "127.0.0.1";
+ final int GATEWAY_PORT = 80;
+ final boolean SECURE = false;
+ GatewayServiceFactory serviceFactory = GatewayServiceFactory.connect(GATEWAY_IP, GATEWAY_PORT, SECURE,
+ CLIENT_CERT);
+ // 创建服务代理;
+ BlockchainService service = serviceFactory.getBlockchainService();
+```
+
+
+### 2. 用户注册
+
+
+```java
+ // 创建服务代理;
+ BlockchainService service = serviceFactory.getBlockchainService();
+ // 在本地定义注册账号的 TX;
+ TransactionTemplate txTemp = service.newTransaction(ledgerHash);
+ SignatureFunction signatureFunction = asymmetricCryptography.getSignatureFunction(CryptoAlgorithm.ED25519);
+ CryptoKeyPair cryptoKeyPair = signatureFunction.generateKeyPair();
+ BlockchainKeyPair user = new BlockchainKeyPair(cryptoKeyPair.getPubKey(), cryptoKeyPair.getPrivKey());
+
+ txTemp.users().register(user.getIdentity());
+
+ // TX 准备就绪;
+ PreparedTransaction prepTx = txTemp.prepare();
+ // 使用私钥进行签名;
+ CryptoKeyPair keyPair = getSponsorKey();
+ prepTx.sign(keyPair);
+
+ // 提交交易;
+ prepTx.commit();
+```
+
+
+### 3. 数据账户注册
+
+
+```java
+ // 创建服务代理;
+ BlockchainService service = serviceFactory.getBlockchainService();
+ // 在本地定义注册账号的 TX;
+ TransactionTemplate txTemp = service.newTransaction(ledgerHash);
+ SignatureFunction signatureFunction = asymmetricCryptography.getSignatureFunction(CryptoAlgorithm.ED25519);
+ CryptoKeyPair cryptoKeyPair = signatureFunction.generateKeyPair();
+ BlockchainKeyPair dataAccount = new BlockchainKeyPair(cryptoKeyPair.getPubKey(), cryptoKeyPair.getPrivKey());
+
+ txTemp.dataAccounts().register(dataAccount.getIdentity());
+
+ // TX 准备就绪;
+ PreparedTransaction prepTx = txTemp.prepare();
+ // 使用私钥进行签名;
+ CryptoKeyPair keyPair = getSponsorKey();
+ prepTx.sign(keyPair);
+
+ // 提交交易;
+ prepTx.commit();
+```
+
+### 4. 写入数据
+
+```java
+ // 创建服务代理;
+ BlockchainService service = serviceFactory.getBlockchainService();
+
+ HashDigest ledgerHash = getLedgerHash();
+ // 在本地定义注册账号的 TX;
+ TransactionTemplate txTemp = service.newTransaction(ledgerHash);
+
+ // --------------------------------------
+ // 将商品信息写入到指定的账户中;
+ // 对象将被序列化为 JSON 形式存储,并基于 JSON 结构建立查询索引;
+ String commodityDataAccount = "GGhhreGeasdfasfUUfehf9932lkae99ds66jf==";
+ Commodity commodity1 = new Commodity();
+ txTemp.dataAccount(commodityDataAccount).set("ASSET_CODE", commodity1.getCode().getBytes(), -1);
+
+ // TX 准备就绪;
+ PreparedTransaction prepTx = txTemp.prepare();
+
+ String txHash = ByteArray.toBase64(prepTx.getHash().toBytes());
+ // 使用私钥进行签名;
+ CryptoKeyPair keyPair = getSponsorKey();
+ prepTx.sign(keyPair);
+
+ // 提交交易;
+ prepTx.commit();
+```
+
+
+### 5. 查询数据
+
+> 注:详细的查询可参考模块sdk-samples中SDK_GateWay_Query_Test_相关测试用例
+
+```java
+ // 创建服务代理;
+ BlockchainService service = serviceFactory.getBlockchainService();
+
+ // 查询区块信息;
+ // 区块高度;
+ long ledgerNumber = service.getLedger(LEDGER_HASH).getLatestBlockHeight();
+ // 最新区块;
+ LedgerBlock latestBlock = service.getBlock(LEDGER_HASH, ledgerNumber);
+ // 区块中的交易的数量;
+ long txCount = service.getTransactionCount(LEDGER_HASH, latestBlock.getHash());
+ // 获取交易列表;
+ LedgerTransaction[] txList = service.getTransactions(LEDGER_HASH, ledgerNumber, 0, 100);
+ // 遍历交易列表
+ for (LedgerTransaction ledgerTransaction : txList) {
+ TransactionContent txContent = ledgerTransaction.getTransactionContent();
+ Operation[] operations = txContent.getOperations();
+ if (operations != null && operations.length > 0) {
+ for (Operation operation : operations) {
+ operation = ClientOperationUtil.read(operation);
+ // 操作类型:数据账户注册操作
+ if (operation instanceof DataAccountRegisterOperation) {
+ DataAccountRegisterOperation daro = (DataAccountRegisterOperation) operation;
+ BlockchainIdentity blockchainIdentity = daro.getAccountID();
+ }
+ // 操作类型:用户注册操作
+ else if (operation instanceof UserRegisterOperation) {
+ UserRegisterOperation uro = (UserRegisterOperation) operation;
+ BlockchainIdentity blockchainIdentity = uro.getUserID();
+ }
+ // 操作类型:账本注册操作
+ else if (operation instanceof LedgerInitOperation) {
+
+ LedgerInitOperation ledgerInitOperation = (LedgerInitOperation)operation;
+ LedgerInitSetting ledgerInitSetting = ledgerInitOperation.getInitSetting();
+
+ ParticipantNode[] participantNodes = ledgerInitSetting.getConsensusParticipants();
+ }
+ // 操作类型:合约发布操作
+ else if (operation instanceof ContractCodeDeployOperation) {
+ ContractCodeDeployOperation ccdo = (ContractCodeDeployOperation) operation;
+ BlockchainIdentity blockchainIdentity = ccdo.getContractID();
+ }
+ // 操作类型:合约执行操作
+ else if (operation instanceof ContractEventSendOperation) {
+ ContractEventSendOperation ceso = (ContractEventSendOperation) operation;
+ }
+ // 操作类型:KV存储操作
+ else if (operation instanceof DataAccountKVSetOperation) {
+ DataAccountKVSetOperation.KVWriteEntry[] kvWriteEntries =
+ ((DataAccountKVSetOperation) operation).getWriteSet();
+ if (kvWriteEntries != null && kvWriteEntries.length > 0) {
+ for (DataAccountKVSetOperation.KVWriteEntry kvWriteEntry : kvWriteEntries) {
+ BytesValue bytesValue = kvWriteEntry.getValue();
+ DataType dataType = bytesValue.getType();
+ Object showVal = ClientOperationUtil.readValueByBytesValue(bytesValue);
+ System.out.println("writeSet.key=" + kvWriteEntry.getKey());
+ System.out.println("writeSet.value=" + showVal);
+ System.out.println("writeSet.type=" + dataType);
+ System.out.println("writeSet.version=" + kvWriteEntry.getExpectedVersion());
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // 根据交易的 hash 获得交易;注:客户端生成 PrepareTransaction 时得到交易hash;
+ HashDigest txHash = txList[0].getTransactionContent().getHash();
+ Transaction tx = service.getTransactionByContentHash(LEDGER_HASH, txHash);
+ // 获取数据;
+ String commerceAccount = "GGhhreGeasdfasfUUfehf9932lkae99ds66jf==";
+ String[] objKeys = new String[] { "x001", "x002" };
+ KVDataEntry[] kvData = service.getDataEntries(LEDGER_HASH, commerceAccount, objKeys);
+
+ long payloadVersion = kvData[0].getVersion();
+
+ // 获取数据账户下所有的KV列表
+ KVDataEntry[] kvData = service.getDataEntries(ledgerHash, commerceAccount, 0, 100);
+ if (kvData != null && kvData.length > 0) {
+ for (KVDataEntry kvDatum : kvData) {
+ System.out.println("kvData.key=" + kvDatum.getKey());
+ System.out.println("kvData.version=" + kvDatum.getVersion());
+ System.out.println("kvData.type=" + kvDatum.getType());
+ System.out.println("kvData.value=" + kvDatum.getValue());
+ }
+ }
+```
+
+
+### 6. 合约发布
+
+
+```java
+
+ // 创建服务代理;
+ BlockchainService service = serviceFactory.getBlockchainService();
+
+ // 在本地定义TX模板
+ TransactionTemplate txTemp = service.newTransaction(ledgerHash);
+
+ // 合约内容读取
+ byte[] contractBytes = FileUtils.readBytes(new File(CONTRACT_FILE));
+
+ // 生成用户
+ BlockchainIdentityData blockchainIdentity = new BlockchainIdentityData(getSponsorKey().getPubKey());
+
+ // 发布合约
+ txTemp.contracts().deploy(blockchainIdentity, contractBytes);
+
+ // TX 准备就绪;
+ PreparedTransaction prepTx = txTemp.prepare();
+
+ // 使用私钥进行签名;
+ CryptoKeyPair keyPair = getSponsorKey();
+
+ prepTx.sign(keyPair);
+
+ // 提交交易;
+ TransactionResponse transactionResponse = prepTx.commit();
+
+ assertTrue(transactionResponse.isSuccess());
+
+ // 打印合约地址
+ System.out.println(blockchainIdentity.getAddress().toBase58());
+
+```
+
+### 7. 合约执行
+
+```java
+
+ // 创建服务代理;
+ BlockchainService service = serviceFactory.getBlockchainService();
+
+ // 在本地定义TX模板
+ TransactionTemplate txTemp = service.newTransaction(ledgerHash);
+
+ // 合约地址
+ String contractAddressBase58 = "";
+
+ // 使用接口方式调用合约
+ TransferContract transferContract = txTpl.contract(contractAddress, TransferContract.class);
+
+ // 使用decode方式调用合约内部方法(create方法)
+ // 返回GenericValueHolder可通过get方法获取结果,但get方法需要在commit调用后执行
+ GenericValueHolder result = ContractReturnValue.decode(transferContract.create(address, account, money));
+
+ PreparedTransaction ptx = txTpl.prepare();
+
+ ptx.sign(adminKey);
+
+ TransactionResponse transactionResponse = ptx.commit();
+
+ String cotractExecResult = result.get();
+
+ // TransactionResponse也提供了可供查询结果的接口
+ OperationResult[] operationResults = transactionResponse.getOperationResults();
+
+ // 通过OperationResult获取结果
+ for (int i = 0; i < operationResults.length; i++) {
+ OperationResult opResult = operationResults[i];
+ System.out.printf("Operation[%s].result = %s \r\n",
+ opResult.getIndex(), BytesValueEncoding.decode(opResult.getResult()));
+ }
+
+
+```
\ No newline at end of file
diff --git a/docs/images/deployment.jpg b/docs/images/deployment.jpg
new file mode 100644
index 00000000..aec66f03
Binary files /dev/null and b/docs/images/deployment.jpg differ
diff --git a/source/base/src/main/java/com/jd/blockchain/consts/DataCodes.java b/source/base/src/main/java/com/jd/blockchain/consts/DataCodes.java
index d1487f73..7358ba4e 100644
--- a/source/base/src/main/java/com/jd/blockchain/consts/DataCodes.java
+++ b/source/base/src/main/java/com/jd/blockchain/consts/DataCodes.java
@@ -168,4 +168,5 @@ public interface DataCodes {
public static final int CONSENSUS_MSGQUEUE_BLOCK_SETTINGS = CONSENSUS_MSGQUEUE | 0x05;
+
}
diff --git a/source/base/src/main/java/com/jd/blockchain/consts/Global.java b/source/base/src/main/java/com/jd/blockchain/consts/Global.java
new file mode 100644
index 00000000..b508e833
--- /dev/null
+++ b/source/base/src/main/java/com/jd/blockchain/consts/Global.java
@@ -0,0 +1,19 @@
+package com.jd.blockchain.consts;
+
+import java.util.TimeZone;
+
+public class Global {
+
+ public static final String DEFAULT_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss.SSSZ";
+
+ public static final String DEFAULT_TIME_ZONE = "GMT+08:00";
+
+ static {
+ initialize();
+ }
+
+ public static void initialize() {
+ TimeZone.setDefault(TimeZone.getTimeZone(DEFAULT_TIME_ZONE));
+ }
+
+}
diff --git a/source/base/src/main/resources/log4j2.xml b/source/base/src/main/resources/log4j2.xml
deleted file mode 100644
index 26f090d7..00000000
--- a/source/base/src/main/resources/log4j2.xml
+++ /dev/null
@@ -1,74 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/source/crypto/crypto-composite/src/test/java/com/jd/blockchain/AppTest.java b/source/crypto/crypto-composite/src/test/java/com/jd/blockchain/AppTest.java
new file mode 100644
index 00000000..941b907f
--- /dev/null
+++ b/source/crypto/crypto-composite/src/test/java/com/jd/blockchain/AppTest.java
@@ -0,0 +1,20 @@
+package com.jd.blockchain;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/**
+ * Unit test for simple App.
+ */
+public class AppTest
+{
+ /**
+ * Rigorous Test :-)
+ */
+ @Test
+ public void shouldAnswerWithTrue()
+ {
+ assertTrue( true );
+ }
+}
diff --git a/source/deployment/deployment-autotest/src/test/java/com/jd/blockchain/AppTest.java b/source/deployment/deployment-autotest/src/test/java/com/jd/blockchain/AppTest.java
new file mode 100644
index 00000000..941b907f
--- /dev/null
+++ b/source/deployment/deployment-autotest/src/test/java/com/jd/blockchain/AppTest.java
@@ -0,0 +1,20 @@
+package com.jd.blockchain;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/**
+ * Unit test for simple App.
+ */
+public class AppTest
+{
+ /**
+ * Rigorous Test :-)
+ */
+ @Test
+ public void shouldAnswerWithTrue()
+ {
+ assertTrue( true );
+ }
+}
diff --git a/source/deployment/deployment-gateway/src/main/resources/scripts/startup.sh b/source/deployment/deployment-gateway/src/main/resources/scripts/startup.sh
index db75a6ad..44a1a528 100644
--- a/source/deployment/deployment-gateway/src/main/resources/scripts/startup.sh
+++ b/source/deployment/deployment-gateway/src/main/resources/scripts/startup.sh
@@ -5,5 +5,5 @@ GATEWAY=$(ls $HOME/lib | grep deployment-gateway-)
if [ ! -n "$GATEWAY" ]; then
echo "GateWay Is Null !!!"
else
- nohup java -jar -server $HOME/lib/$GATEWAY -c $HOME/config/gateway.conf $* > gw.out 2>&1 &
+ nohup java -jar -server -Dgateway.log=$HOME $HOME/lib/$GATEWAY -c $HOME/config/gateway.conf $* >$HOME/bin/gw.out 2>&1 &
fi
\ No newline at end of file
diff --git a/source/deployment/deployment-peer/pom.xml b/source/deployment/deployment-peer/pom.xml
index f9c3e56f..7d94202b 100644
--- a/source/deployment/deployment-peer/pom.xml
+++ b/source/deployment/deployment-peer/pom.xml
@@ -25,7 +25,11 @@
runtime-modular-booter
${project.version}
-
+
com.jd.blockchain
storage-composite
diff --git a/source/deployment/deployment-peer/src/main/resources/assembly.xml b/source/deployment/deployment-peer/src/main/resources/assembly.xml
index 5e64c93e..0fc4ddf5 100644
--- a/source/deployment/deployment-peer/src/main/resources/assembly.xml
+++ b/source/deployment/deployment-peer/src/main/resources/assembly.xml
@@ -55,6 +55,16 @@
com.jd.blockchain:deployment-peer
+
+
+
diff --git a/source/deployment/deployment-peer/src/main/resources/docs/安装部署.MD b/source/deployment/deployment-peer/src/main/resources/docs/安装部署.MD
index 75cd0502..573d4e48 100644
--- a/source/deployment/deployment-peer/src/main/resources/docs/安装部署.MD
+++ b/source/deployment/deployment-peer/src/main/resources/docs/安装部署.MD
@@ -78,7 +78,7 @@ Peer打包程序解压完后的安装包结构如下:
其中目录说明如下:
+ **bin** :相关命令操作目录;
- + **config** :对应命令的配置目录,keys路径默认可能不存在,会在执行相关脚本时自动创建;
+ + **config** :对应命令的配置目录,keys路径解压时不存在,会在执行keygen.sh脚本时自动创建;ledger-binding.conf文件解压时不存在,会在成功执行ledger-init.sh脚本后生成;
+ **docs** :相关文档保存目录;
+ **libs** :项目运行依赖第三方及非system依赖包保存路径;
+ **system** :项目运行系统包保存路径;
diff --git a/source/deployment/deployment-peer/src/main/resources/scripts/jump-start.sh b/source/deployment/deployment-peer/src/main/resources/scripts/jump-start.sh
new file mode 100644
index 00000000..6c1f44af
--- /dev/null
+++ b/source/deployment/deployment-peer/src/main/resources/scripts/jump-start.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+HOME=$(cd `dirname $0`;cd ../; pwd)
+UMP=$(ls $HOME/ext | grep ump-booter-)
+if [ ! -n "UMP" ]; then
+ echo "Unified Management Platform Is Null !!!"
+else
+ nohup java -jar -server -Djump.log=$HOME $HOME/ext/$UMP -p 8000 $* >$HOME/bin/jump.out 2>&1 &
+fi
\ No newline at end of file
diff --git a/source/deployment/deployment-peer/src/main/resources/scripts/jump-stop.sh b/source/deployment/deployment-peer/src/main/resources/scripts/jump-stop.sh
new file mode 100644
index 00000000..b7155c88
--- /dev/null
+++ b/source/deployment/deployment-peer/src/main/resources/scripts/jump-stop.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+
+#启动Home路径
+BOOT_HOME=$(cd `dirname $0`;cd ../; pwd)
+
+#获取进程PID
+PID=`ps -ef | grep $BOOT_HOME/ext/ump-booter | grep -v grep | awk '{print $2}'`
+
+#通过Kill命令将进程杀死
+if [ -z "$PID" ]; then
+ echo "Unable to find UMP PID. stop aborted."
+else
+ echo "Start to kill PID = $PID ..."
+ kill -9 $PID
+ echo "Unified Management Platform has been stopped ..."
+fi
\ No newline at end of file
diff --git a/source/deployment/deployment-peer/src/main/resources/scripts/ledger-init.sh b/source/deployment/deployment-peer/src/main/resources/scripts/ledger-init.sh
index c9f3db47..660676e8 100644
--- a/source/deployment/deployment-peer/src/main/resources/scripts/ledger-init.sh
+++ b/source/deployment/deployment-peer/src/main/resources/scripts/ledger-init.sh
@@ -1,9 +1,9 @@
#!/bin/bash
HOME=$(cd `dirname $0`;cd ../; pwd)
-boot_file=$(ls ../libs | grep tools-initializer-booter-)
+boot_file=$(ls $HOME/libs | grep tools-initializer-booter-)
if [ ! -n "$boot_file" ]; then
echo "tools-initializer-booter is null"
else
- java -jar $HOME/libs/$boot_file -l $HOME/config/init/local.conf -i $HOME/config/init/ledger.init $*
-fi
+ java -jar -server -Dinit.log=$HOME $HOME/libs/$boot_file -l $HOME/config/init/local.conf -i $HOME/config/init/ledger.init $*
+fi
\ No newline at end of file
diff --git a/source/deployment/deployment-peer/src/main/resources/scripts/startup.sh b/source/deployment/deployment-peer/src/main/resources/scripts/startup.sh
index 371b8d78..d0fdd3d5 100644
--- a/source/deployment/deployment-peer/src/main/resources/scripts/startup.sh
+++ b/source/deployment/deployment-peer/src/main/resources/scripts/startup.sh
@@ -5,5 +5,5 @@ PEER=$(ls $HOME/system | grep deployment-peer-)
if [ ! -n "$PEER" ]; then
echo "Peer Is Null !!!"
else
- nohup java -jar -server -Xmx2g -Xms2g $HOME/system/$PEER -home=$HOME -c $HOME/config/ledger-binding.conf -p 7080 $* &
+ nohup java -jar -server -Xmx2g -Xms2g -Dpeer.log=$HOME $HOME/system/$PEER -home=$HOME -c $HOME/config/ledger-binding.conf -p 7080 $* >$HOME/bin/peer.out 2>&1 &
fi
\ No newline at end of file
diff --git a/source/gateway/src/main/resources/log4j2.xml b/source/gateway/src/main/resources/log4j2.xml
index d81fe1dc..6b49c3e9 100644
--- a/source/gateway/src/main/resources/log4j2.xml
+++ b/source/gateway/src/main/resources/log4j2.xml
@@ -13,12 +13,12 @@
-
+
-
+
@@ -27,8 +27,8 @@
-
+
@@ -38,8 +38,8 @@
-
+
@@ -51,7 +51,7 @@
-
+
diff --git a/source/ledger/ledger-model/src/main/java/com/jd/blockchain/ledger/KVDataObject.java b/source/ledger/ledger-model/src/main/java/com/jd/blockchain/ledger/KVDataObject.java
index 2769631c..1e8247ee 100644
--- a/source/ledger/ledger-model/src/main/java/com/jd/blockchain/ledger/KVDataObject.java
+++ b/source/ledger/ledger-model/src/main/java/com/jd/blockchain/ledger/KVDataObject.java
@@ -79,6 +79,8 @@ public class KVDataObject implements KVDataEntry {
return BytesUtils.toLong(bytesValue.getValue().toBytes());
case JSON:
return bytesValue.getValue().toUTF8String();
+ case XML:
+ return bytesValue.getValue().toUTF8String();
default:
throw new IllegalStateException("Unsupported value type[" + getType() + "] to resolve!");
diff --git a/source/manager/pom.xml b/source/manager/pom.xml
new file mode 100644
index 00000000..9972ceaf
--- /dev/null
+++ b/source/manager/pom.xml
@@ -0,0 +1,18 @@
+
+ 4.0.0
+
+
+ com.jd.blockchain
+ jdchain-root
+ 1.1.0-SNAPSHOT
+
+ manager
+ pom
+
\ No newline at end of file
diff --git a/source/manager/ump-booter/pom.xml b/source/manager/ump-booter/pom.xml
new file mode 100644
index 00000000..392cb3b9
--- /dev/null
+++ b/source/manager/ump-booter/pom.xml
@@ -0,0 +1,132 @@
+
+
+
+
+ manager
+ com.jd.blockchain
+ 1.1.0-SNAPSHOT
+
+ 4.0.0
+
+ ump-booter
+
+ ump-booter
+
+
+ UTF-8
+ 1.8
+ 1.8
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-web
+
+
+ org.springframework.boot
+ spring-boot-starter-logging
+
+
+
+
+
+ com.jd.blockchain
+ ump-web
+ ${project.version}
+
+
+
+ com.jd.blockchain
+ ump-service
+ ${project.version}
+
+
+
+ com.jd.blockchain
+ ump-model
+ ${project.version}
+
+
+
+ com.jd.blockchain
+ ump-explorer
+
+
+
+ org.springframework.boot
+ spring-boot-starter-log4j2
+
+
+
+ org.springframework.boot
+ spring-boot-starter-security
+
+
+ org.springframework.boot
+ spring-boot-configuration-processor
+ true
+
+
+ org.springframework.boot
+ spring-boot-devtools
+ true
+
+
+ junit
+ junit
+ test
+
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+
+
+
+ org.apache.maven.plugins
+ maven-assembly-plugin
+
+
+ make-assembly
+ package
+
+ single
+
+
+ jump
+
+ src/main/resources/assembly.xml
+
+
+
+
+
+
+
+
+
+ ${project.basedir}/libs
+ BOOT-INF/lib/
+
+ *.jar
+
+
+
+ ${project.basedir}/src/main/resources
+ BOOT-INF/classes/
+
+ log4j2-jump.xml
+ *.txt
+ *.properties
+
+
+
+
+
+
diff --git a/source/manager/ump-booter/src/main/java/com/jd/blockchain/ump/UmpBooter.java b/source/manager/ump-booter/src/main/java/com/jd/blockchain/ump/UmpBooter.java
new file mode 100644
index 00000000..4bf8d7ae
--- /dev/null
+++ b/source/manager/ump-booter/src/main/java/com/jd/blockchain/ump/UmpBooter.java
@@ -0,0 +1,128 @@
+package com.jd.blockchain.ump;
+
+import org.springframework.boot.SpringApplication;
+
+import java.io.File;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+
+
+public class UmpBooter {
+
+ private static final String ARG_PORT = "-p";
+
+ private static final String ARG_HOST = "-h";
+
+ private static final String CONFIG = "BOOT-INF" + File.separator + "classes" + File.separator + "config.properties";
+
+ private static final String CONFIG_PROP_HOST = "server.host";
+
+ private static final String CONFIG_PROP_HOST_DEFAULT = "0.0.0.0";
+
+ private static final String CONFIG_PROP_PORT = "server.port";
+
+ private static final String CONFIG_PROP_PORT_DEFAULT = "8080";
+
+ private static final String CONFIG_PROP_DB_URL = "db.url";
+
+ private static final String CONFIG_PROP_DB_URL_DEFAULT = "rocksdb://#project#/jumpdb";
+
+ public static void main(String[] args) {
+ startServer(server(args));
+ System.out.println("Unified Management Platform Server Start SUCCESS !!!");
+ }
+
+ private static void startServer(Server server) {
+
+ List argList = new ArrayList<>();
+ argList.add(String.format("--server.address=%s", server.host));
+ argList.add(String.format("--server.port=%s", server.port));
+ argList.add(String.format("--db.url=%s", server.dbUrl));
+
+ String[] args = argList.toArray(new String[argList.size()]);
+
+ // 启动服务器;
+ SpringApplication.run(UmpConfiguration.class, args);
+ }
+
+ private static Server server(String[] args) {
+ Server defaultServer = serverFromConfig();
+ if (args == null || args.length == 0) {
+ return defaultServer;
+ }
+ String host = null;
+
+ int port = 0;
+
+ // 读取参数列表
+ for (int i = 0; i < args.length; i++) {
+ String arg = args[i];
+ if (arg.equals(ARG_HOST)) {
+ host = args[i + 1];
+ } else if (arg.equals(ARG_PORT)) {
+ port = Integer.parseInt(args[i + 1]);
+ }
+ }
+
+ // 参数列表中的数据不完整,则剩余部分数据从配置文件中获取
+ if (host == null) {
+ host = defaultServer.host;
+ }
+ if (port == 0) {
+ port = defaultServer.port;
+ }
+
+ return new Server(host, port, defaultServer.dbUrl);
+ }
+
+ private static Server serverFromConfig() {
+ try {
+ InputStream inputStream = UmpBooter.class.getResourceAsStream(File.separator + CONFIG);
+ if (inputStream == null) {
+ System.err.println("InputStream is NULL !!!");
+ }
+ Properties props = new Properties();
+ props.load(inputStream);
+ String host = props.getProperty(CONFIG_PROP_HOST, CONFIG_PROP_HOST_DEFAULT);
+ int port = Integer.parseInt(
+ props.getProperty(CONFIG_PROP_PORT, CONFIG_PROP_PORT_DEFAULT));
+ String dbUrl = props.getProperty(CONFIG_PROP_DB_URL, CONFIG_PROP_DB_URL_DEFAULT);
+ return new Server(host, port, dbUrl);
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ private static class Server {
+
+ private String host;
+
+ private int port;
+
+ private String dbUrl;
+
+ public Server(String host, int port, String dbUrl) {
+ this.host = host;
+ this.port = port;
+ this.dbUrl = dbUrl;
+ }
+
+ public String getHost() {
+ return host;
+ }
+
+ public void setHost(String host) {
+ this.host = host;
+ }
+
+ public int getPort() {
+ return port;
+ }
+
+ public void setPort(int port) {
+ this.port = port;
+ }
+ }
+}
diff --git a/source/manager/ump-booter/src/main/java/com/jd/blockchain/ump/UmpConfiguration.java b/source/manager/ump-booter/src/main/java/com/jd/blockchain/ump/UmpConfiguration.java
new file mode 100644
index 00000000..f1e86f12
--- /dev/null
+++ b/source/manager/ump-booter/src/main/java/com/jd/blockchain/ump/UmpConfiguration.java
@@ -0,0 +1,12 @@
+package com.jd.blockchain.ump;
+
+
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+
+@EnableConfigurationProperties
+@SpringBootApplication(exclude = {
+ org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration.class}
+ )
+public class UmpConfiguration {
+}
diff --git a/source/manager/ump-booter/src/main/resources/application.properties b/source/manager/ump-booter/src/main/resources/application.properties
new file mode 100644
index 00000000..b5ef6943
--- /dev/null
+++ b/source/manager/ump-booter/src/main/resources/application.properties
@@ -0,0 +1,5 @@
+server.tomcat.uri-encoding=utf-8
+
+spring.mvc.favicon.enabled=false
+
+logging.config=classpath:log4j2-jump.xml
\ No newline at end of file
diff --git a/source/manager/ump-booter/src/main/resources/assembly.xml b/source/manager/ump-booter/src/main/resources/assembly.xml
new file mode 100644
index 00000000..8fd114ba
--- /dev/null
+++ b/source/manager/ump-booter/src/main/resources/assembly.xml
@@ -0,0 +1,27 @@
+
+
+ ${project.version}
+
+ zip
+
+ false
+
+
+ src/main/resources/scripts
+ bin
+
+
+
+
+ false
+ true
+ ext
+
+ com.jd.blockchain:ump-booter
+
+
+
+
\ No newline at end of file
diff --git a/source/manager/ump-booter/src/main/resources/banner.txt b/source/manager/ump-booter/src/main/resources/banner.txt
new file mode 100644
index 00000000..c39618bd
--- /dev/null
+++ b/source/manager/ump-booter/src/main/resources/banner.txt
@@ -0,0 +1,13 @@
+
+ ▄▄▄▄▄▄▄▄▄▄▄ ▄▄▄▄▄▄▄▄▄▄ ▄▄▄▄▄▄▄▄▄▄ ▄ ▄▄▄▄▄▄▄▄▄▄▄ ▄▄▄▄▄▄▄▄▄▄▄ ▄ ▄ ▄▄▄▄▄▄▄▄▄▄▄ ▄ ▄ ▄▄▄▄▄▄▄▄▄▄▄ ▄▄▄▄▄▄▄▄▄▄▄ ▄▄ ▄
+▐░░░░░░░░░░░▌▐░░░░░░░░░░▌ ▐░░░░░░░░░░▌ ▐░▌ ▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░▌ ▐░▌ ▐░░░░░░░░░░░▌▐░▌ ▐░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░░▌ ▐░▌
+ ▀▀▀▀▀█░█▀▀▀ ▐░█▀▀▀▀▀▀▀█░▌ ▐░█▀▀▀▀▀▀▀█░▌▐░▌ ▐░█▀▀▀▀▀▀▀█░▌▐░█▀▀▀▀▀▀▀▀▀ ▐░▌ ▐░▌ ▐░█▀▀▀▀▀▀▀▀▀ ▐░▌ ▐░▌▐░█▀▀▀▀▀▀▀█░▌ ▀▀▀▀█░█▀▀▀▀ ▐░▌░▌ ▐░▌
+ ▐░▌ ▐░▌ ▐░▌ ▐░▌ ▐░▌▐░▌ ▐░▌ ▐░▌▐░▌ ▐░▌▐░▌ ▐░▌ ▐░▌ ▐░▌▐░▌ ▐░▌ ▐░▌ ▐░▌▐░▌ ▐░▌
+ ▐░▌ ▐░▌ ▐░▌ ▐░█▄▄▄▄▄▄▄█░▌▐░▌ ▐░▌ ▐░▌▐░▌ ▐░▌░▌ ▐░▌ ▐░█▄▄▄▄▄▄▄█░▌▐░█▄▄▄▄▄▄▄█░▌ ▐░▌ ▐░▌ ▐░▌ ▐░▌
+ ▐░▌ ▐░▌ ▐░▌ ▐░░░░░░░░░░▌ ▐░▌ ▐░▌ ▐░▌▐░▌ ▐░░▌ ▐░▌ ▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌ ▐░▌ ▐░▌ ▐░▌ ▐░▌
+ ▐░▌ ▐░▌ ▐░▌ ▐░█▀▀▀▀▀▀▀█░▌▐░▌ ▐░▌ ▐░▌▐░▌ ▐░▌░▌ ▐░▌ ▐░█▀▀▀▀▀▀▀█░▌▐░█▀▀▀▀▀▀▀█░▌ ▐░▌ ▐░▌ ▐░▌ ▐░▌
+ ▐░▌ ▐░▌ ▐░▌ ▐░▌ ▐░▌▐░▌ ▐░▌ ▐░▌▐░▌ ▐░▌▐░▌ ▐░▌ ▐░▌ ▐░▌▐░▌ ▐░▌ ▐░▌ ▐░▌ ▐░▌▐░▌
+ ▄▄▄▄▄█░▌ ▐░█▄▄▄▄▄▄▄█░▌ ▐░█▄▄▄▄▄▄▄█░▌▐░█▄▄▄▄▄▄▄▄▄ ▐░█▄▄▄▄▄▄▄█░▌▐░█▄▄▄▄▄▄▄▄▄ ▐░▌ ▐░▌ ▐░█▄▄▄▄▄▄▄▄▄ ▐░▌ ▐░▌▐░▌ ▐░▌ ▄▄▄▄█░█▄▄▄▄ ▐░▌ ▐░▐░▌
+▐░░░░░░░▌ ▐░░░░░░░░░░▌ ▐░░░░░░░░░░▌ ▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░▌ ▐░▌ ▐░░░░░░░░░░░▌▐░▌ ▐░▌▐░▌ ▐░▌▐░░░░░░░░░░░▌▐░▌ ▐░░▌
+ ▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀ ▀ ▀ ▀▀▀▀▀▀▀▀▀▀▀ ▀ ▀ ▀ ▀ ▀▀▀▀▀▀▀▀▀▀▀ ▀ ▀▀
+
diff --git a/source/manager/ump-booter/src/main/resources/config.properties b/source/manager/ump-booter/src/main/resources/config.properties
new file mode 100644
index 00000000..deaf015e
--- /dev/null
+++ b/source/manager/ump-booter/src/main/resources/config.properties
@@ -0,0 +1,8 @@
+# Tomcat启动的HOST,默认为0.0.0.0
+server.host=0.0.0.0
+
+# Tomcat启动监听端口号
+server.port=8080
+
+# 本地数据库存储位置
+db.url=rocksdb://#project#/jumpdb
\ No newline at end of file
diff --git a/source/manager/ump-booter/src/main/resources/log4j2-jump.xml b/source/manager/ump-booter/src/main/resources/log4j2-jump.xml
new file mode 100644
index 00000000..6b19f527
--- /dev/null
+++ b/source/manager/ump-booter/src/main/resources/log4j2-jump.xml
@@ -0,0 +1,46 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/source/manager/ump-booter/src/main/resources/scripts/jump-start.sh b/source/manager/ump-booter/src/main/resources/scripts/jump-start.sh
new file mode 100644
index 00000000..a31a5b28
--- /dev/null
+++ b/source/manager/ump-booter/src/main/resources/scripts/jump-start.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+HOME=$(cd `dirname $0`;cd ../; pwd)
+UMP=$(ls $HOME/ext | grep ump-booter-)
+if [ ! -n "UMP" ]; then
+ echo "Unified Management Platform Is Null !!!"
+else
+ nohup java -jar -server -Djump.log=$HOME $HOME/ext/$UMP $* >$HOME/bin/jump.out 2>&1 &
+fi
\ No newline at end of file
diff --git a/source/manager/ump-booter/src/main/resources/scripts/jump-stop.sh b/source/manager/ump-booter/src/main/resources/scripts/jump-stop.sh
new file mode 100644
index 00000000..b7155c88
--- /dev/null
+++ b/source/manager/ump-booter/src/main/resources/scripts/jump-stop.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+
+#启动Home路径
+BOOT_HOME=$(cd `dirname $0`;cd ../; pwd)
+
+#获取进程PID
+PID=`ps -ef | grep $BOOT_HOME/ext/ump-booter | grep -v grep | awk '{print $2}'`
+
+#通过Kill命令将进程杀死
+if [ -z "$PID" ]; then
+ echo "Unable to find UMP PID. stop aborted."
+else
+ echo "Start to kill PID = $PID ..."
+ kill -9 $PID
+ echo "Unified Management Platform has been stopped ..."
+fi
\ No newline at end of file
diff --git a/source/manager/ump-model/pom.xml b/source/manager/ump-model/pom.xml
new file mode 100644
index 00000000..67436cc0
--- /dev/null
+++ b/source/manager/ump-model/pom.xml
@@ -0,0 +1,81 @@
+
+
+
+
+ manager
+ com.jd.blockchain
+ 1.1.0-SNAPSHOT
+
+ 4.0.0
+
+ ump-model
+
+ ump-model
+
+
+ UTF-8
+ 1.8
+ 1.8
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-web
+
+
+ org.springframework.boot
+ spring-boot-starter-logging
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-log4j2
+
+
+
+ org.springframework.boot
+ spring-boot-starter-security
+
+
+ org.springframework.boot
+ spring-boot-configuration-processor
+ true
+
+
+ org.springframework.boot
+ spring-boot-devtools
+ true
+
+
+
+ com.alibaba
+ fastjson
+
+
+
+ org.reflections
+ reflections
+
+
+
+ org.rocksdb
+ rocksdbjni
+
+
+
+ commons-io
+ commons-io
+
+
+
+ junit
+ junit
+ test
+
+
+
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/DBConnection.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/DBConnection.java
new file mode 100644
index 00000000..eea65d3f
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/DBConnection.java
@@ -0,0 +1,16 @@
+package com.jd.blockchain.ump.dao;
+
+public interface DBConnection {
+
+ String dbSchema();
+
+ DBConnection initDbUrl(String dbUrl);
+
+ void put(String key, String value);
+
+ void put(String key, Object value, Class> type);
+
+ String get(String key);
+
+ boolean exist(String dbUrl);
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/DBConnectionProvider.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/DBConnectionProvider.java
new file mode 100644
index 00000000..d029a411
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/DBConnectionProvider.java
@@ -0,0 +1,58 @@
+package com.jd.blockchain.ump.dao;
+
+import org.reflections.Reflections;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class DBConnectionProvider {
+
+ private static final Map dbConnections = new ConcurrentHashMap<>();
+
+ static {
+ init();
+ }
+
+ public static DBConnection dbConnection(String dbUrl) {
+ String dbSchema = dbSchema(dbUrl);
+ if (!dbConnections.containsKey(dbSchema)) {
+ throw new IllegalStateException(
+ String.format("Can not find DBConnection by {%s} !", dbUrl));
+ }
+
+ DBConnection dbConnection = dbConnections.get(dbSchema);
+ return dbConnection.initDbUrl(dbUrl);
+ }
+
+
+ private static String dbSchema(String dbUrl) {
+ // rocksdb:///home/xxx -> rocksdb
+ return dbUrl.split("://")[0];
+
+ }
+
+ private static void init() {
+ // 初始化所有实现类
+ Reflections reflections = new Reflections("com.jd.blockchain.ump.dao");
+
+ Set> dbConnectionSet =
+ reflections.getSubTypesOf(DBConnection.class);
+
+ for (Class extends DBConnection> clazz : dbConnectionSet) {
+
+ if (!clazz.isInterface() && !clazz.equals(UmpDaoHandler.class)) {
+ try {
+ // 根据class生成对象
+ DBConnection dbConnection = clazz.newInstance();
+ String dbSchema = dbConnection.dbSchema();
+ if (dbSchema != null && dbSchema.length() > 0) {
+ dbConnections.put(dbSchema, dbConnection);
+ }
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+ }
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/MemoryDBConnection.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/MemoryDBConnection.java
new file mode 100644
index 00000000..ac9e5755
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/MemoryDBConnection.java
@@ -0,0 +1,47 @@
+package com.jd.blockchain.ump.dao;
+
+import com.alibaba.fastjson.JSON;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class MemoryDBConnection implements DBConnection {
+
+ private static final String MEMORY_SCHEMA = "memory";
+
+ private final Map memory = new ConcurrentHashMap<>();
+
+ @Override
+ public String dbSchema() {
+ return MEMORY_SCHEMA;
+ }
+
+ @Override
+ public DBConnection initDbUrl(String dbUrl) {
+ return this;
+ }
+
+ @Override
+ public void put(String key, String value) {
+ memory.put(key, value);
+ }
+
+ @Override
+ public void put(String key, Object value, Class> type) {
+ String json = JSON.toJSONString(value);
+ put(key, json);
+ }
+
+ @Override
+ public String get(String key) {
+ return memory.get(key);
+ }
+
+ @Override
+ public boolean exist(String dbUrl) {
+ if (dbUrl.startsWith(MEMORY_SCHEMA)) {
+ return true;
+ }
+ return false;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/RocksDBConnection.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/RocksDBConnection.java
new file mode 100644
index 00000000..ed32c519
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/RocksDBConnection.java
@@ -0,0 +1,145 @@
+package com.jd.blockchain.ump.dao;
+
+
+import com.alibaba.fastjson.JSON;
+import org.apache.commons.io.FileUtils;
+import org.rocksdb.*;
+import org.rocksdb.util.SizeUnit;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+public class RocksDBConnection implements DBConnection {
+
+ public static final String SCHEMA = "rocksdb";
+
+ public static final String PROTOCOL_SPLIT = "://";
+
+ public static final String ROCKSDB_PROTOCOL = SCHEMA + PROTOCOL_SPLIT;
+
+ static {
+ RocksDB.loadLibrary();
+ }
+
+ private RocksDB rocksDB;
+
+ @Override
+ public String dbSchema() {
+ return SCHEMA;
+ }
+
+ @Override
+ public DBConnection initDbUrl(String dbUrl) {
+ if (!dbUrl.startsWith(dbSchema())) {
+ throw new IllegalStateException(String.format("Unsupport DBConnection by URL {%s} !!!", dbUrl));
+ }
+ String dbSavePath = dbUrl.split(PROTOCOL_SPLIT)[1];
+ initDBConnection(dbSavePath);
+ return this;
+ }
+
+ @Override
+ public void put(String key, String value) {
+ if (this.rocksDB == null) {
+ throw new IllegalStateException("Rocksdb is NULL, Please initDbUrl first !!!");
+ }
+ try {
+ this.rocksDB.put(key.getBytes(UTF_8), value.getBytes(UTF_8));
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ @Override
+ public void put(String key, Object value, Class> type) {
+ // 使用JSON序列化
+ String json = JSON.toJSONString(value);
+ put(key, json);
+ }
+
+ @Override
+ public String get(String key) {
+ try {
+ byte[] value = this.rocksDB.get(key.getBytes(UTF_8));
+ if (value != null && value.length > 0) {
+ return new String(value, UTF_8);
+ }
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ return null;
+ }
+
+ @Override
+ public boolean exist(String dbUrl) {
+ // 首先该dbUrl是Rocksdb
+ if (dbUrl.startsWith(ROCKSDB_PROTOCOL)) {
+ // 判断File是否存在,并且是文件夹
+ File dbPath = new File(dbUrl.substring(ROCKSDB_PROTOCOL.length()));
+ if (dbPath.exists() && dbPath.isDirectory()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private void initDBConnection(String dbUrl) {
+ try {
+ File dbPath = new File(dbUrl);
+ File dbParentPath = dbPath.getParentFile();
+ if (!dbParentPath.exists()) {
+ FileUtils.forceMkdir(dbParentPath);
+ }
+ this.rocksDB = RocksDB.open(initOptions(), dbUrl);
+ } catch (Exception e) {
+ throw new IllegalStateException(e.getMessage(), e);
+ }
+ }
+
+ private Options initOptions() {
+ final Filter bloomFilter = new BloomFilter(32);
+ final BlockBasedTableConfig tableOptions = new BlockBasedTableConfig()
+ .setFilter(bloomFilter)
+ .setBlockSize(4 * SizeUnit.KB)
+ .setBlockSizeDeviation(10)
+ .setBlockCacheSize(64 * SizeUnit.GB)
+ .setNoBlockCache(false)
+ .setCacheIndexAndFilterBlocks(true)
+ .setBlockRestartInterval(16)
+ ;
+ final List compressionLevels = new ArrayList<>();
+ compressionLevels.add(CompressionType.NO_COMPRESSION); // 0-1
+ compressionLevels.add(CompressionType.SNAPPY_COMPRESSION); // 1-2
+ compressionLevels.add(CompressionType.SNAPPY_COMPRESSION); // 2-3
+ compressionLevels.add(CompressionType.SNAPPY_COMPRESSION); // 3-4
+ compressionLevels.add(CompressionType.SNAPPY_COMPRESSION); // 4-5
+ compressionLevels.add(CompressionType.SNAPPY_COMPRESSION); // 5-6
+ compressionLevels.add(CompressionType.SNAPPY_COMPRESSION); // 6-7
+
+ Options options = new Options()
+ .setAllowConcurrentMemtableWrite(true)
+ .setEnableWriteThreadAdaptiveYield(true)
+ .setCreateIfMissing(true)
+ .setMaxWriteBufferNumber(3)
+ .setTableFormatConfig(tableOptions)
+ .setMaxBackgroundCompactions(10)
+ .setMaxBackgroundFlushes(4)
+ .setBloomLocality(10)
+ .setMinWriteBufferNumberToMerge(4)
+ .setCompressionPerLevel(compressionLevels)
+ .setNumLevels(7)
+ .setCompressionType(CompressionType.SNAPPY_COMPRESSION)
+ .setCompactionStyle(CompactionStyle.UNIVERSAL)
+ .setMemTableConfig(new SkipListMemTableConfig())
+ ;
+ return options;
+ }
+
+ public static void main(String[] args) {
+ String path = "rocksdb:///zhangsan/lisi";
+ System.out.println(path.substring(ROCKSDB_PROTOCOL.length()));
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/UmpDao.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/UmpDao.java
new file mode 100644
index 00000000..1da5d48b
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/UmpDao.java
@@ -0,0 +1,4 @@
+package com.jd.blockchain.ump.dao;
+
+public interface UmpDao {
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/UmpDaoHandler.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/UmpDaoHandler.java
new file mode 100644
index 00000000..62cce01d
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/dao/UmpDaoHandler.java
@@ -0,0 +1,115 @@
+package com.jd.blockchain.ump.dao;
+
+import com.jd.blockchain.ump.model.UmpConstant;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.stereotype.Repository;
+
+import java.io.File;
+
+@Repository
+public class UmpDaoHandler implements UmpDao, CommandLineRunner, DBConnection {
+
+ public final String PROJECT_FLAG = "#project#";
+
+ private static final String PROTOCOL_FILE = "file:";
+
+ private static final String INNER_FILE_SEPARATOR = "!";
+
+ private static final String PROTOCOL_SEPARATOR = "://";
+
+ private DBConnection dbConnection;
+
+ @Override
+ public void run(String... args) {
+
+ String dbUrl = RocksDBConnection.SCHEMA + PROTOCOL_SEPARATOR +
+ PROJECT_FLAG + File.separator + UmpConstant.DB_NAME;
+
+ if (args != null && args.length > 0) {
+ for (String arg : args) {
+ if (arg.startsWith("--db.url")) {
+ dbUrl = arg.split("=")[1];
+ }
+ }
+ }
+
+ dbConnection = DBConnectionProvider.dbConnection(realPath(dbUrl));
+
+ initProjectPath();
+ }
+
+ private void initProjectPath() {
+ UmpConstant.PROJECT_PATH = projectPath();
+ System.out.printf("Init Project Path = %s \r\n", UmpConstant.PROJECT_PATH);
+ }
+
+ @Override
+ public String dbSchema() {
+ return null;
+ }
+
+ @Override
+ public DBConnection initDbUrl(String dbUrl) {
+ return dbConnection;
+ }
+
+ @Override
+ public void put(String key, String value) {
+ dbConnection.put(key, value);
+ }
+
+ @Override
+ public void put(String key, Object value, Class> type) {
+ dbConnection.put(key, value, type);
+ }
+
+ @Override
+ public String get(String key) {
+ return dbConnection.get(key);
+ }
+
+ @Override
+ public boolean exist(String dbUrl) {
+ try {
+ return dbConnection.exist(dbUrl);
+ } catch (Exception e) {
+ // 不关心异常
+ System.err.println(e);
+ return false;
+ }
+ }
+
+ private String realPath(String dbUrl) {
+ if (dbUrl.contains(PROJECT_FLAG)) {
+ // 获取当前jar包路径
+ try {
+ String projectPath = projectPath();
+ return dbUrl.replaceAll(PROJECT_FLAG, projectPath);
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+ return dbUrl;
+ }
+
+ private String projectPath() {
+ File jarDirectory = new File(jarRootPath());
+ return jarDirectory.getParentFile().getParentFile().getPath();
+ }
+
+ private String jarRootPath() {
+ // 获取Jar包所在路径
+ String jarRootPath = UmpDaoHandler.class.getProtectionDomain().getCodeSource().getLocation().getPath();
+
+ // 处理打包到SpringBoot后路径问题:file:
+ if (jarRootPath.startsWith(PROTOCOL_FILE)) {
+ jarRootPath = jarRootPath.substring(PROTOCOL_FILE.length());
+ }
+ // 处理打包到SpringBoot后内部分隔符问题:!
+ if (jarRootPath.contains(INNER_FILE_SEPARATOR)) {
+ jarRootPath = jarRootPath.substring(0, jarRootPath.indexOf(INNER_FILE_SEPARATOR));
+ }
+
+ return jarRootPath;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/MasterAddr.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/MasterAddr.java
new file mode 100644
index 00000000..700cef0b
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/MasterAddr.java
@@ -0,0 +1,47 @@
+package com.jd.blockchain.ump.model;
+
+public class MasterAddr {
+
+ private String ipAddr;
+
+ private int port;
+
+ public MasterAddr() {
+ }
+
+ public MasterAddr(String ipAddr, int port) {
+ this.ipAddr = ipAddr;
+ this.port = port;
+ }
+
+ public String getIpAddr() {
+ return ipAddr;
+ }
+
+ public void setIpAddr(String ipAddr) {
+ this.ipAddr = ipAddr;
+ }
+
+ public int getPort() {
+ return port;
+ }
+
+ public void setPort(int port) {
+ this.port = port;
+ }
+
+ public static MasterAddr newInstance(String ipAddr, int port) {
+ return new MasterAddr(ipAddr, port);
+ }
+
+ public String toHttpUrl() {
+ return "http://" + ipAddr + ":" + port;
+ }
+
+ public boolean legal() {
+ if (this.ipAddr == null || this.ipAddr.length() == 0 || this.port == 0) {
+ return false;
+ }
+ return true;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/PartiNode.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/PartiNode.java
new file mode 100644
index 00000000..9281d408
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/PartiNode.java
@@ -0,0 +1,88 @@
+package com.jd.blockchain.ump.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PartiNode {
+
+ private int id;
+
+ private String name;
+
+ private String pubKey;
+
+ private String initHost;
+
+ private int initPort;
+
+ private boolean isSecure;
+
+ public List toConfigChars() {
+
+ List configCharList = new ArrayList<>();
+
+ configCharList.add(formatConfig(UmpConstant.PARTINODE_NAME_FORMAT, name));
+
+ configCharList.add(formatConfig(UmpConstant.PARTINODE_PUBKEY_FORMAT, pubKey));
+
+ configCharList.add(formatConfig(UmpConstant.PARTINODE_INIT_HOST_FORMAT, initHost));
+
+ configCharList.add(formatConfig(UmpConstant.PARTINODE_INIT_PORT_FORMAT, initPort));
+
+ configCharList.add(formatConfig(UmpConstant.PARTINODE_INIT_SECURE_FORMAT, isSecure));
+
+ return configCharList;
+ }
+
+ private String formatConfig(String formatter, Object value) {
+ return String.format(formatter, id) + "=" + value;
+ }
+
+ public int getId() {
+ return id;
+ }
+
+ public void setId(int id) {
+ this.id = id;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public String getPubKey() {
+ return pubKey;
+ }
+
+ public void setPubKey(String pubKey) {
+ this.pubKey = pubKey;
+ }
+
+ public String getInitHost() {
+ return initHost;
+ }
+
+ public void setInitHost(String initHost) {
+ this.initHost = initHost;
+ }
+
+ public int getInitPort() {
+ return initPort;
+ }
+
+ public void setInitPort(int initPort) {
+ this.initPort = initPort;
+ }
+
+ public boolean isSecure() {
+ return isSecure;
+ }
+
+ public void setSecure(boolean secure) {
+ isSecure = secure;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/PeerSharedConfigs.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/PeerSharedConfigs.java
new file mode 100644
index 00000000..63251967
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/PeerSharedConfigs.java
@@ -0,0 +1,217 @@
+package com.jd.blockchain.ump.model;
+
+import com.jd.blockchain.ump.model.config.LedgerInitConfig;
+import com.jd.blockchain.ump.model.config.MasterConfig;
+import com.jd.blockchain.ump.model.config.PeerLocalConfig;
+import com.jd.blockchain.ump.model.config.PeerSharedConfig;
+import com.jd.blockchain.ump.model.state.LedgerMasterInstall;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class PeerSharedConfigs {
+
+ /**
+ * 默认的一次邀请码最长等待时间,单位分钟,默认30分钟
+ */
+ private static final int MAX_WAIT_MINUTE = 30;
+
+ private CountDownLatch latch = null;
+
+ private Lock lock = new ReentrantLock();
+
+ private Lock waitLock = new ReentrantLock();
+
+ private Condition sizeCondition = waitLock.newCondition();
+
+ private List sharedConfigs = new ArrayList<>();
+
+ private int waitNodeSize;
+
+ private String consensusProvider;
+
+ private String sharedKey;
+
+ private String ledgerName;
+
+ private LedgerInitConfig ledgerInitConfig;
+
+ public synchronized PeerSharedConfigs addConfig(PeerLocalConfig sharedConfig) {
+
+ // 判断内容是否存在重复
+ for (PeerSharedConfig innerSharedConfig : sharedConfigs) {
+ if (innerSharedConfig.getName().equals(sharedConfig.getName())
+ || innerSharedConfig.getPubKey().equals(sharedConfig.getPubKey())) {
+ return null;
+ }
+ }
+
+ if (sharedConfig.getMasterConfig().isMaster()) {
+ initDataByMaster(sharedConfig);
+ }
+
+ sharedConfigs.add(sharedConfig);
+
+ if (latch != null) {
+ // 不管是Master还是普通用户都需要-1
+ latch.countDown();
+ }
+ return this;
+ }
+
+ /**
+ * 由Master节点传入的信息对数据进行初始化
+ *
+ * @param sharedConfig
+ */
+ private void initDataByMaster(PeerLocalConfig sharedConfig) {
+
+ MasterConfig masterConfig = sharedConfig.getMasterConfig();
+
+ // master需要对数据进行组织
+ if (latch == null) {
+ latch = new CountDownLatch(masterConfig.getNodeSize() - sharedConfigs.size());
+ }
+ if (consensusProvider == null) {
+ consensusProvider = sharedConfig.getConsensusProvider();
+ }
+ if (sharedKey == null) {
+ sharedKey = sharedConfig.getSharedKey();
+ }
+ if (ledgerName == null) {
+ ledgerName = masterConfig.getLedgerName();
+ }
+ waitNodeSize = masterConfig.getNodeSize();
+ }
+
+ /**
+ * 线程等待
+ * 一直处于等待状态(30分钟),直到有线程调用single方法
+ *
+ */
+ public void await() {
+ waitLock.lock();
+ try {
+ sizeCondition.await(MAX_WAIT_MINUTE, TimeUnit.MINUTES);
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ } finally {
+ waitLock.unlock();
+ }
+ }
+
+ /**
+ * 通知其他线程等待状态结束
+ *
+ */
+ public void single() {
+ waitLock.lock();
+ try {
+ sizeCondition.signalAll();
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ } finally {
+ waitLock.unlock();
+ }
+ }
+
+ /**
+ * Master线程调用,等待数据满足后通知其他线程
+ *
+ */
+ public void waitAndNotify() {
+ if (this.latch == null) {
+ throw new IllegalStateException("Please init MasterConfig first !!!");
+ }
+ try {
+ latch.await(MAX_WAIT_MINUTE, TimeUnit.MINUTES);
+ single(); // 通知其他线程释放
+ } catch (Exception e) {
+ if (sharedConfigs.size() >= waitNodeSize) {
+ // 成功
+ single();
+ }
+ }
+ }
+
+ public synchronized LedgerInitConfig ledgerInitConfig(String seed, String createTime) {
+ if (ledgerInitConfig != null) {
+ return ledgerInitConfig;
+ }
+
+ // 处理该ledgerInitConfig
+ ledgerInitConfig = new LedgerInitConfig(seed, ledgerName, createTime, consensusProvider, waitNodeSize);
+
+ // 添加参与方
+ for (int i = 0; i < sharedConfigs.size(); i++) {
+ PeerLocalConfig sharedConfig = sharedConfigs.get(i);
+ ledgerInitConfig.addPartiNode(sharedConfig.toPartiNode(i));
+ }
+
+ return ledgerInitConfig;
+ }
+
+ public String getConsensusProvider() {
+ return consensusProvider;
+ }
+
+ public void setConsensusProvider(String consensusProvider) {
+ this.consensusProvider = consensusProvider;
+ }
+
+ public String getSharedKey() {
+ return sharedKey;
+ }
+
+ public void setSharedKey(String sharedKey) {
+ this.sharedKey = sharedKey;
+ }
+
+ public Lock getLock() {
+ return lock;
+ }
+
+ public String getLedgerName() {
+ return ledgerName;
+ }
+
+ public void setLedgerName(String ledgerName) {
+ this.ledgerName = ledgerName;
+ }
+
+ public List getSharedConfigs() {
+ return sharedConfigs;
+ }
+
+ public void setSharedConfigs(List sharedConfigs) {
+ this.sharedConfigs = sharedConfigs;
+ }
+
+ public LedgerInitConfig getLedgerInitConfig() {
+ return ledgerInitConfig;
+ }
+
+ public void setLedgerInitConfig(LedgerInitConfig ledgerInitConfig) {
+ this.ledgerInitConfig = ledgerInitConfig;
+ }
+
+ public LedgerMasterInstall toLedgerMasterInstall() {
+
+ // String ledgerKey, String sharedKey, int totalNodeSize
+ LedgerMasterInstall masterInstall = new LedgerMasterInstall(
+ ledgerInitConfig.ledgerKey(), sharedConfigs.size())
+ .initCreateTime(ledgerInitConfig.getCreateTime());
+
+ for (PeerLocalConfig sharedConfig : sharedConfigs) {
+
+ masterInstall.add(sharedConfig.toPeerInstall());
+ }
+
+ return masterInstall;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/UmpConstant.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/UmpConstant.java
new file mode 100644
index 00000000..5f383e02
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/UmpConstant.java
@@ -0,0 +1,104 @@
+package com.jd.blockchain.ump.model;
+
+import java.io.File;
+
+public class UmpConstant {
+
+ public static String PROJECT_PATH = "";
+
+ public static final String DB_NAME = "jumpdb";
+
+ public static final String URL_SEPARATOR = "/";
+
+ public static final String URL_MASTER = "/master";
+
+ public static final String URL_PEER = "/peer";
+
+ public static final String PRIVATE_KEY_SUFFIX = ".priv";
+
+ public static final String PUBLIC_KEY_SUFFIX = ".priv";
+
+ public static final String PWD_SUFFIX = ".pwd";
+
+ public static final String REQUEST_SHARED_URL = URL_MASTER + URL_SEPARATOR + "share";
+
+ public static final String REQUEST_STATE_URL = URL_MASTER + URL_SEPARATOR + "receive";
+
+ public static final String PARTINODE_COUNT = "cons_parti.count";
+
+ public static final String PARTINODE_FORMAT = "cons_parti.%s";
+
+ public static final String PARTINODE_NAME_FORMAT = PARTINODE_FORMAT + ".name";
+
+ public static final String PARTINODE_PUBKEY_FORMAT = PARTINODE_FORMAT + ".pubkey";
+
+ public static final String PARTINODE_INIT_FORMAT = PARTINODE_FORMAT + ".initializer";
+
+ public static final String PARTINODE_INIT_HOST_FORMAT = PARTINODE_INIT_FORMAT + ".host";
+
+ public static final String PARTINODE_INIT_PORT_FORMAT = PARTINODE_INIT_FORMAT + ".port";
+
+ public static final String PARTINODE_INIT_SECURE_FORMAT = PARTINODE_INIT_FORMAT + ".secure";
+
+ public static final String LEDGER_PREFIX = "ledger";
+
+ public static final String LEDGER_SEED_PREFIX = LEDGER_PREFIX + ".seed";
+
+ public static final String LEDGER_NAME_PREFIX = LEDGER_PREFIX + ".name";
+
+ public static final String CREATE_TIME_PREFIX = "created-time";
+
+ public static final String CONSENSUS_PREFIX = "consensus";
+
+ public static final String CONSENSUS_PROVIDER_PREFIX = CONSENSUS_PREFIX + ".service-provider";
+
+ public static final String CONSENSUS_CONF_PREFIX = CONSENSUS_PREFIX + ".conf";
+
+ public static final String CRYPTO_PREFIX = "crypto";
+
+ public static final String CRYPTO_PROVIDERS_PREFIX = CRYPTO_PREFIX + ".service-providers";
+
+ public static final String LOCAL_PREFIX = "local";
+
+ public static final String LOCAL_PARTI_PREFIX = LOCAL_PREFIX + ".parti";
+
+ public static final String LOCAL_PARTI_ID_PREFIX = LOCAL_PARTI_PREFIX + ".id";
+
+ public static final String LOCAL_PARTI_PUBKEY_PREFIX = LOCAL_PARTI_PREFIX + ".pubkey";
+
+ public static final String LOCAL_PARTI_PRIVKEY_PREFIX = LOCAL_PARTI_PREFIX + ".privkey";
+
+ public static final String LOCAL_PARTI_PWD_PREFIX = LOCAL_PARTI_PREFIX + ".pwd";
+
+ public static final String LEDGER_BINDING_OUT_PREFIX = LEDGER_PREFIX + ".binding.out";
+
+ public static final String LEDGER_DB_URI_PREFIX = LEDGER_PREFIX + ".db.uri";
+
+ public static final String LEDGER_DB_PWD_PREFIX = LEDGER_PREFIX + ".db.pwd";
+
+ public static final String CMD_LEDGER_INIT = "/bin/bash %s -monitor";
+
+ public static final String CMD_START_UP_FORMAT = "/bin/bash %s";
+
+ public static final String PATH_BIN = File.separator + "bin";
+
+ public static final String PATH_LEDGER_INIT_BIN = PATH_BIN + File.separator + "ledger-init.sh";
+
+ public static final String PATH_STARTUP_BIN = PATH_BIN + File.separator + "startup.sh";
+
+ public static final String PATH_LIBS = File.separator + "libs";
+
+ public static final String PATH_SYSTEM = File.separator + "system";
+
+ public static final String PATH_CONFIG = File.separator + "config";
+
+ public static final String PATH_CONFIG_KEYS = PATH_CONFIG + File.separator + "keys";
+
+ public static final String PATH_LEDGER_BINDING_CONFIG = PATH_CONFIG + File.separator + "ledger-binding.conf";
+
+ public static final String PATH_CONFIG_INIT = PATH_CONFIG + File.separator + "init";
+
+ public static final String PATH_LOCAL_CONFIG = PATH_CONFIG_INIT + File.separator + "local.conf";
+
+ public static final String PATH_LEDGER_INIT_CONFIG = PATH_CONFIG_INIT + File.separator + "ledger.init";
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/UmpQueue.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/UmpQueue.java
new file mode 100644
index 00000000..509fb4a5
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/UmpQueue.java
@@ -0,0 +1,50 @@
+package com.jd.blockchain.ump.model;
+
+import com.jd.blockchain.ump.model.state.InstallSchedule;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+public class UmpQueue {
+
+ private final BlockingQueue QUEUE_INSTALL_SCHEDULE = new LinkedBlockingQueue<>();
+
+ public void put(InstallSchedule installSchedule, MasterAddr masterAddr) throws InterruptedException {
+ QUEUE_INSTALL_SCHEDULE.put(new InstallScheduleRequest(installSchedule, masterAddr));
+ }
+
+ public InstallScheduleRequest take() throws InterruptedException {
+ return QUEUE_INSTALL_SCHEDULE.take();
+ }
+
+ public static class InstallScheduleRequest {
+
+ private InstallSchedule installSchedule;
+
+ private MasterAddr masterAddr;
+
+ public InstallScheduleRequest() {
+ }
+
+ public InstallScheduleRequest(InstallSchedule installSchedule, MasterAddr masterAddr) {
+ this.installSchedule = installSchedule;
+ this.masterAddr = masterAddr;
+ }
+
+ public InstallSchedule getInstallSchedule() {
+ return installSchedule;
+ }
+
+ public void setInstallSchedule(InstallSchedule installSchedule) {
+ this.installSchedule = installSchedule;
+ }
+
+ public MasterAddr getMasterAddr() {
+ return masterAddr;
+ }
+
+ public void setMasterAddr(MasterAddr masterAddr) {
+ this.masterAddr = masterAddr;
+ }
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/ConsensusConfig.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/ConsensusConfig.java
new file mode 100644
index 00000000..e6963c2f
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/ConsensusConfig.java
@@ -0,0 +1,24 @@
+package com.jd.blockchain.ump.model.config;
+
+public class ConsensusConfig {
+
+ private String confPath;
+
+ private byte[] content;
+
+ public String getConfPath() {
+ return confPath;
+ }
+
+ public void setConfPath(String confPath) {
+ this.confPath = confPath;
+ }
+
+ public byte[] getContent() {
+ return content;
+ }
+
+ public void setContent(byte[] content) {
+ this.content = content;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/LedgerConfig.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/LedgerConfig.java
new file mode 100644
index 00000000..2b435f93
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/LedgerConfig.java
@@ -0,0 +1,46 @@
+package com.jd.blockchain.ump.model.config;
+
+public class LedgerConfig {
+
+ private LedgerInitConfig initConfig;
+
+ /**
+ * 共识文件配置信息,Base58格式
+ */
+ private String consensusConfig;
+
+
+ public LedgerConfig() {
+ }
+
+ /**
+ * 包装一下,使用JSON处理过程
+ *
+ * @param ledgerConfig
+ */
+ public LedgerConfig(LedgerConfig ledgerConfig) {
+ this.consensusConfig = ledgerConfig.getConsensusConfig();
+
+ }
+
+ public LedgerConfig(LedgerInitConfig initConfig, String consensusConfig) {
+ this.initConfig = initConfig;
+ this.consensusConfig = consensusConfig;
+ }
+
+ public LedgerInitConfig getInitConfig() {
+ return initConfig;
+ }
+
+ public void setInitConfig(LedgerInitConfig initConfig) {
+ this.initConfig = initConfig;
+ }
+
+ public String getConsensusConfig() {
+ return consensusConfig;
+ }
+
+ public void setConsensusConfig(String consensusConfig) {
+ this.consensusConfig = consensusConfig;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/LedgerIdentification.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/LedgerIdentification.java
new file mode 100644
index 00000000..1b724dc7
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/LedgerIdentification.java
@@ -0,0 +1,92 @@
+package com.jd.blockchain.ump.model.config;
+
+import com.jd.blockchain.ump.model.MasterAddr;
+
+public class LedgerIdentification {
+
+ private String ledgerKey;
+
+ private String ledgerAndNodeKey;
+
+ private MasterAddr masterAddr;
+
+ private int nodeId;
+
+ private PeerLocalConfig localConfig;
+
+ private LedgerInitConfig initConfig;
+
+ public LedgerIdentification() {
+ }
+
+ public LedgerIdentification(int nodeId, PeerLocalConfig localConfig, MasterAddr masterAddr, String ledgerAndNodeKey, LedgerInitConfig initConfig) {
+ this.nodeId = nodeId;
+ this.localConfig = localConfig;
+ this.masterAddr = masterAddr;
+ this.ledgerKey = initConfig.ledgerKey();
+ this.ledgerAndNodeKey = ledgerAndNodeKey;
+ this.initConfig = initConfig;
+ init();
+ }
+
+ private void init() {
+ // 初始化部分配置信息
+ MasterConfig masterConfig = localConfig.getMasterConfig();
+ // 设置账本名称
+ if (masterConfig.getLedgerName() == null || masterConfig.getLedgerName().length() == 0) {
+ masterConfig.setLedgerName(initConfig.getName());
+ }
+ // 设置NodeSize
+ if (masterConfig.getNodeSize() == 0) {
+ masterConfig.setNodeSize(initConfig.getNodeSize());
+ }
+ }
+
+ public String getLedgerKey() {
+ return ledgerKey;
+ }
+
+ public void setLedgerKey(String ledgerKey) {
+ this.ledgerKey = ledgerKey;
+ }
+
+ public String getLedgerAndNodeKey() {
+ return ledgerAndNodeKey;
+ }
+
+ public void setLedgerAndNodeKey(String ledgerAndNodeKey) {
+ this.ledgerAndNodeKey = ledgerAndNodeKey;
+ }
+
+ public MasterAddr getMasterAddr() {
+ return masterAddr;
+ }
+
+ public void setMasterAddr(MasterAddr masterAddr) {
+ this.masterAddr = masterAddr;
+ }
+
+ public int getNodeId() {
+ return nodeId;
+ }
+
+ public void setNodeId(int nodeId) {
+ this.nodeId = nodeId;
+ }
+
+ public PeerLocalConfig getLocalConfig() {
+ return localConfig;
+ }
+
+ public void setLocalConfig(PeerLocalConfig localConfig) {
+ this.localConfig = localConfig;
+ }
+
+ public LedgerInitConfig getInitConfig() {
+ return initConfig;
+ }
+
+ public void setInitConfig(LedgerInitConfig initConfig) {
+ this.initConfig = initConfig;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/LedgerInitConfig.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/LedgerInitConfig.java
new file mode 100644
index 00000000..f31d84fe
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/LedgerInitConfig.java
@@ -0,0 +1,141 @@
+package com.jd.blockchain.ump.model.config;
+
+import com.jd.blockchain.ump.model.PartiNode;
+import com.jd.blockchain.ump.model.UmpConstant;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LedgerInitConfig {
+
+ private String seed;
+
+ private String name;
+
+ private String createTime;
+
+ private String consensusProvider;
+
+ private int nodeSize;
+
+ private String cryptoProviders =
+ "com.jd.blockchain.crypto.service.classic.ClassicCryptoService, " +
+ "com.jd.blockchain.crypto.service.sm.SMCryptoService";
+
+
+ private List partiNodes = new ArrayList<>();
+
+ public LedgerInitConfig() {
+ }
+
+ public LedgerInitConfig(String seed, String name, String createTime, String consensusProvider, int nodeSize) {
+ this.seed = seed;
+ this.name = name;
+ this.createTime = createTime;
+ this.consensusProvider = consensusProvider;
+ this.nodeSize = nodeSize;
+ }
+
+ public List toConfigChars(String consensusConf) {
+
+ List configChars = new ArrayList<>();
+
+ configChars.add(toConfigChars(UmpConstant.LEDGER_SEED_PREFIX, seed));
+
+ configChars.add(toConfigChars(UmpConstant.LEDGER_NAME_PREFIX, name));
+
+ configChars.add(toConfigChars(UmpConstant.CREATE_TIME_PREFIX, createTime));
+
+ configChars.add(toConfigChars(UmpConstant.CONSENSUS_PROVIDER_PREFIX, consensusProvider));
+
+ configChars.add(toConfigChars(UmpConstant.CONSENSUS_CONF_PREFIX, consensusConf));
+
+ configChars.add(toConfigChars(UmpConstant.CRYPTO_PROVIDERS_PREFIX, cryptoProviders));
+
+ configChars.add(toConfigChars(UmpConstant.PARTINODE_COUNT, partiNodes.size()));
+
+ for (PartiNode partiNode : partiNodes) {
+ configChars.addAll(partiNode.toConfigChars());
+ }
+
+ return configChars;
+ }
+
+ public String ledgerKey() {
+ return seed + "-" + name;
+ }
+
+ public int nodeId(String pubKey) {
+ for (int i = 0; i < partiNodes.size(); i++) {
+ PartiNode partiNode = partiNodes.get(i);
+ if (partiNode.getPubKey().equals(pubKey)) {
+ return i;
+ }
+ }
+ throw new IllegalStateException(String.format("Can not find PubKey = %s !", pubKey));
+ }
+
+ private String toConfigChars(String prefix, Object value) {
+ return prefix + "=" + value;
+ }
+
+ public String getSeed() {
+ return seed;
+ }
+
+ public void setSeed(String seed) {
+ this.seed = seed;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public String getCreateTime() {
+ return createTime;
+ }
+
+ public void setCreateTime(String createTime) {
+ this.createTime = createTime;
+ }
+
+ public String getConsensusProvider() {
+ return consensusProvider;
+ }
+
+ public void setConsensusProvider(String consensusProvider) {
+ this.consensusProvider = consensusProvider;
+ }
+
+ public int getNodeSize() {
+ return nodeSize;
+ }
+
+ public void setNodeSize(int nodeSize) {
+ this.nodeSize = nodeSize;
+ }
+
+ public String getCryptoProviders() {
+ return cryptoProviders;
+ }
+
+ public void setCryptoProviders(String cryptoProviders) {
+ this.cryptoProviders = cryptoProviders;
+ }
+
+ public List getPartiNodes() {
+ return partiNodes;
+ }
+
+ public void setPartiNodes(List partiNodes) {
+ this.partiNodes = partiNodes;
+ }
+
+ public void addPartiNode(PartiNode partiNode) {
+ this.partiNodes.add(partiNode);
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/MasterConfig.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/MasterConfig.java
new file mode 100644
index 00000000..f3807773
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/MasterConfig.java
@@ -0,0 +1,89 @@
+package com.jd.blockchain.ump.model.config;
+
+import com.jd.blockchain.ump.model.MasterAddr;
+
+public class MasterConfig {
+
+ private String masterAddr;
+
+ private int masterPort;
+
+ private String ledgerName;
+
+ private int nodeSize;
+
+ private boolean isMaster = false;
+
+ public MasterConfig() {
+ }
+
+ public String getMasterAddr() {
+ return masterAddr;
+ }
+
+ public void setMasterAddr(String masterAddr) {
+ this.masterAddr = masterAddr;
+ }
+
+ public int getMasterPort() {
+ return masterPort;
+ }
+
+ public void setMasterPort(int masterPort) {
+ this.masterPort = masterPort;
+ }
+
+ public String getLedgerName() {
+ return ledgerName;
+ }
+
+ public void setLedgerName(String ledgerName) {
+ this.ledgerName = ledgerName;
+ }
+
+ public int getNodeSize() {
+ return nodeSize;
+ }
+
+ public void setNodeSize(int nodeSize) {
+ this.nodeSize = nodeSize;
+ }
+
+ public boolean isMaster() {
+ return isMaster;
+ }
+
+ public void setMaster(boolean master) {
+ isMaster = master;
+ }
+
+ public MasterConfig buildIsMaster(boolean isMaster) {
+ setMaster(isMaster);
+ return this;
+ }
+
+ public MasterConfig buildNodeSize(int nodeSize) {
+ setNodeSize(nodeSize);
+ return this;
+ }
+
+ public MasterConfig buildLedgerName(String ledgerName) {
+ setLedgerName(ledgerName);
+ return this;
+ }
+
+ public MasterConfig buildMasterAddr(String masterAddr) {
+ setMasterAddr(masterAddr);
+ return this;
+ }
+
+ public MasterConfig buildMasterPort(int masterPort) {
+ setMasterPort(masterPort);
+ return this;
+ }
+
+
+ public MasterAddr toMasterAddr() {
+ return MasterAddr.newInstance(masterAddr, masterPort);
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/PeerLocalConfig.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/PeerLocalConfig.java
new file mode 100644
index 00000000..21ba3220
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/PeerLocalConfig.java
@@ -0,0 +1,160 @@
+package com.jd.blockchain.ump.model.config;
+
+
+import com.jd.blockchain.ump.model.MasterAddr;
+import com.jd.blockchain.ump.model.PartiNode;
+import com.jd.blockchain.ump.model.UmpConstant;
+import com.jd.blockchain.ump.model.state.LedgerMasterInstall;
+import com.jd.blockchain.ump.model.state.LedgerPeerInstall;
+
+import java.io.File;
+
+/**
+ * Peer本地配置信息
+ */
+public class PeerLocalConfig extends PeerSharedConfig {
+
+ private String peerPath;
+
+ private String consensusConf = "bftsmart.config"; // 默认为bftsmart配置
+
+ private String privKey;
+
+ private String encodePwd;
+
+ private String dbName;
+
+ private MasterConfig masterConfig;
+
+ public String bindingOutPath() {
+ return peerPath + UmpConstant.PATH_CONFIG;
+ }
+
+ public String localConfPath() {
+ return peerPath + UmpConstant.PATH_LOCAL_CONFIG;
+ }
+
+ public String ledgerInitConfPath() {
+ return peerPath + UmpConstant.PATH_LEDGER_INIT_CONFIG;
+ }
+
+ public String consensusConfPath() {
+ return peerPath + UmpConstant.PATH_CONFIG_INIT + File.separator + consensusConf;
+ }
+
+ public String libsDirectory() {
+ return peerPath + UmpConstant.PATH_LIBS;
+ }
+
+ public String getPeerPath() {
+ return peerPath;
+ }
+
+ public void setPeerPath(String peerPath) {
+ this.peerPath = peerPath;
+ }
+
+ public String getConsensusConf() {
+ return consensusConf;
+ }
+
+ public void setConsensusConf(String consensusConf) {
+ this.consensusConf = consensusConf;
+ }
+
+ public String getPrivKey() {
+ return privKey;
+ }
+
+ public void setPrivKey(String privKey) {
+ this.privKey = privKey;
+ }
+
+ public String getEncodePwd() {
+ return encodePwd;
+ }
+
+ public void setEncodePwd(String encodePwd) {
+ this.encodePwd = encodePwd;
+ }
+
+ public String getDbName() {
+ return dbName;
+ }
+
+ public void setDbName(String dbName) {
+ this.dbName = dbName;
+ }
+
+ public MasterConfig getMasterConfig() {
+ return masterConfig;
+ }
+
+ public void setMasterConfig(MasterConfig masterConfig) {
+ this.masterConfig = masterConfig;
+ }
+
+ public synchronized PartiNode toPartiNode(int nodeId) {
+ if (this.partiNode != null) {
+ return partiNode;
+ }
+ partiNode = new PartiNode();
+ partiNode.setId(nodeId);
+ partiNode.setName(name);
+ partiNode.setInitHost(initAddr);
+ partiNode.setInitPort(initPort);
+ partiNode.setPubKey(pubKey);
+ partiNode.setSecure(false);
+ return partiNode;
+ }
+
+ public LedgerPeerInstall toLedgerPeerInstall(int totalNodeSize) {
+ return new LedgerPeerInstall(name, sharedKey, peerPath, totalNodeSize);
+ }
+
+ public LedgerMasterInstall.PeerInstall toPeerInstall() {
+ return new LedgerMasterInstall.PeerInstall(name, pubKey, initAddr, initPort, consensusNode, consensusProvider);
+ }
+
+ public void verify() {
+
+ // 主要校验dbName地址是否存在
+ String dbPath = peerPath + File.separator + dbName;
+ File dbDir = new File(dbPath);
+ if (dbDir.exists()) {
+ throw new IllegalStateException(String.format("DB name = %s, path = %s is exist !!!", dbName, dbPath));
+ }
+
+ // 其他配置信息是否正确
+ if (masterConfig == null) {
+ // Master不能为空
+ throw new IllegalStateException("Master Config can not be NULL !!!");
+ }
+ if (masterConfig.isMaster()) {
+ // 账本名字及NodeSize不能为空
+ if (masterConfig.getLedgerName() == null || masterConfig.getLedgerName().length() == 0) {
+ throw new IllegalStateException("Master 's LedgerName can not be empty !!!");
+ }
+ if (masterConfig.getNodeSize() == 0) {
+ throw new IllegalStateException("Master 's NodeSize can not be Zero !!!");
+ }
+ } else {
+ // 普通Peer需要检查Master的IP地址及端口
+ if (masterConfig.getMasterAddr() == null || masterConfig.getMasterAddr().length() == 0) {
+ throw new IllegalStateException("Master 's IP Address can not be empty !!!");
+ }
+
+ if (masterConfig.getMasterPort() == 0) {
+ throw new IllegalStateException("Master 's Port must be Set !!!");
+ }
+ }
+ }
+
+ public boolean master() {
+ return masterConfig.isMaster();
+ }
+
+ public MasterAddr masterAddr() {
+ return masterConfig.toMasterAddr();
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/PeerSharedConfig.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/PeerSharedConfig.java
new file mode 100644
index 00000000..cf5d71ef
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/PeerSharedConfig.java
@@ -0,0 +1,86 @@
+package com.jd.blockchain.ump.model.config;
+
+import com.jd.blockchain.ump.model.PartiNode;
+
+public class PeerSharedConfig {
+
+ public static final String DB_ROCKSDB_SUFFIX = "rocksdb_";
+
+ protected String sharedKey;
+
+ protected String name;
+
+ protected String initAddr;
+
+ protected String pubKey;
+
+ protected int initPort;
+
+ protected String consensusNode;
+
+ protected String consensusProvider = "com.jd.blockchain.consensus.bftsmart.BftsmartConsensusProvider";
+
+ protected PartiNode partiNode;
+
+ public String getSharedKey() {
+ return sharedKey;
+ }
+
+ public void setSharedKey(String sharedKey) {
+ this.sharedKey = sharedKey;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public String getInitAddr() {
+ return initAddr;
+ }
+
+ public void setInitAddr(String initAddr) {
+ this.initAddr = initAddr;
+ }
+
+ public String getPubKey() {
+ return pubKey;
+ }
+
+ public void setPubKey(String pubKey) {
+ this.pubKey = pubKey;
+ }
+
+ public int getInitPort() {
+ return initPort;
+ }
+
+ public void setInitPort(int initPort) {
+ this.initPort = initPort;
+ }
+
+ public String addr() {
+ return initAddr + "-" + initPort;
+ }
+
+ public String getConsensusNode() {
+ return consensusNode;
+ }
+
+ public void setConsensusNode(String consensusNode) {
+ this.consensusNode = consensusNode;
+ }
+
+ public String getConsensusProvider() {
+ return consensusProvider;
+ }
+
+ public void setConsensusProvider(String consensusProvider) {
+ this.consensusProvider = consensusProvider;
+ }
+
+
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/PeerSharedConfigVv.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/PeerSharedConfigVv.java
new file mode 100644
index 00000000..6e536b32
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/config/PeerSharedConfigVv.java
@@ -0,0 +1,180 @@
+package com.jd.blockchain.ump.model.config;
+
+
+import com.jd.blockchain.ump.model.UmpConstant;
+import com.jd.blockchain.ump.model.user.UserKeys;
+
+/**
+ *
+ */
+public class PeerSharedConfigVv {
+
+ private String sharedKey;
+
+ private String name;
+
+ private int userId;
+
+ private String pubKey;
+
+ private String initAddr;
+
+ private int initPort;
+
+ private String consensusNode;
+
+ private String peerPath = UmpConstant.PROJECT_PATH;
+
+ private String dbName;
+
+ private int nodeSize;
+
+ private String masterAddr;
+
+ private int masterPort;
+
+ private String ledgerName;
+
+ public String getSharedKey() {
+ return sharedKey;
+ }
+
+ public void setSharedKey(String sharedKey) {
+ this.sharedKey = sharedKey;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public int getUserId() {
+ return userId;
+ }
+
+ public void setUserId(int userId) {
+ this.userId = userId;
+ }
+
+ public String getInitAddr() {
+ return initAddr;
+ }
+
+ public String getPubKey() {
+ return pubKey;
+ }
+
+ public void setPubKey(String pubKey) {
+ this.pubKey = pubKey;
+ }
+
+ public void setInitAddr(String initAddr) {
+ this.initAddr = initAddr;
+ }
+
+ public int getInitPort() {
+ return initPort;
+ }
+
+ public void setInitPort(int initPort) {
+ this.initPort = initPort;
+ }
+
+ public String getConsensusNode() {
+ return consensusNode;
+ }
+
+ public void setConsensusNode(String consensusNode) {
+ this.consensusNode = consensusNode;
+ }
+
+ public String getPeerPath() {
+ return peerPath;
+ }
+
+ public void setPeerPath(String peerPath) {
+ this.peerPath = peerPath;
+ }
+
+ public String getDbName() {
+ return dbName;
+ }
+
+ public void setDbName(String dbName) {
+ this.dbName = dbName;
+ }
+
+ public int getNodeSize() {
+ return nodeSize;
+ }
+
+ public void setNodeSize(Integer nodeSize) {
+ this.nodeSize = nodeSize;
+ }
+
+ public String getMasterAddr() {
+ return masterAddr;
+ }
+
+ public void setMasterAddr(String masterAddr) {
+ this.masterAddr = masterAddr;
+ }
+
+ public int getMasterPort() {
+ return masterPort;
+ }
+
+ public void setMasterPort(Integer masterPort) {
+ this.masterPort = masterPort;
+ }
+
+ public String getLedgerName() {
+ return ledgerName;
+ }
+
+ public void setLedgerName(String ledgerName) {
+ this.ledgerName = ledgerName;
+ }
+
+ public PeerLocalConfig toPeerLocalConfig(UserKeys userKeys) {
+
+ PeerLocalConfig localConfig = new PeerLocalConfig();
+
+ localConfig.setSharedKey(sharedKey);
+ localConfig.setName(name);
+ localConfig.setInitAddr(initAddr);
+ localConfig.setInitPort(initPort);
+ localConfig.setConsensusNode(consensusNode);
+ localConfig.setPubKey(userKeys.getPubKey());
+ localConfig.setPrivKey(userKeys.getPrivKey());
+ localConfig.setEncodePwd(userKeys.getEncodePwd());
+ localConfig.setPeerPath(peerPath);
+ localConfig.setDbName(dbName);
+
+ MasterConfig masterConfig = new MasterConfig();
+
+ if (master()) {
+ masterConfig.buildIsMaster(true)
+ .buildLedgerName(ledgerName)
+ .buildNodeSize(nodeSize);
+ } else {
+ masterConfig.buildIsMaster(false)
+ .buildMasterAddr(masterAddr)
+ .buildMasterPort(masterPort);
+ }
+
+ localConfig.setMasterConfig(masterConfig);
+
+ return localConfig;
+ }
+
+ private boolean master() {
+ if (masterAddr == null || masterAddr.length() == 0) {
+ return true;
+ }
+ return false;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/InstallProcess.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/InstallProcess.java
new file mode 100644
index 00000000..a373f5be
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/InstallProcess.java
@@ -0,0 +1,21 @@
+package com.jd.blockchain.ump.model.state;
+
+public class InstallProcess {
+
+ private String content;
+
+ public InstallProcess() {
+ }
+
+ public InstallProcess(String content) {
+ this.content = content;
+ }
+
+ public String getContent() {
+ return content;
+ }
+
+ public void setContent(String content) {
+ this.content = content;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/InstallSchedule.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/InstallSchedule.java
new file mode 100644
index 00000000..66f26ebb
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/InstallSchedule.java
@@ -0,0 +1,54 @@
+package com.jd.blockchain.ump.model.state;
+
+public class InstallSchedule {
+
+ private String ledgerKey;
+
+ private String ledgerAndNodeKey;
+
+ private InstallProcess process;
+
+ private ScheduleState state;
+
+ public InstallSchedule() {
+ }
+
+ public InstallSchedule(String ledgerKey, String ledgerAndNodeKey, InstallProcess process, ScheduleState state) {
+ this.ledgerKey = ledgerKey;
+ this.ledgerAndNodeKey = ledgerAndNodeKey;
+ this.process = process;
+ this.state = state;
+ }
+
+ public String getLedgerKey() {
+ return ledgerKey;
+ }
+
+ public void setLedgerKey(String ledgerKey) {
+ this.ledgerKey = ledgerKey;
+ }
+
+ public String getLedgerAndNodeKey() {
+ return ledgerAndNodeKey;
+ }
+
+ public void setLedgerAndNodeKey(String ledgerAndNodeKey) {
+ this.ledgerAndNodeKey = ledgerAndNodeKey;
+ }
+
+ public InstallProcess getProcess() {
+ return process;
+ }
+
+ public void setProcess(InstallProcess process) {
+ this.process = process;
+ }
+
+ public ScheduleState getState() {
+ return state;
+ }
+
+ public void setState(ScheduleState state) {
+ this.state = state;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/LedgerBindingConf.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/LedgerBindingConf.java
new file mode 100644
index 00000000..7843dade
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/LedgerBindingConf.java
@@ -0,0 +1,33 @@
+package com.jd.blockchain.ump.model.state;
+
+import java.util.Set;
+
+public class LedgerBindingConf {
+
+ private Set ledgerHashs;
+
+ private long lastTime;
+
+ public LedgerBindingConf() {
+ }
+
+ public LedgerBindingConf(long lastTime) {
+ this.lastTime = lastTime;
+ }
+
+ public Set getLedgerHashs() {
+ return ledgerHashs;
+ }
+
+ public void setLedgerHashs(Set ledgerHashs) {
+ this.ledgerHashs = ledgerHashs;
+ }
+
+ public long getLastTime() {
+ return lastTime;
+ }
+
+ public void setLastTime(long lastTime) {
+ this.lastTime = lastTime;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/LedgerInited.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/LedgerInited.java
new file mode 100644
index 00000000..64445781
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/LedgerInited.java
@@ -0,0 +1,101 @@
+package com.jd.blockchain.ump.model.state;
+
+public class LedgerInited {
+
+ private String ledgerHash;
+
+ private String ledgerName;
+
+ private String partiName;
+
+ private String partiAddress;
+
+ private String dbUri;
+
+ private StartupState startupState = StartupState.UNKNOWN;
+
+ public LedgerInited() {
+ }
+
+ public LedgerInited(String ledgerHash) {
+ this.ledgerHash = ledgerHash;
+ }
+
+ public String getLedgerHash() {
+ return ledgerHash;
+ }
+
+ public void setLedgerHash(String ledgerHash) {
+ this.ledgerHash = ledgerHash;
+ }
+
+ public String getLedgerName() {
+ return ledgerName;
+ }
+
+ public void setLedgerName(String ledgerName) {
+ this.ledgerName = ledgerName;
+ }
+
+ public String getPartiName() {
+ return partiName;
+ }
+
+ public void setPartiName(String partiName) {
+ this.partiName = partiName;
+ }
+
+ public String getPartiAddress() {
+ return partiAddress;
+ }
+
+ public void setPartiAddress(String partiAddress) {
+ this.partiAddress = partiAddress;
+ }
+
+ public String getDbUri() {
+ return dbUri;
+ }
+
+ public void setDbUri(String dbUri) {
+ this.dbUri = dbUri;
+ }
+
+ public StartupState getStartupState() {
+ return startupState;
+ }
+
+ public void setStartupState(StartupState startupState) {
+ this.startupState = startupState;
+ }
+
+ public LedgerInited buildLedgerHash(String ledgerHash) {
+ setLedgerHash(ledgerHash);
+ return this;
+ }
+
+ public LedgerInited buildLedgerName(String ledgerName) {
+ setLedgerName(ledgerName);
+ return this;
+ }
+
+ public LedgerInited buildPartiName(String partiName) {
+ setPartiName(partiName);
+ return this;
+ }
+
+ public LedgerInited buildPartiAddress(String partiAddress) {
+ setPartiAddress(partiAddress);
+ return this;
+ }
+
+ public LedgerInited buildDbUri(String dbUri) {
+ setDbUri(dbUri);
+ return this;
+ }
+
+ public LedgerInited buildStartupState(StartupState startupState) {
+ setStartupState(startupState);
+ return this;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/LedgerMasterInstall.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/LedgerMasterInstall.java
new file mode 100644
index 00000000..76ca3d41
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/LedgerMasterInstall.java
@@ -0,0 +1,156 @@
+package com.jd.blockchain.ump.model.state;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+public class LedgerMasterInstall {
+
+ private static final SimpleDateFormat SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+
+ private String ledgerKey;
+
+ private int totalNodeSize;
+
+ private String createTime;
+
+ private List peerInstalls = new ArrayList<>();
+
+ public LedgerMasterInstall() {
+ }
+
+ public LedgerMasterInstall(String ledgerKey, int totalNodeSize) {
+ this.ledgerKey = ledgerKey;
+ this.totalNodeSize = totalNodeSize;
+ }
+
+ public LedgerMasterInstall initCreateTime(String createTime) {
+ this.createTime = createTime;
+ return this;
+ }
+
+ public LedgerMasterInstall initCreateTime(Date date) {
+ this.createTime = SDF.format(date);
+ return this;
+ }
+
+ public LedgerMasterInstall add(PeerInstall peerInstall) {
+ peerInstalls.add(peerInstall);
+ return this;
+ }
+
+ public LedgerMasterInstall add(String name, String pubKey, String ipAddr, int initPort,
+ String consensusNode, String consensusProvider) {
+ PeerInstall peerInstall = new PeerInstall(
+ name, pubKey, ipAddr, initPort, consensusNode, consensusProvider);
+ return add(peerInstall);
+ }
+
+ public String getLedgerKey() {
+ return ledgerKey;
+ }
+
+ public void setLedgerKey(String ledgerKey) {
+ this.ledgerKey = ledgerKey;
+ }
+
+ public int getTotalNodeSize() {
+ return totalNodeSize;
+ }
+
+ public void setTotalNodeSize(int totalNodeSize) {
+ this.totalNodeSize = totalNodeSize;
+ }
+
+ public String getCreateTime() {
+ return createTime;
+ }
+
+ public void setCreateTime(String createTime) {
+ this.createTime = createTime;
+ }
+
+ public List getPeerInstalls() {
+ return peerInstalls;
+ }
+
+ public void setPeerInstalls(List peerInstalls) {
+ this.peerInstalls = peerInstalls;
+ }
+
+ public static class PeerInstall {
+
+ private String name;
+
+ private String pubKey;
+
+ private String ipAddr;
+
+ private int initPort;
+
+ private String consensusNode;
+
+ private String consensusProvider;
+
+ public PeerInstall() {
+ }
+
+ public PeerInstall(String name, String pubKey, String ipAddr, int initPort, String consensusNode, String consensusProvider) {
+ this.name = name;
+ this.pubKey = pubKey;
+ this.ipAddr = ipAddr;
+ this.initPort = initPort;
+ this.consensusNode = consensusNode;
+ this.consensusProvider = consensusProvider;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public String getPubKey() {
+ return pubKey;
+ }
+
+ public void setPubKey(String pubKey) {
+ this.pubKey = pubKey;
+ }
+
+ public String getIpAddr() {
+ return ipAddr;
+ }
+
+ public void setIpAddr(String ipAddr) {
+ this.ipAddr = ipAddr;
+ }
+
+ public int getInitPort() {
+ return initPort;
+ }
+
+ public void setInitPort(int initPort) {
+ this.initPort = initPort;
+ }
+
+ public String getConsensusNode() {
+ return consensusNode;
+ }
+
+ public void setConsensusNode(String consensusNode) {
+ this.consensusNode = consensusNode;
+ }
+
+ public String getConsensusProvider() {
+ return consensusProvider;
+ }
+
+ public void setConsensusProvider(String consensusProvider) {
+ this.consensusProvider = consensusProvider;
+ }
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/LedgerPeerInited.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/LedgerPeerInited.java
new file mode 100644
index 00000000..7026aa57
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/LedgerPeerInited.java
@@ -0,0 +1,42 @@
+package com.jd.blockchain.ump.model.state;
+
+public class LedgerPeerInited {
+
+ private String ledgerHash;
+
+ private LedgerPeerInstall peerInstall;
+
+ private StartupState startupState;
+
+ public LedgerPeerInited() {
+ }
+
+ public LedgerPeerInited(String ledgerHash, LedgerPeerInstall peerInstall) {
+ this.ledgerHash = ledgerHash;
+ this.peerInstall = peerInstall;
+ }
+
+ public String getLedgerHash() {
+ return ledgerHash;
+ }
+
+ public void setLedgerHash(String ledgerHash) {
+ this.ledgerHash = ledgerHash;
+ }
+
+ public LedgerPeerInstall getPeerInstall() {
+ return peerInstall;
+ }
+
+ public void setPeerInstall(LedgerPeerInstall peerInstall) {
+ this.peerInstall = peerInstall;
+ }
+
+ public StartupState getStartupState() {
+ return startupState;
+ }
+
+ public void setStartupState(StartupState startupState) {
+ this.startupState = startupState;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/LedgerPeerInstall.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/LedgerPeerInstall.java
new file mode 100644
index 00000000..932d621c
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/LedgerPeerInstall.java
@@ -0,0 +1,117 @@
+package com.jd.blockchain.ump.model.state;
+
+import com.jd.blockchain.ump.model.MasterAddr;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class LedgerPeerInstall {
+
+ private static final SimpleDateFormat SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+
+ private String ledgerKey;
+
+ private String ledgerAndNodeKey;
+
+ private String nodeName;
+
+ private String sharedKey;
+
+ private String peerPath;
+
+ private int totalNodeSize;
+
+ private MasterAddr masterAddr;
+
+ private String createTime;
+
+ public LedgerPeerInstall() {
+ }
+
+ public LedgerPeerInstall(String nodeName, String sharedKey, String peerPath, int totalNodeSize) {
+ this.nodeName = nodeName;
+ this.sharedKey = sharedKey;
+ this.peerPath = peerPath;
+ this.totalNodeSize = totalNodeSize;
+ }
+
+ public LedgerPeerInstall initKey(String ledgerKey, String ledgerAndNodeKey) {
+ this.ledgerKey = ledgerKey;
+ this.ledgerAndNodeKey = ledgerAndNodeKey;
+ return this;
+ }
+
+ public LedgerPeerInstall initMasterAddr(MasterAddr masterAddr) {
+ this.masterAddr = masterAddr;
+ return this;
+ }
+
+ public LedgerPeerInstall initCreateTime(Date date) {
+ createTime = SDF.format(date);
+ return this;
+ }
+
+ public String getLedgerKey() {
+ return ledgerKey;
+ }
+
+ public void setLedgerKey(String ledgerKey) {
+ this.ledgerKey = ledgerKey;
+ }
+
+ public String getLedgerAndNodeKey() {
+ return ledgerAndNodeKey;
+ }
+
+ public void setLedgerAndNodeKey(String ledgerAndNodeKey) {
+ this.ledgerAndNodeKey = ledgerAndNodeKey;
+ }
+
+ public String getNodeName() {
+ return nodeName;
+ }
+
+ public void setNodeName(String nodeName) {
+ this.nodeName = nodeName;
+ }
+
+ public String getSharedKey() {
+ return sharedKey;
+ }
+
+ public void setSharedKey(String sharedKey) {
+ this.sharedKey = sharedKey;
+ }
+
+ public String getPeerPath() {
+ return peerPath;
+ }
+
+ public void setPeerPath(String peerPath) {
+ this.peerPath = peerPath;
+ }
+
+ public int getTotalNodeSize() {
+ return totalNodeSize;
+ }
+
+ public void setTotalNodeSize(int totalNodeSize) {
+ this.totalNodeSize = totalNodeSize;
+ }
+
+ public String getCreateTime() {
+ return createTime;
+ }
+
+ public void setCreateTime(String createTime) {
+ this.createTime = createTime;
+ }
+
+ public MasterAddr getMasterAddr() {
+ return masterAddr;
+ }
+
+ public void setMasterAddr(MasterAddr masterAddr) {
+ this.masterAddr = masterAddr;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/PeerInstallSchedule.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/PeerInstallSchedule.java
new file mode 100644
index 00000000..dc85343a
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/PeerInstallSchedule.java
@@ -0,0 +1,32 @@
+package com.jd.blockchain.ump.model.state;
+
+public class PeerInstallSchedule {
+
+ private InstallProcess process;
+
+ private ScheduleState state;
+
+ public PeerInstallSchedule() {
+ }
+
+ public PeerInstallSchedule(InstallProcess process, ScheduleState state) {
+ this.process = process;
+ this.state = state;
+ }
+
+ public InstallProcess getProcess() {
+ return process;
+ }
+
+ public void setProcess(InstallProcess process) {
+ this.process = process;
+ }
+
+ public ScheduleState getState() {
+ return state;
+ }
+
+ public void setState(ScheduleState state) {
+ this.state = state;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/PeerInstallSchedules.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/PeerInstallSchedules.java
new file mode 100644
index 00000000..d6aaa7b1
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/PeerInstallSchedules.java
@@ -0,0 +1,61 @@
+package com.jd.blockchain.ump.model.state;
+
+import com.jd.blockchain.ump.model.config.LedgerIdentification;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PeerInstallSchedules {
+
+ private String ledgerHash;
+
+ private LedgerIdentification identification;
+
+ private List installSchedules = new ArrayList<>();
+
+ public PeerInstallSchedules() {
+ }
+
+ public PeerInstallSchedules(LedgerIdentification identification) {
+ this.identification = identification;
+ }
+
+ public PeerInstallSchedules(LedgerIdentification identification, String ledgerHash) {
+ this.identification = identification;
+ this.ledgerHash = ledgerHash;
+ }
+
+ public PeerInstallSchedules addInstallSchedule(PeerInstallSchedule installSchedule) {
+ this.installSchedules.add(installSchedule);
+ return this;
+ }
+
+ public PeerInstallSchedules initLedgerHash(String ledgerHash) {
+ setLedgerHash(ledgerHash);
+ return this;
+ }
+
+ public String getLedgerHash() {
+ return ledgerHash;
+ }
+
+ public void setLedgerHash(String ledgerHash) {
+ this.ledgerHash = ledgerHash;
+ }
+
+ public LedgerIdentification getIdentification() {
+ return identification;
+ }
+
+ public void setIdentification(LedgerIdentification identification) {
+ this.identification = identification;
+ }
+
+ public List getInstallSchedules() {
+ return installSchedules;
+ }
+
+ public void setInstallSchedules(List installSchedules) {
+ this.installSchedules = installSchedules;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/PeerStartupSchedules.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/PeerStartupSchedules.java
new file mode 100644
index 00000000..ba9ac9da
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/PeerStartupSchedules.java
@@ -0,0 +1,40 @@
+package com.jd.blockchain.ump.model.state;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PeerStartupSchedules {
+
+ private String peerPath;
+
+ private List installSchedules = new ArrayList<>();
+
+ public PeerStartupSchedules() {
+ }
+
+ public PeerStartupSchedules(String peerPath) {
+ this.peerPath = peerPath;
+ }
+
+
+ public PeerStartupSchedules addInstallSchedule(PeerInstallSchedule installSchedule) {
+ this.installSchedules.add(installSchedule);
+ return this;
+ }
+
+ public List getInstallSchedules() {
+ return installSchedules;
+ }
+
+ public void setInstallSchedules(List installSchedules) {
+ this.installSchedules = installSchedules;
+ }
+
+ public String getPeerPath() {
+ return peerPath;
+ }
+
+ public void setPeerPath(String peerPath) {
+ this.peerPath = peerPath;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/ScheduleState.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/ScheduleState.java
new file mode 100644
index 00000000..6307e498
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/ScheduleState.java
@@ -0,0 +1,43 @@
+package com.jd.blockchain.ump.model.state;
+
+public enum ScheduleState {
+
+ /**
+ * 加载内容,包括获取各种数据列表
+ */
+ LOAD,
+ LOAD_SUCCESS, // 加载成功
+ LOAD_FAIL, // 加载失败
+
+ /**
+ * 将获取的数据写入文件
+ *
+ */
+ WRITE,
+ WRITE_SUCCESS, // 写入文件成功
+ WRITE_FAIL, // 写入文件失败
+
+ /**
+ * Ledger_INIT:账本初始化过程
+ * 主要是调用SHELL
+ *
+ */
+ INIT,
+ INIT_SUCCESS, // 账本初始化成功
+ INIT_FAIL, // 账本初始化失败
+
+ /**
+ * 无须启动PEER,等待PEER自动更新账本信息
+ */
+ NO_STARTUP,
+
+ /**
+ * 启动Peer节点
+ */
+ STARTUP_START,
+ STARTUP_OVER,
+ STARTUP_SUCCESS, // Peer节点启动成功
+ STARTUP_FAIL, // Peer节点启动失败
+ ;
+
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/StartupState.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/StartupState.java
new file mode 100644
index 00000000..d605ccd8
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/state/StartupState.java
@@ -0,0 +1,48 @@
+package com.jd.blockchain.ump.model.state;
+
+public enum StartupState {
+
+ /**
+ * UNEXIST
+ * 不存在,描述该账本Hash曾经创建,但目前在LedgerBinding.conf文件中不存在
+ * 此状态不支持任何其他操作
+ */
+ UNEXIST,
+
+ /**
+ * UNLOAD
+ * 账本存在,但未加载
+ * 此状态可以启动,不能停止
+ */
+ UNLOAD,
+
+ /**
+ * LOADING
+ * 账本加载中,说明程序已经启动,但尚未加载该程序
+ * 此状态不可以启动,不建议停止
+ */
+ LOADING,
+
+ /**
+ * LOADED
+ * 账本已加载
+ * 此状态不可以启动,后续可以支持停止操作
+ */
+ LOADED,
+
+ /**
+ * UNKNOWN
+ * 未知,常见于命令检测执行错误或程序启动,但账本尚未加载完成
+ * 此状态不支持任何其他操作
+ */
+ UNKNOWN,
+
+ /**
+ * DB_UNEXIST
+ * 该账本对应的数据库不存在
+ * 此状态不支持任何其他操作
+ */
+ DB_UNEXIST,
+
+ ;
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/user/UserKeyBuilder.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/user/UserKeyBuilder.java
new file mode 100644
index 00000000..e3967c01
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/user/UserKeyBuilder.java
@@ -0,0 +1,34 @@
+package com.jd.blockchain.ump.model.user;
+
+public class UserKeyBuilder {
+
+ private String name;
+
+ private String seed;
+
+ private String pwd;
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public String getSeed() {
+ return seed;
+ }
+
+ public void setSeed(String seed) {
+ this.seed = seed;
+ }
+
+ public String getPwd() {
+ return pwd;
+ }
+
+ public void setPwd(String pwd) {
+ this.pwd = pwd;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/user/UserKeys.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/user/UserKeys.java
new file mode 100644
index 00000000..121d3ed7
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/user/UserKeys.java
@@ -0,0 +1,68 @@
+package com.jd.blockchain.ump.model.user;
+
+public class UserKeys {
+
+ private int id;
+
+ private String name;
+
+ private String privKey;
+
+ private String pubKey;
+
+ private String encodePwd;
+
+ public UserKeys() {
+ }
+
+ public UserKeys(String name, String privKey, String pubKey, String encodePwd) {
+ this.name = name;
+ this.privKey = privKey;
+ this.pubKey = pubKey;
+ this.encodePwd = encodePwd;
+ }
+
+ public int getId() {
+ return id;
+ }
+
+ public void setId(int id) {
+ this.id = id;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public String getPrivKey() {
+ return privKey;
+ }
+
+ public void setPrivKey(String privKey) {
+ this.privKey = privKey;
+ }
+
+ public String getPubKey() {
+ return pubKey;
+ }
+
+ public void setPubKey(String pubKey) {
+ this.pubKey = pubKey;
+ }
+
+ public String getEncodePwd() {
+ return encodePwd;
+ }
+
+ public void setEncodePwd(String encodePwd) {
+ this.encodePwd = encodePwd;
+ }
+
+ public UserKeysVv toUserKeysVv() {
+ return new UserKeysVv(id, name, privKey, pubKey);
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/user/UserKeysVv.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/user/UserKeysVv.java
new file mode 100644
index 00000000..90eaae9c
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/user/UserKeysVv.java
@@ -0,0 +1,69 @@
+package com.jd.blockchain.ump.model.user;
+
+public class UserKeysVv {
+
+ public static final int PRIVKEY_HEADER_LENGTH = 4;
+
+ public static final int PRIVKEY_TAIL_LENGTH = 8;
+
+ public static final String PRIVKEY_HIDE_CONTENT = "******";
+
+ private int id;
+
+ private String name;
+
+ private String privKey;
+
+ private String pubKey;
+
+ public UserKeysVv() {
+ }
+
+ public UserKeysVv(int id, String name, String privKey, String pubKey) {
+ this.id = id;
+ this.name = name;
+ this.privKey = encodePrivKey(privKey);
+ this.pubKey = pubKey;
+ }
+
+ public int getId() {
+ return id;
+ }
+
+ public void setId(int id) {
+ this.id = id;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public String getPrivKey() {
+ return privKey;
+ }
+
+ public void setPrivKey(String privKey) {
+ this.privKey = privKey;
+ }
+
+ public String getPubKey() {
+ return pubKey;
+ }
+
+ public void setPubKey(String pubKey) {
+ this.pubKey = pubKey;
+ }
+
+ private String encodePrivKey(final String privKey) {
+ if (privKey != null && privKey.length() > (PRIVKEY_HEADER_LENGTH + PRIVKEY_TAIL_LENGTH)) {
+ return privKey.substring(0, PRIVKEY_HEADER_LENGTH) +
+ PRIVKEY_HIDE_CONTENT +
+ privKey.substring(privKey.length() - PRIVKEY_TAIL_LENGTH);
+ }
+ return privKey;
+ }
+}
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/web/ErrorCode.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/web/ErrorCode.java
new file mode 100644
index 00000000..ca023e05
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/web/ErrorCode.java
@@ -0,0 +1,20 @@
+package com.jd.blockchain.ump.model.web;
+
+/**
+ * 错误代码;
+ */
+public enum ErrorCode {
+
+ UNEXPECTED(5000),
+ ;
+
+ private int value;
+
+ ErrorCode(int value) {
+ this.value = value;
+ }
+
+ public int getValue() {
+ return value;
+ }
+}
\ No newline at end of file
diff --git a/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/web/WebResponse.java b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/web/WebResponse.java
new file mode 100644
index 00000000..29890518
--- /dev/null
+++ b/source/manager/ump-model/src/main/java/com/jd/blockchain/ump/model/web/WebResponse.java
@@ -0,0 +1,97 @@
+package com.jd.blockchain.ump.model.web;
+
+public class WebResponse {
+
+ private boolean success;
+
+ private T data;
+
+ private ErrorMessage error;
+
+ private WebResponse(){
+
+ }
+
+ public boolean isSuccess() {
+ return success;
+ }
+
+ public void setSuccess(boolean success) {
+ this.success = success;
+ }
+
+ public T getData() {
+ return data;
+ }
+
+ public void setData(T data) {
+ this.data = data;
+ }
+
+ public ErrorMessage getError() {
+ return error;
+ }
+
+ public void setError(ErrorMessage error) {
+ this.error = error;
+ }
+
+ public static WebResponse createSuccessResult(Object data){
+ WebResponse responseResult = new WebResponse();
+ responseResult.setSuccess(true);
+ responseResult.setData(data);
+ return responseResult;
+ }
+
+ public static WebResponse createFailureResult(int code, String message){
+ ErrorMessage errorMessage = new ErrorMessage(code, message);
+ return createFailureResult(errorMessage);
+ }
+
+ public static WebResponse createFailureResult(ErrorMessage errorMessage){
+ WebResponse responseResult = new WebResponse();
+ responseResult.setSuccess(false);
+ responseResult.setError(errorMessage);
+ return responseResult;
+ }
+
+
+
+ /**
+ * 错误消息实体
+ *
+ * @author liuxrb
+ *
+ */
+ public static class ErrorMessage {
+
+ private int errorCode;
+
+ private String errorMessage;
+
+ public ErrorMessage() {
+
+ }
+
+ public ErrorMessage(int errorCode, String errorMessage) {
+ this.errorCode = errorCode;
+ this.errorMessage = errorMessage;
+ }
+
+ public int getErrorCode() {
+ return errorCode;
+ }
+
+ public void setErrorCode(int errorCode) {
+ this.errorCode = errorCode;
+ }
+
+ public String getErrorMessage() {
+ return errorMessage;
+ }
+
+ public void setErrorMessage(String errorMessage) {
+ this.errorMessage = errorMessage;
+ }
+ }
+}
diff --git a/source/manager/ump-service/pom.xml b/source/manager/ump-service/pom.xml
new file mode 100644
index 00000000..b01c60cc
--- /dev/null
+++ b/source/manager/ump-service/pom.xml
@@ -0,0 +1,119 @@
+
+
+
+
+ manager
+ com.jd.blockchain
+ 1.1.0-SNAPSHOT
+
+ 4.0.0
+
+ ump-service
+
+ ump-service
+
+
+ UTF-8
+ 1.8
+ 1.8
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-web
+
+
+ org.springframework.boot
+ spring-boot-starter-logging
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-log4j2
+
+
+
+ org.springframework.boot
+ spring-boot-configuration-processor
+ true
+
+
+ org.springframework.boot
+ spring-boot-devtools
+ true
+
+
+
+ com.jd.blockchain
+ crypto-classic
+ ${project.version}
+
+
+
+ com.jd.blockchain
+ crypto-sm
+ ${project.version}
+
+
+
+ com.jd.blockchain
+ tools-keygen
+ ${project.version}
+
+
+
+ com.alibaba
+ fastjson
+
+
+
+ commons-io
+ commons-io
+
+
+
+ commons-codec
+ commons-codec
+
+
+
+ com.jd.blockchain
+ ump-model
+ ${project.version}
+
+
+
+ org.reflections
+ reflections
+
+
+
+ com.google.guava
+ guava
+
+
+
+ org.apache.httpcomponents
+ httpclient
+
+
+
+ com.sun
+ tools
+ 1.8
+ system
+ ${project.basedir}/../ump-booter/libs/tools.jar
+
+
+
+ junit
+ junit
+ test
+
+
+
diff --git a/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/LedgerService.java b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/LedgerService.java
new file mode 100644
index 00000000..77c11016
--- /dev/null
+++ b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/LedgerService.java
@@ -0,0 +1,31 @@
+package com.jd.blockchain.ump.service;
+
+import com.jd.blockchain.ump.model.state.LedgerBindingConf;
+import com.jd.blockchain.ump.model.state.LedgerInited;
+
+import java.util.List;
+
+public interface LedgerService {
+
+ String randomSeed();
+
+ String currentCreateTime();
+
+ String ledgerInitCommand(String peerPath);
+
+ String peerStartCommand(String peerPath);
+
+ LedgerBindingConf allLedgerHashs(String peerPath);
+
+ LedgerBindingConf allLedgerHashs(long lastTime, String peerPath);
+
+ List allLedgerIniteds(String peerPath);
+
+ boolean dbExist(String peerPath, String ledgerHash);
+
+ String peerVerifyKey(String peerPath);
+
+ void save(String ledgerAndNodeKey, String ledgerHash);
+
+ String readLedgerHash(String ledgerAndNodeKey);
+}
diff --git a/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/LedgerServiceHandler.java b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/LedgerServiceHandler.java
new file mode 100644
index 00000000..f78aef42
--- /dev/null
+++ b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/LedgerServiceHandler.java
@@ -0,0 +1,310 @@
+package com.jd.blockchain.ump.service;
+
+
+import com.jd.blockchain.ump.dao.DBConnection;
+import com.jd.blockchain.ump.model.UmpConstant;
+import com.jd.blockchain.ump.model.state.LedgerBindingConf;
+import com.jd.blockchain.ump.model.state.LedgerInited;
+import org.apache.commons.codec.binary.Hex;
+import org.apache.commons.io.FileUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.text.SimpleDateFormat;
+import java.util.*;
+
+@Service
+public class LedgerServiceHandler implements LedgerService {
+
+ private static final SimpleDateFormat SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSSZ");
+
+ private static final String LEDGER_HASHS_FLAG = "ledger.bindings";
+
+ private static final String LEDGER_NAME_FORMAT = "binding.%s.name";
+
+ private static final String LEDGER_PARTI_ADDRESS_FORMAT = "binding.%s.parti.address";
+
+ private static final String LEDGER_PARTI_NAME_FORMAT = "binding.%s.parti.name";
+
+ private static final String LEDGER_DB_FORMAT = "binding.%s.db.uri";
+
+ private static final String FILE_PEER_FLAG = "deployment-peer";
+
+ private static final String JAR_SUFFIX = "jar";
+
+ private static final int SEED_BYTES_LENGTH = 32;
+
+ private static final int NAME_BYTES_LENGTH = 8;
+
+ private static final int SEED_PART_LENGTH = 8;
+
+ private static final Random LEDGER_RANDOM = new Random();
+
+ @Autowired
+ private UmpStateService umpStateService;
+
+ @Autowired
+ private DBConnection dbConnection;
+
+ @Override
+ public String randomSeed() {
+ byte[] seedBytes = new byte[SEED_BYTES_LENGTH];
+
+ LEDGER_RANDOM.nextBytes(seedBytes);
+
+ char[] seedChars = Hex.encodeHex(seedBytes);
+
+ StringBuilder sBuilder = new StringBuilder();
+
+ for (int i = 0; i < seedChars.length; i++) {
+ if (i != 0 && i % SEED_PART_LENGTH == 0) {
+ sBuilder.append("-");
+ }
+ sBuilder.append(seedChars[i]);
+ }
+
+ return sBuilder.toString();
+ }
+
+ @Override
+ public String currentCreateTime() {
+ return SDF.format(new Date());
+ }
+
+ @Override
+ public String ledgerInitCommand(String peerPath) {
+
+ return String.format(UmpConstant.CMD_LEDGER_INIT,
+ peerPath + UmpConstant.PATH_LEDGER_INIT_BIN);
+ }
+
+ @Override
+ public String peerStartCommand(String peerPath) {
+ return String.format(UmpConstant.CMD_START_UP_FORMAT,
+ peerPath + UmpConstant.PATH_STARTUP_BIN);
+ }
+
+ @Override
+ public LedgerBindingConf allLedgerHashs(String peerPath) {
+
+ return allLedgerHashs(0L, peerPath);
+ }
+
+ @Override
+ public LedgerBindingConf allLedgerHashs(long lastTime, String peerPath) {
+
+ // 读取LedgerBingConf文件,假设该文件不存在则返回空值
+ Set allLedgerHashs = new HashSet<>();
+
+ PropAndTime propAndTime = loadLedgerBindingConf(lastTime, peerPath);
+
+ Properties props = propAndTime.getProp();
+
+ if (props != null) {
+
+ String ledgerHashChars = props.getProperty(LEDGER_HASHS_FLAG);
+
+ if (ledgerHashChars != null && ledgerHashChars.length() > 0) {
+ String[] ledgerHashArray = ledgerHashChars.split(",");
+ if (ledgerHashArray.length > 0) {
+ for (String ledgerHash : ledgerHashArray) {
+ allLedgerHashs.add(ledgerHash.trim());
+ }
+ }
+ }
+ }
+
+ LedgerBindingConf ledgerBindingConf = new LedgerBindingConf(propAndTime.getLastTime());
+
+ ledgerBindingConf.setLedgerHashs(allLedgerHashs);
+
+ return ledgerBindingConf;
+ }
+
+ @Override
+ public List allLedgerIniteds(String peerPath) {
+
+ List ledgerIniteds = new ArrayList<>();
+
+ PropAndTime propAndTime = loadLedgerBindingConf(0L, peerPath);
+
+ Properties props = propAndTime.getProp();
+
+ if (props != null) {
+
+ String ledgerHashChars = props.getProperty(LEDGER_HASHS_FLAG);
+
+ Set ledgerHashSet = new HashSet<>();
+
+ if (ledgerHashChars != null && ledgerHashChars.length() > 0) {
+ String[] ledgerHashArray = ledgerHashChars.split(",");
+ if (ledgerHashArray.length > 0) {
+ for (String ledgerHash : ledgerHashArray) {
+ ledgerHashSet.add(ledgerHash.trim());
+ }
+ }
+ }
+
+ // 根据Hash值,遍历Prop
+ for (String hash : ledgerHashSet) {
+
+ LedgerInited ledgerInited = new LedgerInited(hash);
+
+ String ledgerName = props.getProperty(String.format(LEDGER_NAME_FORMAT, hash));
+
+ String partiAddress = props.getProperty(String.format(LEDGER_PARTI_ADDRESS_FORMAT, hash));
+
+ String partiName = props.getProperty(String.format(LEDGER_PARTI_NAME_FORMAT, hash));
+
+ String dbUri = props.getProperty(String.format(LEDGER_DB_FORMAT, hash));
+
+ ledgerIniteds.add(
+ ledgerInited
+ .buildLedgerName(ledgerName)
+ .buildPartiAddress(partiAddress)
+ .buildPartiName(partiName)
+ .buildDbUri(dbUri));
+ }
+ }
+ return ledgerIniteds;
+ }
+
+ @Override
+ public synchronized boolean dbExist(String peerPath, String ledgerHash) {
+ // 检查该账本对应的数据库是否存在
+
+ PropAndTime propAndTime = loadLedgerBindingConf(0L, peerPath);
+
+ // binding.j5faRYSqSqSRmSVgdmPsgq7Hzd1yP7yAGPWkTihekWms94.db.uri=rocksdb:///Users/shaozhuguang/Documents/ideaProjects/jdchain-patch/source/test/test-integration/rocks.db/rocksdb4.db
+ Properties props = propAndTime.getProp();
+
+ if (props != null) {
+ String dbKey = String.format(LEDGER_DB_FORMAT, ledgerHash);
+
+ String dbUri = props.getProperty(dbKey);
+
+ if (dbUri != null && dbUri.length() > 0) {
+
+ return dbConnection.exist(dbUri);
+ }
+ }
+
+ return false;
+ }
+
+ @Override
+ public String peerVerifyKey(String peerPath) {
+ // 从libs中读取对应的Peer.jar的文件名称,配合全路径
+ File libsDirectory = new File(peerPath + UmpConstant.PATH_SYSTEM);
+
+ Collection jars = FileUtils.listFiles(libsDirectory, new String[]{JAR_SUFFIX}, false);
+
+ String peerVerifyKey = null;
+
+ if (!jars.isEmpty()) {
+ for (File jar : jars) {
+ String jarName = jar.getName();
+ if (jarName.startsWith(FILE_PEER_FLAG)) {
+ peerVerifyKey = jar.getPath();
+ break;
+ }
+ }
+ }
+
+ return peerVerifyKey;
+ }
+
+ @Override
+ public void save(String ledgerAndNodeKey, String ledgerHash) {
+ // 保存LedgerAndNodeKey与账本关系
+ umpStateService.saveLedgerHash(ledgerAndNodeKey, ledgerHash);
+ }
+
+ @Override
+ public String readLedgerHash(String ledgerAndNodeKey) {
+
+ return umpStateService.readLedgerHash(ledgerAndNodeKey);
+ }
+
+ private PropAndTime loadLedgerBindingConf(long lastTime, String peerPath) {
+
+ File ledgerBindingConf = new File(peerPath + UmpConstant.PATH_LEDGER_BINDING_CONFIG);
+
+ PropAndTime propAndTime = new PropAndTime(lastTime);
+
+ // 说明被修改过
+ if (ledgerBindingConf.exists() && ledgerBindingConf.lastModified() > lastTime) {
+
+ propAndTime.lastTime = ledgerBindingConf.lastModified();
+
+ try (InputStream inputStream = new FileInputStream(ledgerBindingConf)) {
+
+ Properties props = new Properties();
+
+ props.load(inputStream);
+
+ propAndTime.prop = props;
+
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ return propAndTime;
+ }
+
+ private static class PropAndTime {
+
+ private Properties prop;
+
+ private long lastTime;
+
+ public PropAndTime() {
+ }
+
+ public PropAndTime(long lastTime) {
+ this.lastTime = lastTime;
+ }
+
+ public Properties getProp() {
+ return prop;
+ }
+
+ public void setProp(Properties prop) {
+ this.prop = prop;
+ }
+
+ public long getLastTime() {
+ return lastTime;
+ }
+
+ public void setLastTime(long lastTime) {
+ this.lastTime = lastTime;
+ }
+ }
+
+// private Properties loadLedgerBindingConf(String peerPath) {
+//
+// File ledgerBindingConf = new File(peerPath + UmpConstant.PATH_LEDGER_BINDING_CONFIG);
+//
+// if (ledgerBindingConf.exists()) {
+//
+// try (InputStream inputStream = new FileInputStream(ledgerBindingConf)) {
+//
+// Properties props = new Properties();
+//
+// props.load(inputStream);
+//
+// return props;
+//
+// } catch (Exception e) {
+// throw new IllegalStateException(e);
+// }
+// }
+//
+// return null;
+// }
+}
diff --git a/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpService.java b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpService.java
new file mode 100644
index 00000000..08e1ee4a
--- /dev/null
+++ b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpService.java
@@ -0,0 +1,36 @@
+package com.jd.blockchain.ump.service;
+
+import com.jd.blockchain.ump.model.MasterAddr;
+import com.jd.blockchain.ump.model.PeerSharedConfigs;
+import com.jd.blockchain.ump.model.config.*;
+import com.jd.blockchain.ump.model.state.PeerInstallSchedules;
+import com.jd.blockchain.ump.model.state.PeerStartupSchedules;
+
+
+public interface UmpService {
+
+ PeerSharedConfigs loadPeerSharedConfigs(PeerLocalConfig sharedConfig);
+
+ LedgerConfig response(PeerSharedConfigs peerSharedConfigs, PeerLocalConfig localConfig);
+
+ String save(MasterAddr masterAddr, LedgerConfig ledgerConfig, PeerLocalConfig localConfig);
+
+ String ledgerAndNodeKey(LedgerConfig ledgerConfig, PeerSharedConfig sharedConfig);
+
+ PeerInstallSchedules install(LedgerIdentification identification, PeerLocalConfig localConfig, String ledgerAndNodeKey);
+
+ PeerInstallSchedules install(String ledgerAndNodeKey);
+
+ PeerInstallSchedules init(String ledgerAndNodeKey);
+
+ PeerInstallSchedules init(LedgerIdentification identification, PeerLocalConfig localConfig, String ledgerAndNodeKey);
+
+// PeerInstallSchedules startup(String ledgerAndNodeKey);
+
+ PeerStartupSchedules startup();
+
+ boolean stop(String ledgerAndNodeKey);
+
+ boolean stop();
+
+}
diff --git a/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpServiceHandler.java b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpServiceHandler.java
new file mode 100644
index 00000000..c17cc309
--- /dev/null
+++ b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpServiceHandler.java
@@ -0,0 +1,925 @@
+package com.jd.blockchain.ump.service;
+
+
+import com.jd.blockchain.ump.dao.DBConnection;
+import com.jd.blockchain.ump.dao.RocksDBConnection;
+import com.jd.blockchain.ump.model.MasterAddr;
+import com.jd.blockchain.ump.model.PeerSharedConfigs;
+import com.jd.blockchain.ump.model.UmpConstant;
+import com.jd.blockchain.ump.model.config.*;
+import com.jd.blockchain.ump.model.state.*;
+import com.jd.blockchain.ump.service.consensus.ConsensusService;
+import com.jd.blockchain.ump.util.Base58Utils;
+import com.jd.blockchain.ump.util.CommandUtils;
+import org.apache.commons.io.FileUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.text.SimpleDateFormat;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.Lock;
+
+@Service
+public class UmpServiceHandler implements UmpService {
+
+ private final Logger LOGGER = LoggerFactory.getLogger(getClass());
+
+ private static final String SUCCESS = "SUCCESS";
+
+ private static final String ROCKSDB_PROTOCOL = RocksDBConnection.ROCKSDB_PROTOCOL;
+
+ private static final int DB_SUFFIX_LENGTH = 4;
+
+ private static final Random DB_RANDOM = new Random();
+
+ private static final SimpleDateFormat SDF = new SimpleDateFormat("yyyyMMddHHmmssSSS");//yyyy-MM-dd HH:mm:ss为目标的样式
+
+ private final Map ledgerConfigs = new ConcurrentHashMap<>();
+
+ private final Map masterConfigs = new ConcurrentHashMap<>();
+
+ private final Map peerShareds = new ConcurrentHashMap<>();
+
+ private final Map ledgerConfigMemory = new ConcurrentHashMap<>();
+
+ @Autowired
+ private ConsensusService consensusService;
+
+ @Autowired
+ private LedgerService ledgerService;
+
+ @Autowired
+ private DBConnection dbConnection;
+
+ @Autowired
+ private UmpStateService umpStateService;
+
+ @Override
+ public synchronized PeerSharedConfigs loadPeerSharedConfigs(PeerLocalConfig sharedConfig) {
+
+ String sharedKey = sharedConfig.getSharedKey();
+
+ PeerSharedConfigs peerSharedConfigs = peerShareds.get(sharedKey);
+
+ if (peerSharedConfigs == null) {
+ peerSharedConfigs = new PeerSharedConfigs();
+ peerShareds.put(sharedKey, peerSharedConfigs);
+ }
+
+ return peerSharedConfigs.addConfig(sharedConfig);
+ }
+
+ @Override
+ public LedgerConfig response(PeerSharedConfigs sharedConfigs, PeerLocalConfig localConfig) {
+ try {
+ // 对于Master和Peer处理方式不同
+ if (localConfig.getMasterConfig().isMaster()) {
+
+ // Master节点需要等待完成后通知其他线程
+ sharedConfigs.waitAndNotify();
+ } else {
+
+ // 等待Master节点通知
+ sharedConfigs.await();
+ }
+
+ // 此处需要防止并发
+ final String sharedKey = sharedConfigs.getSharedKey();
+
+ LedgerConfig savedLedgerConfig = ledgerConfigMemory.get(sharedKey);
+
+ if (savedLedgerConfig != null) {
+ return savedLedgerConfig;
+ }
+
+ // 获取当前对象锁(所有节点请求使用同一个对象)
+ final Lock lock = sharedConfigs.getLock();
+
+ lock.lock();
+
+ try {
+ // 执行到此表示获取到锁,此时需要判断是否有数据
+ // Double Check !!!
+ savedLedgerConfig = ledgerConfigMemory.get(sharedKey);
+
+ if (savedLedgerConfig != null) {
+ return savedLedgerConfig;
+ }
+
+ // 校验
+ verify(sharedConfigs);
+
+ // 所有数据到达之后生成返回的应答
+ LedgerInitConfig initConfig = sharedConfigs.ledgerInitConfig(
+ ledgerService.randomSeed(), ledgerService.currentCreateTime());
+
+ // 生成共识文件
+ String consensusConfig = consensusService.initConsensusConf(
+ sharedConfigs.getConsensusProvider(), sharedConfigs.getSharedConfigs());
+
+ LedgerConfig ledgerConfig = new LedgerConfig(initConfig, consensusConfig);
+
+ // 将本次LedgerKey信息写入数据库
+ String ledgerKey = initConfig.ledgerKey();
+
+ dbConnection.put(ledgerKey, ledgerConfig, LedgerConfig.class);
+
+ // 将节点的Key信息写入数据库
+ umpStateService.save(ledgerKey, sharedConfigKeys(ledgerKey, sharedConfigs));
+
+ // 将本地生成数据的信息写入数据库
+ LedgerMasterInstall masterInstall = sharedConfigs.toLedgerMasterInstall();
+
+ umpStateService.save(masterInstall);
+
+ // 将数据放入内存
+ ledgerConfigMemory.put(sharedKey, ledgerConfig);
+
+ return ledgerConfig;
+ } finally {
+ lock.unlock();
+ }
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ @Override
+ public String save(MasterAddr masterAddr, LedgerConfig ledgerConfig, PeerLocalConfig localConfig) {
+
+ String ledgerAndNodeKey = ledgerAndNodeKey(ledgerConfig, localConfig);
+
+ ledgerConfigs.put(ledgerAndNodeKey, ledgerConfig);
+
+ // 保存本次需要发送的Master地址
+ masterConfigs.put(ledgerAndNodeKey, localConfig.getMasterConfig());
+
+ // 保存所有的信息至本地
+ umpStateService.save(ledgerAndNodeKey, localConfig);
+
+ // 保存当前同步信息至数据库
+ LedgerPeerInstall peerInstall = localConfig.toLedgerPeerInstall(ledgerConfig.getInitConfig().getNodeSize());
+
+ // init相关配置信息
+ peerInstall
+ .initKey(ledgerConfig.getInitConfig().ledgerKey(), ledgerAndNodeKey)
+ .initCreateTime(new Date())
+ .initMasterAddr(masterAddr);
+
+ // 写入数据库
+ umpStateService.save(peerInstall);
+
+ return ledgerAndNodeKey;
+ }
+
+ @Override
+ public String ledgerAndNodeKey(LedgerConfig ledgerConfig, PeerSharedConfig sharedConfig) {
+
+ return ledgerAndNodeKey(ledgerConfig.getInitConfig().ledgerKey(), sharedConfig);
+ }
+
+ @Override
+ public PeerInstallSchedules install(LedgerIdentification identification, PeerLocalConfig localConfig, String ledgerAndNodeKey) {
+
+ // 初始化Peer节点数据
+ PeerInstallSchedules installSchedules = init(identification, localConfig, ledgerAndNodeKey);
+
+ // Peer节点启动
+ peerStart(localConfig.getPeerPath(), installSchedules);
+
+ return installSchedules;
+ }
+
+ @Override
+ public PeerInstallSchedules install(String ledgerAndNodeKey) {
+
+ PeerLocalConfig localConfig = umpStateService.readConfig(ledgerAndNodeKey);
+
+ if (localConfig != null) {
+
+ // 获取LedgerIdentification
+ LedgerIdentification identification = umpStateService.readIdentification(ledgerAndNodeKey);
+
+ return install(identification, localConfig, ledgerAndNodeKey);
+ }
+ throw new IllegalStateException("Can not find LocalConfig from DataBase !!!");
+ }
+
+ @Override
+ public PeerInstallSchedules init(LedgerIdentification identification, PeerLocalConfig localConfig, String ledgerAndNodeKey) {
+
+ PeerInstallSchedules installSchedules = new PeerInstallSchedules(identification);
+
+ MasterAddr masterAddr = loadMaster(localConfig);
+
+ LedgerConfig ledgerConfig = ledgerConfigs.get(ledgerAndNodeKey);
+
+ if (ledgerConfig == null || ledgerConfig.getInitConfig() == null) {
+ saveInstallSchedule(installSchedules, masterAddr, "", ledgerAndNodeKey,
+ String.format("Ledger Key = [%s] can not find Ledger-Config !!!", ledgerAndNodeKey),
+ ScheduleState.LOAD_FAIL);
+ throw new IllegalStateException(String.format("Ledger Key = [%s] can not find Ledger-Config !!!", ledgerAndNodeKey));
+ }
+
+ LedgerInitConfig initConfig = ledgerConfig.getInitConfig();
+
+ String ledgerKey = initConfig.ledgerKey();
+
+ List localConfContents, ledgerInitContents;
+
+ try {
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ String.format("Find LedgerConfig from Memory for Key [%s] -> %s", ledgerAndNodeKey, SUCCESS),
+ ScheduleState.LOAD);
+
+ // 首先获取当前节点的ID
+ int nodeId = initConfig.nodeId(localConfig.getPubKey());
+
+ // 生成local.conf文件内容
+ localConfContents = localConfContents(localConfig, nodeId);
+
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ String.format("Init Local.Conf's Content -> %s", SUCCESS),
+ ScheduleState.LOAD);
+
+ // 生成LedgerInit内容
+ ledgerInitContents = initConfig.toConfigChars(localConfig.consensusConfPath());
+
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ String.format("Init Ledger.Init's Content -> %s", SUCCESS),
+ ScheduleState.LOAD);
+ } catch (Exception e) {
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ "Load Config's Content !!!",
+ ScheduleState.LOAD_FAIL);
+ throw new IllegalStateException(e);
+ }
+
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ "Load Config's Content !!!",
+ ScheduleState.LOAD_SUCCESS);
+
+ try {
+ // 将该文件内容写入Local.Conf
+ forceWrite(localConfContents, new File(localConfig.localConfPath()));
+
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ String.format("Write And Backup File local.conf -> %s", SUCCESS),
+ ScheduleState.WRITE);
+
+ // 将文件内容写入Ledger-Init
+ forceWrite(ledgerInitContents, new File(localConfig.ledgerInitConfPath()));
+
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ String.format("Write And Backup File ledger.init -> %s", SUCCESS),
+ ScheduleState.WRITE);
+
+ // 将共识内容写入文件,例如bftsmart.conf
+ String consensusFileName = writeConsensusContent(ledgerConfig.getConsensusConfig(),
+ new File(localConfig.consensusConfPath()));
+
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ String.format("Write And Backup Consensus File %s -> %s", consensusFileName, SUCCESS),
+ ScheduleState.WRITE);
+
+ } catch (Exception e) {
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ "Write Config's Content to Config File !!!",
+ ScheduleState.WRITE_FAIL);
+ throw new IllegalStateException(e);
+ }
+
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ "Write Config's Content to Config File !!!",
+ ScheduleState.WRITE_SUCCESS);
+
+ // 账本初始化
+ String ledgerHash = ledgerInit(localConfig.getPeerPath(), installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey);
+
+ // 设置账本Hash
+ installSchedules.setLedgerHash(ledgerHash);
+
+ return installSchedules;
+ }
+
+ @Override
+ public PeerInstallSchedules init(String ledgerAndNodeKey) {
+
+ PeerLocalConfig localConfig = umpStateService.readConfig(ledgerAndNodeKey);
+
+ if (localConfig != null) {
+
+ // 获取LedgerIdentification
+ LedgerIdentification identification = umpStateService.readIdentification(ledgerAndNodeKey);
+
+ return init(identification, localConfig, ledgerAndNodeKey);
+ }
+ throw new IllegalStateException("Can not find LocalConfig from DataBase !!!");
+ }
+
+
+// @Override
+// public PeerInstallSchedules startup(String ledgerAndNodeKey) {
+//
+// PeerLocalConfig localConfig = umpStateService.readConfig(ledgerAndNodeKey);
+//
+// if (localConfig != null) {
+//
+// PeerInstallSchedules installSchedules = umpStateService.loadState(ledgerAndNodeKey);
+//
+// // Peer节点启动
+// return peerStart(localConfig.getPeerPath(), installSchedules);
+//
+// }
+// throw new IllegalStateException("Can not find LocalConfig from DataBase !!!");
+// }
+
+ @Override
+ public PeerStartupSchedules startup() {
+
+ PeerStartupSchedules startupSchedules = new PeerStartupSchedules(UmpConstant.PROJECT_PATH);
+
+ return peerStart(startupSchedules);
+ }
+
+ @Override
+ public boolean stop(String ledgerAndNodeKey) {
+ PeerLocalConfig localConfig = umpStateService.readConfig(ledgerAndNodeKey);
+
+ if (localConfig != null) {
+
+ // Peer节点停止
+ return peerStop(localConfig.getPeerPath());
+ }
+ throw new IllegalStateException("Can not find LocalConfig from DataBase !!!");
+ }
+
+ @Override
+ public boolean stop() {
+
+ return peerStop(UmpConstant.PROJECT_PATH);
+ }
+
+ private MasterAddr loadMaster(PeerLocalConfig localConfig) {
+
+ // 开始安装之后则可以将内存中的数据释放
+ String sharedKey = localConfig.getSharedKey();
+
+ if (sharedKey != null) {
+ ledgerConfigMemory.remove(sharedKey);
+ }
+
+ if (localConfig.master()) {
+ return null;
+ }
+
+ return localConfig.masterAddr();
+ }
+
+ private List sharedConfigKeys(String ledgerKey, PeerSharedConfigs sharedConfigs) {
+
+ List sharedConfigKeys = new ArrayList<>();
+
+ List pscs = sharedConfigs.getSharedConfigs();
+
+ for(PeerSharedConfig psc : pscs) {
+ sharedConfigKeys.add(ledgerAndNodeKey(ledgerKey, psc));
+ }
+
+ return sharedConfigKeys;
+ }
+
+ private String ledgerAndNodeKey(String ledgerKey, PeerSharedConfig sharedConfig) {
+
+ return ledgerKey + "-" + sharedConfig.getName();
+ }
+
+ private String ledgerInit(String peerPath, PeerInstallSchedules installSchedules, MasterAddr masterAddr, String ledgerKey, String ledgerAndNodeKey) {
+
+ String newLedgerHash = "";
+
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ "Steps to start processing LedgerInit !!!",
+ ScheduleState.INIT);
+
+ // 获取当前已经存在的Ledger列表
+ LedgerBindingConf ledgerBindingConf = ledgerService.allLedgerHashs(peerPath);
+
+ Set currentLedgerHashs = ledgerBindingConf.getLedgerHashs();
+
+ long lastTime = ledgerBindingConf.getLastTime();
+
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ String.format("Find History Ledger's Size = %s", currentLedgerHashs.size()),
+ ScheduleState.INIT);
+
+ String ledgerInitCommand = ledgerService.ledgerInitCommand(peerPath);
+
+ try {
+
+ LOGGER.info("Execute Ledger-Init's Shell {}", ledgerInitCommand);
+
+ Process ledgerInitProcess;
+
+ try {
+ // 调用ledgerInit初始化脚本
+ ledgerInitProcess = CommandUtils.execute(CommandUtils.toCommandList(ledgerInitCommand));
+
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ String.format("Execute LedgerInit's Command -> %s", SUCCESS),
+ ScheduleState.INIT);
+ } catch (Exception e) {
+ LOGGER.error("Execute Ledger-Init's Shell !!!", e);
+ throw new IllegalStateException(e);
+ }
+
+ int maxSize = 512;
+
+ boolean isInitSuccess = false;
+
+ int checkIndex = 1;
+
+ while (maxSize > 0) {
+ // 时延
+ Thread.sleep(6000);
+
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ String.format("%s Check LedgerInit's Status ...... ", checkIndex++),
+ ScheduleState.INIT);
+
+ // 检查账本是否增加
+ CurrentLedger currentLedger = checkNewLedger(lastTime, peerPath, currentLedgerHashs);
+
+ lastTime = currentLedger.getLastTime();
+
+ newLedgerHash = currentLedger.getLedgerHash();
+
+ if (newLedgerHash != null && newLedgerHash.length() > 0) {
+ isInitSuccess = true;
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ String.format("Find New Ledger = %s", newLedgerHash),
+ ScheduleState.INIT);
+ break;
+ }
+ maxSize --;
+ }
+
+ // 完成后,不管是否处理完,都将命令停止
+ // 为防止其他应用仍在访问,延时6秒停止
+ try {
+ Thread.sleep(6000);
+ ledgerInitProcess = ledgerInitProcess.destroyForcibly();
+ if (ledgerInitProcess.isAlive()) {
+ // 再尝试一次
+ ledgerInitProcess.destroyForcibly();
+ }
+ } catch (Exception e) {
+ // 暂时打印日志
+ LOGGER.error("Stop Ledger Init Command !!!", e);
+ }
+
+ // 再次判断是否初始化账本成功
+ if (newLedgerHash == null) {
+
+ CurrentLedger currentLedger = checkNewLedger(lastTime, peerPath, currentLedgerHashs);
+
+ newLedgerHash = currentLedger.getLedgerHash();
+
+ if (newLedgerHash != null && newLedgerHash.length() > 0) {
+ isInitSuccess = true;
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ String.format("Final Find New Ledger = %s", newLedgerHash),
+ ScheduleState.INIT);
+ }
+ }
+
+ if (!isInitSuccess) {
+ // 失败则抛出异常
+ throw new IllegalStateException("Can Not Find New Ledger !!!");
+ }
+ } catch (Exception e) {
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ "Execute Ledger-Init Command Fail !!!",
+ ScheduleState.INIT_FAIL);
+ LOGGER.error("Execute Ledger-Init Command Fail !!!", e);
+ throw new IllegalStateException(e);
+ }
+
+ saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+ String.format("Steps to processing LedgerInit -> %s", SUCCESS),
+ ScheduleState.INIT_SUCCESS);
+
+ // 将账本Hash写入数据库
+ ledgerService.save(ledgerAndNodeKey, newLedgerHash);
+
+ return newLedgerHash;
+ }
+
+ private CurrentLedger checkNewLedger(long lastTime, String peerPath, Set currentLedgerHashs) {
+ // 再次判断是否初始化账本成功
+ LedgerBindingConf ledgerBindingConf = ledgerService.allLedgerHashs(lastTime, peerPath);
+
+ Set newLedgerHashs = ledgerBindingConf.getLedgerHashs();
+
+ CurrentLedger currentLedger = new CurrentLedger(ledgerBindingConf.getLastTime());
+
+ if (newLedgerHashs.size() > currentLedgerHashs.size()) {
+ // 获取其新安装的LedgerHash
+ for (String ledgerHash : newLedgerHashs) {
+ if (!currentLedgerHashs.contains(ledgerHash)) {
+ // 新获取的LedgerHash为当前值
+ currentLedger.ledgerHash = ledgerHash;
+ break;
+ }
+ }
+ }
+ return currentLedger;
+ }
+
+
+ private PeerInstallSchedules peerStart(String peerPath, PeerInstallSchedules installSchedules) {
+
+ saveInstallSchedule(installSchedules,
+ "Steps to start processing PeerNodeStart !!!",
+ ScheduleState.STARTUP_START);
+ // 启动Peer
+ // 说明初始化成功
+ // 判断是否需要启动Peer
+ String peerVerify = ledgerService.peerVerifyKey(peerPath);
+
+ try {
+ if (!CommandUtils.isActive(peerVerify)) {
+ // 不存在,则需要再启动
+ String peerStartCmd = ledgerService.peerStartCommand(peerPath);
+
+ LOGGER.info("Execute Peer-Startup's Shell {}", peerStartCmd);
+
+ if (!CommandUtils.executeAndVerify(CommandUtils.toCommandList(peerStartCmd), peerVerify)) {
+ // Peer节点启动失败
+ throw new IllegalStateException("Peer Node Start UP Fail !!!");
+ }
+ saveInstallSchedule(installSchedules,
+ String.format("Peer's process %s start -> %s", peerVerify, SUCCESS),
+ ScheduleState.STARTUP_SUCCESS);
+ } else {
+ // 命令已经存在
+ saveInstallSchedule(installSchedules,
+ String.format("Peer's process is exist -> %s", peerVerify),
+ ScheduleState.NO_STARTUP);
+ }
+ } catch (Exception e) {
+ saveInstallSchedule(installSchedules,
+ e.getMessage(),
+ ScheduleState.STARTUP_FAIL);
+ throw new IllegalStateException(e);
+ }
+
+ saveInstallSchedule(installSchedules,
+ "Steps to start processing PeerNodeStart over !!!",
+ ScheduleState.STARTUP_OVER);
+
+ return installSchedules;
+ }
+
+ private PeerStartupSchedules peerStart(PeerStartupSchedules startupSchedules) {
+
+ String peerPath = startupSchedules.getPeerPath();
+
+ saveStartupSchedules(startupSchedules,
+ "Steps to start processing PeerNodeStart !!!",
+ ScheduleState.STARTUP_START);
+ // 启动Peer
+ // 说明初始化成功
+ // 判断是否需要启动Peer
+ String peerVerify = ledgerService.peerVerifyKey(peerPath);
+
+ try {
+ if (!CommandUtils.isActive(peerVerify)) {
+ // 不存在,则需要再启动
+ String peerStartCmd = ledgerService.peerStartCommand(peerPath);
+
+ LOGGER.info("Execute Peer-Startup's Shell {}", peerStartCmd);
+
+ if (!CommandUtils.executeAndVerify(CommandUtils.toCommandList(peerStartCmd), peerVerify)) {
+ // Peer节点启动失败
+ throw new IllegalStateException("Peer Node Start UP Fail !!!");
+ }
+ saveStartupSchedules(startupSchedules,
+ String.format("Peer's process %s start -> %s", peerVerify, SUCCESS),
+ ScheduleState.STARTUP_SUCCESS);
+ } else {
+ // 命令已经存在
+ saveStartupSchedules(startupSchedules,
+ String.format("Peer's process is exist -> %s", peerVerify),
+ ScheduleState.NO_STARTUP);
+ }
+ } catch (Exception e) {
+ saveStartupSchedules(startupSchedules,
+ e.getMessage(),
+ ScheduleState.STARTUP_FAIL);
+ throw new IllegalStateException(e);
+ }
+
+ saveStartupSchedules(startupSchedules,
+ "Steps to start processing PeerNodeStart over !!!",
+ ScheduleState.STARTUP_OVER);
+
+ return startupSchedules;
+ }
+
+// private PeerInstallSchedules peerStart(String peerPath, PeerInstallSchedules installSchedules) {
+//
+// MasterAddr masterAddr = installSchedules.getIdentification().getMasterAddr();
+//
+// String ledgerKey = installSchedules.getIdentification().getLedgerKey();
+//
+// String ledgerAndNodeKey = installSchedules.getIdentification().getLedgerAndNodeKey();
+//
+// saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+// "Steps to start processing PeerNodeStart !!!",
+// ScheduleState.STARTUP_START);
+// // 启动Peer
+// // 说明初始化成功
+// // 判断是否需要启动Peer
+// String peerVerify = ledgerService.peerVerifyKey(peerPath);
+//
+// try {
+// if (!CommandUtils.isActive(peerVerify)) {
+// // 不存在,则需要再启动
+// String peerStartCmd = ledgerService.peerStartCommand(peerPath);
+//
+// LOGGER.info("Execute Peer-Startup's Shell {}", peerStartCmd);
+//
+// if (!CommandUtils.executeAndVerify(CommandUtils.toCommandList(peerStartCmd), peerVerify)) {
+// // Peer节点启动失败
+// throw new IllegalStateException("Peer Node Start UP Fail !!!");
+// }
+// saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+// String.format("Peer's process %s start -> %s", peerVerify, SUCCESS),
+// ScheduleState.STARTUP_SUCCESS);
+// } else {
+// // 命令已经存在
+// saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+// String.format("Peer's process is exist -> %s", peerVerify),
+// ScheduleState.NO_STARTUP);
+// }
+// } catch (Exception e) {
+// saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+// e.getMessage(),
+// ScheduleState.STARTUP_FAIL);
+// throw new IllegalStateException(e);
+// }
+//
+// saveInstallSchedule(installSchedules, masterAddr, ledgerKey, ledgerAndNodeKey,
+// "Steps to start processing PeerNodeStart over !!!",
+// ScheduleState.STARTUP_OVER);
+//
+// return installSchedules;
+// }
+
+ private boolean peerStop(String peerPath) {
+
+ // 判断是否需要停止Peer
+ String peerVerify = ledgerService.peerVerifyKey(peerPath);
+
+ try {
+ if (CommandUtils.isActive(peerVerify)) {
+
+ LOGGER.info("We need stop peer {}", peerVerify);
+ // 需要停止Peer节点
+ CommandUtils.killVm(peerVerify);
+
+ // 最多循环5次进行判断
+ int maxSize = 5;
+
+ while (maxSize > 0) {
+ try {
+ Thread.sleep(3000);
+ if (!CommandUtils.isActive(peerVerify)) {
+ return true;
+ }
+ } catch (Exception e) {
+ LOGGER.error("Check Peer Stop State !!!", e);
+ } finally {
+ maxSize--;
+ }
+ }
+ } else {
+ LOGGER.info("We do not need stop peer {}", peerVerify);
+ return false;
+ }
+ } catch (Exception e) {
+ LOGGER.error("Stop Peer Node", e);
+ throw new IllegalStateException(e);
+ }
+ return false;
+ }
+
+ private String writeConsensusContent(String consensusContent, File consensusFile) throws IOException {
+ // 将字符串转换为字节数组
+ byte[] consensusBytes = Base58Utils.decode(consensusContent);
+ forceWrite(consensusBytes, consensusFile);
+ return consensusFile.getName();
+ }
+
+ private void forceWrite(List lines, File file) throws IOException {
+ if (file.exists()) {
+ FileUtils.moveFile(file, new File(file.getPath() + "_bak_" + currentDate()));
+ }
+
+ FileUtils.writeLines(file, StandardCharsets.UTF_8.toString(), lines);
+ }
+
+ private void forceWrite(byte[] content, File file) throws IOException {
+ if (file.exists()) {
+ FileUtils.moveFile(file, new File(file.getPath() + "_bak_" + currentDate()));
+ }
+
+ FileUtils.writeByteArrayToFile(file, content);
+ }
+
+ private void verify(PeerSharedConfigs peerSharedConfigs) {
+ // 校验其中内容
+ List sharedConfigs = peerSharedConfigs.getSharedConfigs();
+
+ // 首先保证其中的数据一致性
+ // 1、name不能重复;
+ // 2、pubKey不能重复;
+ // 3、ipAddr + initPort不能重复;
+
+ Set nameSet = new HashSet<>(),
+ pubKeySet = new HashSet<>(),
+ addrSet = new HashSet<>();
+
+ for (PeerSharedConfig sharedConfig : sharedConfigs) {
+ String name = sharedConfig.getName(),
+ pubKey = sharedConfig.getPubKey(),
+ addr = sharedConfig.addr();
+ if (nameSet.contains(name)) {
+ throw new IllegalStateException(String.format("Name [%s] is Conflict !!!", name));
+ } else {
+ nameSet.add(name);
+ }
+
+ if (pubKeySet.contains(pubKey)) {
+ throw new IllegalStateException(String.format("PubKey [%s] is Conflict !!!", pubKey));
+ } else {
+ pubKeySet.add(pubKey);
+ }
+
+ if (addrSet.contains(addr)) {
+ throw new IllegalStateException(String.format("Address [%s] is Conflict !!!", addr));
+ } else {
+ addrSet.add(addr);
+ }
+ }
+ }
+
+ private void saveInstallSchedule(PeerInstallSchedules installSchedules, MasterAddr masterAddr, String ledgerKey, String ledgerAndNodeKey, String content, ScheduleState state) {
+
+ // 日志打印相关内容
+ LOGGER.info(content);
+
+ // 生成InstallSchedule对象
+ InstallSchedule schedule = installSchedule(ledgerKey, ledgerAndNodeKey, content, state);
+
+ // 加入反馈列表
+ installSchedules.addInstallSchedule(
+ new PeerInstallSchedule(new InstallProcess(content), state));
+
+ // 将InstallSchedule写入数据库
+ umpStateService.save(schedule, masterAddr);
+ }
+
+ private void saveInstallSchedule(PeerInstallSchedules installSchedules, String content, ScheduleState state) {
+
+ // 日志打印相关内容
+ LOGGER.info(content);
+
+ // 加入反馈列表
+ installSchedules.addInstallSchedule(
+ new PeerInstallSchedule(new InstallProcess(content), state));
+ }
+
+ private void saveStartupSchedules(PeerStartupSchedules startupSchedules, String content, ScheduleState state) {
+
+ // 日志打印相关内容
+ LOGGER.info(content);
+
+ // 加入反馈列表
+ startupSchedules.addInstallSchedule(
+ new PeerInstallSchedule(new InstallProcess(content), state));
+ }
+
+ private InstallSchedule installSchedule(String ledgerKey, String ledgerAndNodeKey, String content, ScheduleState state) {
+
+ InstallProcess process = new InstallProcess(content);
+
+ return new InstallSchedule(ledgerKey, ledgerAndNodeKey, process, state);
+
+ }
+
+ private List localConfContents(PeerLocalConfig localConfig, int nodeId) {
+ /**
+ * #当前参与方的 id,与ledger.init文件中cons_parti.id一致,默认从0开始
+ * local.parti.id=0
+ *
+ * #当前参与方的公钥
+ * local.parti.pubkey=
+ *
+ * #当前参与方的私钥(密文编码)
+ * local.parti.privkey=
+ *
+ * #当前参与方的私钥解密密钥(原始口令的一次哈希,Base58格式),如果不设置,则启动过程中需要从控制台输入
+ * local.parti.pwd=
+ *
+ * #账本初始化完成后生成的"账本绑定配置文件"的输出目录
+ * #推荐使用绝对路径,相对路径以当前文件(local.conf)所在目录为基准
+ * ledger.binding.out=../
+ *
+ * #账本数据库的连接字符
+ * #rocksdb数据库连接格式:rocksdb://{path},例如:rocksdb:///export/App08/peer/rocks.db/rocksdb0.db
+ * #redis数据库连接格式:redis://{ip}:{prot}/{db},例如:redis://127.0.0.1:6379/0
+ * ledger.db.uri=
+ *
+ * #账本数据库的连接口令
+ * ledger.db.pwd=
+ */
+
+ List localContents = new ArrayList<>();
+
+ localContents.add(valueToConfig(UmpConstant.LOCAL_PARTI_ID_PREFIX, nodeId));
+
+ localContents.add(valueToConfig(UmpConstant.LOCAL_PARTI_PUBKEY_PREFIX, localConfig.getPubKey()));
+
+ localContents.add(valueToConfig(UmpConstant.LOCAL_PARTI_PRIVKEY_PREFIX, localConfig.getPrivKey()));
+
+ localContents.add(valueToConfig(UmpConstant.LOCAL_PARTI_PWD_PREFIX, localConfig.getEncodePwd()));
+
+ localContents.add(valueToConfig(UmpConstant.LEDGER_BINDING_OUT_PREFIX, localConfig.bindingOutPath()));
+
+ localContents.add(valueToConfig(UmpConstant.LEDGER_DB_URI_PREFIX, dbUri(localConfig.getDbName(), localConfig.getPeerPath())));
+
+ localContents.add(valueToConfig(UmpConstant.LEDGER_DB_PWD_PREFIX, ""));
+
+ return localContents;
+ }
+
+ private String valueToConfig(String prefix, Object value) {
+ return prefix + "=" + value;
+ }
+
+ private String currentDate() {
+ return SDF.format(new Date());
+ }
+
+ private String dbUri(final String dbName, final String peerPath) {
+
+ String dbDirectoryPath = peerPath + File.separator + dbName;
+
+ String dbUri = ROCKSDB_PROTOCOL + dbDirectoryPath;
+
+ File dbDirectory = new File(dbDirectoryPath);
+
+ if (!dbDirectory.exists()) {
+ return dbUri;
+ }
+ throw new IllegalStateException(String.format("DB name = %s, path = %s is Exist !!!", dbName, dbDirectoryPath));
+ }
+
+ private static class CurrentLedger {
+
+ private String ledgerHash;
+
+ private long lastTime;
+
+ public CurrentLedger() {
+ }
+
+ public CurrentLedger(long lastTime) {
+ this.lastTime = lastTime;
+ }
+
+ public String getLedgerHash() {
+ return ledgerHash;
+ }
+
+ public void setLedgerHash(String ledgerHash) {
+ this.ledgerHash = ledgerHash;
+ }
+
+ public long getLastTime() {
+ return lastTime;
+ }
+
+ public void setLastTime(long lastTime) {
+ this.lastTime = lastTime;
+ }
+ }
+}
diff --git a/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpSimulateService.java b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpSimulateService.java
new file mode 100644
index 00000000..c6c8ea82
--- /dev/null
+++ b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpSimulateService.java
@@ -0,0 +1,17 @@
+package com.jd.blockchain.ump.service;
+
+import com.jd.blockchain.ump.model.config.PeerLocalConfig;
+import com.jd.blockchain.ump.model.config.PeerSharedConfigVv;
+import com.jd.blockchain.ump.model.user.UserKeys;
+import com.jd.blockchain.ump.model.user.UserKeysVv;
+
+public interface UmpSimulateService {
+
+ UserKeysVv userKeysVv(int nodeId);
+
+ UserKeys userKeys(int nodeId);
+
+ PeerLocalConfig nodePeerLocalConfig(int nodeId, boolean isMaster);
+
+ PeerSharedConfigVv peerSharedConfigVv(int nodeId, boolean isMaster);
+}
diff --git a/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpSimulateServiceHandler.java b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpSimulateServiceHandler.java
new file mode 100644
index 00000000..3bfb20bf
--- /dev/null
+++ b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpSimulateServiceHandler.java
@@ -0,0 +1,134 @@
+package com.jd.blockchain.ump.service;
+
+import com.jd.blockchain.ump.model.config.PeerLocalConfig;
+import com.jd.blockchain.ump.model.config.PeerSharedConfigVv;
+import com.jd.blockchain.ump.model.user.UserKeys;
+import com.jd.blockchain.ump.model.user.UserKeysVv;
+import com.jd.blockchain.ump.service.consensus.providers.BftsmartConsensusProvider;
+import org.apache.commons.codec.binary.Hex;
+import org.springframework.stereotype.Service;
+
+import java.util.Random;
+
+@Service
+public class UmpSimulateServiceHandler implements UmpSimulateService {
+
+ private static final Random RANDOM_ROCKSDB = new Random();
+
+ private static final String SHARED_KEY = "JDChain";
+
+ private static final int TOTAL_SIZE = 4;
+
+ private static final String LOCALHOST = "127.0.0.1";
+
+ private static final String CONSENSUS_PROVIDER = BftsmartConsensusProvider.BFTSMART_PROVIDER;
+
+ private static final String CONSENSUS_CONF = BftsmartConsensusProvider.BFTSMART_CONFIG_FILE;
+
+ private static final int INIT_PORT_START = 9000;
+
+ private static final String[] PUBKEYS = new String[]{
+ "3snPdw7i7PjVKiTH2VnXZu5H8QmNaSXpnk4ei533jFpuifyjS5zzH9",
+ "3snPdw7i7PajLB35tEau1kmixc6ZrjLXgxwKbkv5bHhP7nT5dhD9eX",
+ "3snPdw7i7PZi6TStiyc6mzjprnNhgs2atSGNS8wPYzhbKaUWGFJt7x",
+ "3snPdw7i7PifPuRX7fu3jBjsb3rJRfDe9GtbDfvFJaJ4V4hHXQfhwk"};
+
+ private static final String[] PRIVKEYS = new String[]{
+ "177gjzHTznYdPgWqZrH43W3yp37onm74wYXT4v9FukpCHBrhRysBBZh7Pzdo5AMRyQGJD7x",
+ "177gju9p5zrNdHJVEQnEEKF4ZjDDYmAXyfG84V5RPGVc5xFfmtwnHA7j51nyNLUFffzz5UT",
+ "177gjtwLgmSx5v1hFb46ijh7L9kdbKUpJYqdKVf9afiEmAuLgo8Rck9yu5UuUcHknWJuWaF",
+ "177gk1pudweTq5zgJTh8y3ENCTwtSFsKyX7YnpuKPo7rKgCkCBXVXh5z2syaTCPEMbuWRns"};
+
+ private static final String ENCODE_PWD = "DYu3G8aGTMBW1WrTw76zxQJQU4DHLw9MLyy7peG4LKkY";
+
+ private static final String BINDING_OUT = "../";
+
+ private static final String[] DB_URIS = new String[]{
+ "rocksdb:///Users/shaozhuguang/Documents/simulate/peer0/rocksdb",
+ "rocksdb:///Users/shaozhuguang/Documents/simulate/peer1/rocksdb",
+ "rocksdb:///Users/shaozhuguang/Documents/simulate/peer2/rocksdb",
+ "rocksdb:///Users/shaozhuguang/Documents/simulate/peer3/rocksdb"};
+
+ private static final String DB_PWD = "";
+
+ private static final String DB_NAME = "rocksdb_";
+
+ private static final String[] PEER_PATHS = new String[]{
+ "/Users/shaozhuguang/Documents/simulate/peer0",
+ "/Users/shaozhuguang/Documents/simulate/peer1",
+ "/Users/shaozhuguang/Documents/simulate/peer2",
+ "/Users/shaozhuguang/Documents/simulate/peer3"};
+
+ private static final String[] CONSENSUS_NODES = new String[]{
+ "127.0.0.1:6000",
+ "127.0.0.1:6010",
+ "127.0.0.1:6020",
+ "127.0.0.1:6030"};
+
+
+ @Override
+ public UserKeysVv userKeysVv(int nodeId) {
+
+ UserKeys userKeys = userKeys(nodeId);
+
+ return userKeys.toUserKeysVv();
+ }
+
+ @Override
+ public UserKeys userKeys(int nodeId) {
+
+ return new UserKeys("Peer-" + nodeId, PRIVKEYS[nodeId], PUBKEYS[nodeId], ENCODE_PWD);
+ }
+
+ @Override
+ public PeerLocalConfig nodePeerLocalConfig(int nodeId, boolean isMaster) {
+
+ UserKeys userKeys = userKeys(nodeId);
+
+ return peerSharedConfigVv(nodeId, isMaster).toPeerLocalConfig(userKeys);
+ }
+
+ @Override
+ public PeerSharedConfigVv peerSharedConfigVv(int nodeId, boolean isMaster) {
+
+ PeerSharedConfigVv sharedConfigVv = new PeerSharedConfigVv();
+
+ sharedConfigVv.setSharedKey(SHARED_KEY);
+ sharedConfigVv.setName(SHARED_KEY + "-" + nodeId);
+ sharedConfigVv.setInitAddr(LOCALHOST);
+ sharedConfigVv.setInitPort(INIT_PORT_START + nodeId * 10);
+ sharedConfigVv.setConsensusNode(CONSENSUS_NODES[nodeId]);
+ sharedConfigVv.setPubKey(PUBKEYS[nodeId]);
+ sharedConfigVv.setUserId(nodeId);
+ sharedConfigVv.setPeerPath(PEER_PATHS[nodeId]);
+ sharedConfigVv.setDbName(dbName());
+
+ if (isMaster) {
+ sharedConfigVv.setLedgerName(ledgerName());
+ sharedConfigVv.setNodeSize(TOTAL_SIZE);
+ } else {
+ sharedConfigVv.setMasterAddr(LOCALHOST);
+ sharedConfigVv.setMasterPort(8080);
+ }
+
+ return sharedConfigVv;
+ }
+
+ private String ledgerName() {
+
+ byte[] nameBytes = new byte[4];
+
+ RANDOM_ROCKSDB.nextBytes(nameBytes);
+
+ return Hex.encodeHexString(nameBytes);
+ }
+
+ private String dbName() {
+
+ byte[] nameBytes = new byte[4];
+
+ RANDOM_ROCKSDB.nextBytes(nameBytes);
+
+ return DB_NAME + Hex.encodeHexString(nameBytes);
+ }
+}
diff --git a/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpStateService.java b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpStateService.java
new file mode 100644
index 00000000..161ed867
--- /dev/null
+++ b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpStateService.java
@@ -0,0 +1,62 @@
+package com.jd.blockchain.ump.service;
+
+import com.jd.blockchain.ump.model.MasterAddr;
+import com.jd.blockchain.ump.model.config.LedgerIdentification;
+import com.jd.blockchain.ump.model.config.PeerLocalConfig;
+import com.jd.blockchain.ump.model.state.*;
+import com.jd.blockchain.ump.model.user.UserKeys;
+import com.jd.blockchain.ump.model.user.UserKeysVv;
+
+import java.util.List;
+import java.util.Map;
+
+public interface UmpStateService {
+
+ void save(String ledgerAndNodeKey, PeerLocalConfig localConfig);
+
+ void save(String ledgerKey, List sharedConfigKeys);
+
+ void save(InstallSchedule installSchedule, MasterAddr masterAddr);
+
+ void save(UserKeys userKeys);
+
+ void save(LedgerPeerInstall peerInstall);
+
+ void save(LedgerMasterInstall masterInstall);
+
+ void save(LedgerIdentification identification);
+
+ void saveLedgerHash(String ledgerAndNodeKey, String ledgerHash);
+
+ List readUserKeysList();
+
+ List readUserKeysVvList();
+
+ UserKeys readUserKeys(int id);
+
+ PeerLocalConfig readConfig(String ledgerAndNodeKey);
+
+ PeerInstallSchedules loadState(String ledgerAndNodeKey);
+
+ PeerInstallSchedules loadInitState(String ledgerAndNodeKey);
+
+ PeerInstallSchedules readState(String ledgerAndNodeKey);
+
+ PeerInstallSchedules readInitState(String ledgerAndNodeKey);
+
+ Map> readStates(String ledgerKey);
+
+ LedgerIdentification readIdentification(String ledgerAndNodeKey);
+
+ List readLedgerPeerInstalls();
+
+ List readLedgerMasterInstalls();
+
+ List readLedgerPeerIniteds();
+
+ List readLedgerPeerIniteds(String search);
+
+ List readLedgerIniteds(String search);
+
+ String readLedgerHash(String ledgerAndNodeKey);
+}
diff --git a/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpStateServiceHandler.java b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpStateServiceHandler.java
new file mode 100644
index 00000000..5ed51aca
--- /dev/null
+++ b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UmpStateServiceHandler.java
@@ -0,0 +1,880 @@
+package com.jd.blockchain.ump.service;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.jd.blockchain.ump.dao.DBConnection;
+import com.jd.blockchain.ump.model.*;
+import com.jd.blockchain.ump.model.config.LedgerIdentification;
+import com.jd.blockchain.ump.model.config.PeerLocalConfig;
+import com.jd.blockchain.ump.model.state.*;
+import com.jd.blockchain.ump.model.user.UserKeys;
+import com.jd.blockchain.ump.model.user.UserKeysVv;
+import com.jd.blockchain.ump.util.CommandUtils;
+import com.jd.blockchain.ump.util.HttpJsonClientUtils;
+import org.apache.commons.io.FileUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.text.SimpleDateFormat;
+import java.util.*;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+@Service
+public class UmpStateServiceHandler implements UmpStateService, Closeable {
+
+ private final Logger LOGGER = LoggerFactory.getLogger(getClass());
+
+ private static final SimpleDateFormat SDF = new SimpleDateFormat("yyyyMM-ddHHmmss");
+
+ private static final String PEER_IDENTIFICATION_FORMAT = "PEER_IDENTIFICATION_INDEX_%s";
+
+ private static final String PEER_INSTALL_MAX_KEY = "PEER_INSTALL_MAX_INDEX";
+
+ private static final String PEER_INSTALL_KEY_FORMAT = "PEER_INSTALL_INDEX_%s";
+
+ private static final String MASTER_INSTALL_MAX_KEY = "MASTER_INSTALL_MAX_INDEX";
+
+ private static final String MASTER_INSTALL_KEY_FORMAT = "MASTER_INSTALL_INDEX_%s";
+
+ private static final String USERS_KEY_MAX_KEY = "USERS_KEY_MAX_INDEX";
+
+ private static final String USERS_KEY_FORMAT = "USERS_%s_REGISTER";
+
+ private static final String MAX_SIZE_KEY_SUFFIX = "_MAX_SIZE_KEY";
+
+ private static final String LEDGER_HASH_KEY_SUFFIX = "_LEDGER_HASH_KEY";
+
+ private static final String LEDGER_NODE_KEY_CONFIG_SUFFIX = "_LEDGER_NODE_CONFIG_KEY";
+
+ private static final String LEDGER_NODE_KEY_SUFFIX = "_LEDGER_NODE_KEY";
+
+ private static final String CURRENT_INDEX_KEY_SUFFIX_FORMAT = "_%s_INDEX_KEY";
+
+ private static final String PORT_ARG = "-p";
+
+ private static final String LOCALHOST = "127.0.0.1";
+
+ private ExecutorService singleHttpThread = Executors.newSingleThreadExecutor();
+
+ @Autowired
+ private DBConnection dbConnection;
+
+ @Autowired
+ private LedgerService ledgerService;
+
+ @Override
+ public synchronized void save(String ledgerAndNodeKey, PeerLocalConfig localConfig) {
+
+ String ledgerAndNodeConfigKey = ledgerAndNodeConfigKey(ledgerAndNodeKey);
+
+ dbConnection.put(ledgerAndNodeConfigKey, JSON.toJSONString(localConfig));
+ }
+
+ @Override
+ public synchronized void save(String ledgerKey, List sharedConfigKeys) {
+
+ String ledgerAllNodeKey = ledgerAllNodeKey(ledgerKey);
+
+ StringBuilder sBuilder = new StringBuilder();
+
+ for (String sharedConfigKey : sharedConfigKeys) {
+ if (sBuilder.length() > 0) {
+ sBuilder.append(";");
+ }
+ sBuilder.append(sharedConfigKey);
+ }
+
+ dbConnection.put(ledgerAllNodeKey, sBuilder.toString());
+ }
+
+ @Override
+ public synchronized void save(InstallSchedule installSchedule, MasterAddr masterAddr) {
+ try {
+ String ledgerAndNodeKey = installSchedule.getLedgerAndNodeKey();
+ // 不使用队列,直接将其写入数据库
+ // 需要查询目前该Key对应的最大值是多少
+ String maxKey = ledgerAndNodeMaxKey(ledgerAndNodeKey);
+ String maxIdChars = dbConnection.get(maxKey);
+ int maxId = 0;
+ if (maxIdChars != null && maxIdChars.length() > 0) {
+ maxId = Integer.parseInt(maxIdChars) + 1;
+ }
+
+ String newKey = ledgerAndNodeCurrentNewKey(ledgerAndNodeKey, maxId);
+
+ // 内容写入数据库
+ dbConnection.put(newKey, installSchedule, InstallSchedule.class);
+
+ // 更新最大值
+ dbConnection.put(maxKey, String.valueOf(maxId));
+
+ if (masterAddr != null && masterAddr.legal()) {
+ singleHttpThread.execute(() -> {
+
+ try {
+ // 发送HTTP请求
+ HttpJsonClientUtils.httpPost(masterAddr, UmpConstant.REQUEST_STATE_URL, installSchedule, String.class, false);
+ } catch (Exception e) {
+ // 暂不关注是否发送成功
+ LOGGER.error(e.toString());
+ }
+
+ });
+ }
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ @Override
+ public synchronized void save(UserKeys userKeys) {
+
+ int maxIndex = maxIndex(USERS_KEY_MAX_KEY);
+
+ String userKey = usersKey(maxIndex);
+
+ // 重置userId
+ userKeys.setId(maxIndex);
+
+ // 将用户信息写入数据库
+ dbConnection.put(userKey, JSON.toJSONString(userKeys));
+
+ // 更新最大值
+ dbConnection.put(USERS_KEY_MAX_KEY, String.valueOf(maxIndex));
+
+ try {
+ // 将其放入文件中
+ String keysDirPath = UmpConstant.PROJECT_PATH + UmpConstant.PATH_CONFIG_KEYS;
+
+ File keysDir = new File(keysDirPath);
+
+ if (!keysDir.exists()) {
+ // 创建文件夹
+ keysDir.mkdir();
+ }
+ saveKeys2Files(keysDirPath, userKeys);
+ } catch (Exception e) {
+ LOGGER.error("Save Keys To File !", e);
+ }
+ }
+
+ @Override
+ public synchronized void save(LedgerPeerInstall peerInstall) {
+
+ int maxIndex = maxIndex(PEER_INSTALL_MAX_KEY);
+
+ // 将用户信息写入数据库
+ dbConnection.put(peerInstallKey(maxIndex), JSON.toJSONString(peerInstall));
+
+ // 更新最大值
+ dbConnection.put(PEER_INSTALL_MAX_KEY, String.valueOf(maxIndex));
+
+ }
+
+ @Override
+ public synchronized void save(LedgerMasterInstall masterInstall) {
+
+ int maxIndex = maxIndex(MASTER_INSTALL_MAX_KEY);
+
+ // 将用户信息写入数据库
+ dbConnection.put(masterInstallKey(maxIndex), JSON.toJSONString(masterInstall));
+
+ // 更新最大值
+ dbConnection.put(MASTER_INSTALL_MAX_KEY, String.valueOf(maxIndex));
+ }
+
+ @Override
+ public synchronized void save(LedgerIdentification identification) {
+
+ String ledgerAndNodeKey = identification.getLedgerAndNodeKey();
+
+ String idKey = String.format(PEER_IDENTIFICATION_FORMAT, ledgerAndNodeKey);
+
+ dbConnection.put(idKey, JSON.toJSONString(identification));
+ }
+
+ @Override
+ public void saveLedgerHash(String ledgerAndNodeKey, String ledgerHash) {
+
+ String ledgerHashKey = ledgerAndNodeHashKey(ledgerAndNodeKey);
+
+ dbConnection.put(ledgerHashKey, ledgerHash);
+ }
+
+ @Override
+ public List readUserKeysList() {
+
+ List userKeysList = new ArrayList<>();
+
+ String maxIndexChars = dbConnection.get(USERS_KEY_MAX_KEY);
+
+ if (maxIndexChars != null && maxIndexChars.length() > 0) {
+
+ int maxIndex = Integer.parseInt(maxIndexChars);
+
+ for (int i = 0; i <= maxIndex; i++) {
+ try {
+
+ String json = dbConnection.get(usersKey(i));
+
+ if (json != null && json.length() > 0) {
+ userKeysList.add(JSON.parseObject(json, UserKeys.class));
+ }
+ } catch (Exception e) {
+ LOGGER.error(e.toString());
+ }
+ }
+ }
+
+ return userKeysList;
+ }
+
+ @Override
+ public List readUserKeysVvList() {
+
+ List userKeysVvList = new ArrayList<>();
+
+ List userKeysList = readUserKeysList();
+
+ if (!userKeysList.isEmpty()) {
+ for (UserKeys userKeys : userKeysList) {
+
+ userKeysVvList.add(userKeys.toUserKeysVv());
+ }
+ }
+
+ return userKeysVvList;
+ }
+
+ @Override
+ public UserKeys readUserKeys(int id) {
+
+ String userKey = usersKey(id);
+
+ String userKeysJson = dbConnection.get(userKey);
+
+ if (userKeysJson != null && userKeysJson.length() > 0) {
+ return JSON.parseObject(userKeysJson, UserKeys.class);
+ }
+
+ return null;
+ }
+
+ @Override
+ public PeerLocalConfig readConfig(String ledgerAndNodeKey) {
+
+ String json = dbConnection.get(ledgerAndNodeConfigKey(ledgerAndNodeKey));
+
+ if (json != null && json.length() > 0) {
+
+ return JSON.parseObject(json, PeerLocalConfig.class);
+ }
+
+ return null;
+ }
+
+ @Override
+ public PeerInstallSchedules loadState(String ledgerAndNodeKey) {
+
+ PeerInstallSchedules installSchedules = loadInitState(ledgerAndNodeKey);
+
+ String ledgerHash = ledgerService.readLedgerHash(ledgerAndNodeKey);
+
+ if (ledgerHash == null || ledgerHash.length() == 0) {
+ throw new IllegalStateException("Can not find LedgerHash from DataBase !!!");
+ }
+
+ return installSchedules.initLedgerHash(ledgerHash);
+
+ }
+
+ @Override
+ public PeerInstallSchedules loadInitState(String ledgerAndNodeKey) {
+ // 获取LedgerIdentification
+ LedgerIdentification identification = readIdentification(ledgerAndNodeKey);
+
+ if (identification == null) {
+ throw new IllegalStateException("Can not find LedgerIdentification from DataBase !!!");
+ }
+
+ return new PeerInstallSchedules(identification);
+ }
+
+ @Override
+ public PeerInstallSchedules readState(final String ledgerAndNodeKey) {
+
+ PeerInstallSchedules installSchedules = loadState(ledgerAndNodeKey);
+
+ loadInstallSchedules(installSchedules, ledgerAndNodeKey);
+
+ return installSchedules;
+ }
+
+ @Override
+ public PeerInstallSchedules readInitState(String ledgerAndNodeKey) {
+
+ PeerInstallSchedules installSchedules = loadInitState(ledgerAndNodeKey);
+
+ loadInstallSchedules(installSchedules, ledgerAndNodeKey);
+
+ return installSchedules;
+ }
+
+ @Override
+ public Map> readStates(String ledgerKey) {
+
+ String ledgerAllNodeKey = ledgerAllNodeKey(ledgerKey);
+
+ String ledgerAllNodeValues = dbConnection.get(ledgerAllNodeKey);
+
+ String[] ledgerAndNodeKeys = ledgerAllNodeValues.split(";");
+
+ Map> allInstallSchedules = new HashMap<>();
+
+ // 不存在就返回空值
+ if (ledgerAndNodeKeys.length > 0) {
+
+ for (String ledgerAndNodeKey : ledgerAndNodeKeys) {
+ // 获取每个LedgerAndNodeKey数据
+ List installSchedules = readInstallSchedules(ledgerAndNodeKey);
+
+ if (installSchedules != null) {
+
+ allInstallSchedules.put(ledgerAndNodeKey, installSchedules);
+ }
+ }
+ }
+
+ return allInstallSchedules;
+ }
+
+ @Override
+ public LedgerIdentification readIdentification(String ledgerAndNodeKey) {
+
+ String idKey = String.format(PEER_IDENTIFICATION_FORMAT, ledgerAndNodeKey);
+
+ String identificationJson = dbConnection.get(idKey);
+
+ if (identificationJson != null && identificationJson.length() > 0) {
+
+ return JSON.parseObject(identificationJson, LedgerIdentification.class);
+ }
+
+ return null;
+ }
+
+ @Override
+ public List readLedgerPeerInstalls() {
+
+ List peerInstallList = new ArrayList<>();
+
+ String maxIndexChars = dbConnection.get(PEER_INSTALL_MAX_KEY);
+
+ if (maxIndexChars != null && maxIndexChars.length() > 0) {
+
+ int maxIndex = Integer.parseInt(maxIndexChars);
+
+ for (int i = 1; i <= maxIndex; i++) {
+ try {
+ String json = dbConnection.get(peerInstallKey(i));
+
+ if (json != null && json.length() > 0) {
+ peerInstallList.add(JSON.parseObject(json, LedgerPeerInstall.class));
+ }
+ } catch (Exception e) {
+ LOGGER.error(e.toString());
+ }
+ }
+ }
+
+ return peerInstallList;
+ }
+
+ @Override
+ public List readLedgerMasterInstalls() {
+
+ List masterInstalls = new ArrayList<>();
+
+ String maxIndexChars = dbConnection.get(PEER_INSTALL_MAX_KEY);
+
+ if (maxIndexChars != null && maxIndexChars.length() > 0) {
+
+ int maxIndex = Integer.parseInt(maxIndexChars);
+
+ for (int i = 1; i <= maxIndex; i++) {
+ try {
+ String json = dbConnection.get(masterInstallKey(i));
+
+ if (json != null && json.length() > 0) {
+ masterInstalls.add(JSON.parseObject(json, LedgerMasterInstall.class));
+ }
+ } catch (Exception e) {
+ LOGGER.error(e.toString());
+ }
+ }
+ }
+
+ return masterInstalls;
+ }
+
+ @Override
+ public List readLedgerPeerIniteds() {
+
+ List peerIniteds = new ArrayList<>();
+
+ List peerInstalls = readLedgerPeerInstalls();
+
+ if (!peerInstalls.isEmpty()) {
+
+ LOGGER.info("Read LedgerPeerInstalls, Size = {}", peerInstalls.size());
+ for (LedgerPeerInstall peerInstall : peerInstalls) {
+
+ String ledgerAndNodeKey = peerInstall.getLedgerAndNodeKey();
+
+ // 数据库中读取存放的LedgerHash
+ String ledgerHash = readLedgerHash(ledgerAndNodeKey);
+
+ if (ledgerHash == null || ledgerHash.length() == 0) {
+ continue;
+ }
+
+ LedgerPeerInited peerInited = new LedgerPeerInited(ledgerHash, peerInstall);
+
+ // 检测账本中的Hash是否真正存在
+ StartupState startupState = StartupState.UNKNOWN;
+ try {
+ startupState = startupState(ledgerHash, peerInstall);
+ } catch (Exception e) {
+ LOGGER.error("Check Ledger Hash Exist !!!", e);
+ }
+
+ // 设置账本状态
+ peerInited.setStartupState(startupState);
+
+ // 添加到集合
+ peerIniteds.add(peerInited);
+ }
+ } else {
+ LOGGER.error("Read LedgerPeerInstalls is Empty !!!");
+ }
+ return peerIniteds;
+ }
+
+ @Override
+ public List readLedgerPeerIniteds(String search) {
+
+ List initedList = readLedgerPeerIniteds();
+
+ if (search != null && search.length() > 0 && !initedList.isEmpty()) {
+
+ List filterInitedList = new ArrayList<>();
+
+ for (LedgerPeerInited peerInited : initedList) {
+ if (isMatch(peerInited, search)) {
+ filterInitedList.add(peerInited);
+ }
+ }
+
+ return filterInitedList;
+ }
+
+ return initedList;
+ }
+
+ @Override
+ public List readLedgerIniteds(String search) {
+
+ List ledgerInitedsFromConf = loadAllLedgerIniteds(UmpConstant.PROJECT_PATH);
+
+ if (!ledgerInitedsFromConf.isEmpty()) {
+
+ List ledgerIniteds = new ArrayList<>();
+
+ for (LedgerInited ledgerInited : ledgerInitedsFromConf) {
+
+ if (isMatch(ledgerInited, search)) {
+ ledgerIniteds.add(ledgerInited);
+ }
+ }
+
+ return ledgerIniteds;
+ }
+
+ return ledgerInitedsFromConf;
+ }
+
+ @Override
+ public String readLedgerHash(String ledgerAndNodeKey) {
+
+ String ledgerHashKey = ledgerAndNodeHashKey(ledgerAndNodeKey);
+
+ return dbConnection.get(ledgerHashKey);
+ }
+
+ @Override
+ public void close() throws IOException {
+// writeRunner.close();
+ }
+
+ private boolean isMatch(LedgerInited ledgerInited, String search) {
+
+ if (search == null || search.length() == 0) {
+ return true;
+ }
+
+ String ledgerHash = ledgerInited.getLedgerHash();
+ String ledgerName = ledgerInited.getLedgerName();
+ String partiName = ledgerInited.getPartiName();
+ String partiAddress = ledgerInited.getPartiAddress();
+ String dbUri = ledgerInited.getDbUri();
+ StartupState startupState = ledgerInited.getStartupState();
+
+ if (
+ ledgerHash.contains(search) ||
+ startupState.toString().equals(search) ||
+ ledgerName.contains(search) ||
+ partiName.contains(search) ||
+ partiAddress.contains(search) ||
+ dbUri.contains(search)
+ ) {
+ return true;
+ }
+ return false;
+ }
+
+ private boolean isMatch(LedgerPeerInited peerInited, String search) {
+
+ if (search == null || search.length() == 0) {
+ return true;
+ }
+
+ String ledgerHash = peerInited.getLedgerHash();
+ StartupState startupState = peerInited.getStartupState();
+ LedgerPeerInstall peerInstall = peerInited.getPeerInstall();
+
+ if (ledgerHash.contains(search) ||
+ startupState.toString().equals(search) ||
+ peerInstall.getNodeName().contains(search) ||
+ peerInstall.getCreateTime().contains(search)
+ ) {
+ return true;
+ }
+ return false;
+ }
+
+ private void loadInstallSchedules(PeerInstallSchedules installSchedules, String ledgerAndNodeKey) {
+ List schedules = readInstallSchedules(ledgerAndNodeKey);
+
+ for (InstallSchedule installSchedule : schedules) {
+ installSchedules.addInstallSchedule(
+ new PeerInstallSchedule(installSchedule.getProcess(), installSchedule.getState()));
+ }
+ }
+
+ private List readInstallSchedules(String ledgerAndNodeKey) {
+ String maxKey = ledgerAndNodeMaxKey(ledgerAndNodeKey);
+ String maxIdChars = dbConnection.get(maxKey);
+ if (maxIdChars == null || maxIdChars.length() == 0) {
+ return null;
+ }
+ int maxId = Integer.parseInt(maxIdChars);
+
+ List schedules = new ArrayList<>();
+
+ for (int i = 0; i <= maxId; i++) {
+
+ try {
+ String currentKey = ledgerAndNodeCurrentNewKey(ledgerAndNodeKey, i);
+
+ String jsonChars = dbConnection.get(currentKey);
+
+ if (jsonChars != null && jsonChars.length() > 0) {
+ schedules.add(JSON.parseObject(jsonChars, InstallSchedule.class));
+ }
+ } catch (Exception e) {
+ // 打印错误,暂不处理其他
+ LOGGER.error(e.toString());
+ }
+ }
+
+ return schedules;
+ }
+
+ private List loadAllLedgerIniteds(String peerPath) {
+
+ List ledgerInitedsFromConf = ledgerService.allLedgerIniteds(peerPath);
+
+ if (!ledgerInitedsFromConf.isEmpty()) {
+
+ // 逐个检查其状态
+ for (LedgerInited ledgerInited : ledgerInitedsFromConf) {
+ // 判断该账本对应的数据库是否存在
+ if (!dbConnection.exist(ledgerInited.getDbUri())) {
+ ledgerInited.setStartupState(StartupState.DB_UNEXIST);
+ continue;
+ }
+
+ String peerVerify = ledgerService.peerVerifyKey(peerPath);
+
+ try {
+ if (!CommandUtils.isActive(peerVerify)) {
+ // 进程不存在
+ LOGGER.info("Can not find Peer Process {} !!!", peerVerify);
+ ledgerInited.setStartupState(StartupState.UNLOAD);
+ continue;
+ }
+ } catch (Exception e) {
+ // 进程处理错误打印日志即可
+ LOGGER.error(String.format("Command Check %s !!!", peerVerify), e);
+ }
+ // 查看该进程对应的监听端口
+ try {
+ int listenPort = listenPort(peerVerify);
+
+ LOGGER.info("Find Listen Port = {} !", listenPort);
+
+ if (listenPort > 0) {
+
+ int maxSize = 5, checkIndex = 1;
+
+ boolean isRead = false;
+
+ while (maxSize > 0) {
+
+ try {
+ // 发送请求到对应地址
+ JSONArray ledgerHashs = HttpJsonClientUtils.httpGet(ledgersUrl(listenPort), JSONArray.class, true);
+
+ if (ledgerHashs != null && !ledgerHashs.isEmpty()) {
+ for(Object hashObj : ledgerHashs) {
+ if (hashObj instanceof JSONObject) {
+ if (ledgerInited.getLedgerHash().equals(((JSONObject) hashObj).getString("value"))) {
+ // 说明该账本已经被加载
+ ledgerInited.setStartupState(StartupState.LOADED);
+ isRead = true;
+ break;
+ }
+ }
+ }
+ if (isRead) {
+ break;
+ }
+ }
+
+ // 6秒休眠
+ Thread.sleep(6000);
+ } catch (Exception e) {
+ LOGGER.error(String.format("Request LedgerHashs from PeerNode [%s]", checkIndex++), e);
+ }
+
+ maxSize --;
+ }
+
+ if (!isRead) {
+ // 表明等待加载,无须再启动
+ ledgerInited.setStartupState(StartupState.LOADING);
+ }
+ }
+ } catch (Exception e) {
+ LOGGER.error(String.format("Command [%s] 'Listen Port Check !!!", peerVerify), e);
+ }
+ }
+ }
+
+ return ledgerInitedsFromConf;
+ }
+
+ private StartupState startupState(String ledgerHash, LedgerPeerInstall peerInstall) {
+
+ String peerPath = peerInstall.getPeerPath();
+
+ // 首先检查文件中是否存在该Hash值
+ LedgerBindingConf ledgerBindingConf = ledgerService.allLedgerHashs(peerPath);
+
+ Set allLedgerHashs = ledgerBindingConf.getLedgerHashs();
+
+ if (!allLedgerHashs.contains(ledgerHash)) {
+
+ // 文件中不存在
+ return StartupState.UNEXIST;
+ }
+
+ // 判断该账本对应的数据库是否存在
+ if (!ledgerService.dbExist(peerPath, ledgerHash)) {
+
+ // 该账本对应数据库不存在
+ return StartupState.DB_UNEXIST;
+ }
+
+ // 文件中存在则检查进程是否存在
+ // 进程存在标识为LOADED,否则标识为LOADING,暂时用不到LOADING
+ String peerVerify = ledgerService.peerVerifyKey(peerPath);
+
+ try {
+ if (!CommandUtils.isActive(peerVerify)) {
+ // 进程不存在
+ return StartupState.UNLOAD;
+ }
+
+ } catch (Exception e) {
+ // 进程处理错误打印日志即可
+ LOGGER.error(String.format("Command Check %s !!!", peerVerify), e);
+ }
+
+ // 查看该进程对应的监听端口
+ try {
+ int listenPort = listenPort(peerVerify);
+
+ LOGGER.info("Find Listen Port = {} !", listenPort);
+
+ if (listenPort > 0) {
+ // 发送请求到对应地址
+ JSONArray ledgerHashs = HttpJsonClientUtils.httpGet(ledgersUrl(listenPort), JSONArray.class, true);
+
+ if (ledgerHashs != null && !ledgerHashs.isEmpty()) {
+ for(Object hashObj : ledgerHashs) {
+ if (hashObj instanceof JSONObject) {
+ if (ledgerHash.equals(((JSONObject) hashObj).getString("value"))) {
+ // 说明该账本已经被加载
+ return StartupState.LOADED;
+ }
+ }
+ }
+ // 表明等待加载,无须再启动
+ return StartupState.LOADING;
+ }
+ }
+ } catch (Exception e) {
+ LOGGER.error(String.format("Command [%s] 'Listen Port Check !!!", peerVerify), e);
+ }
+
+ return StartupState.UNKNOWN;
+ }
+
+ private String ledgersUrl(int listenPort) {
+ return "http://" + LOCALHOST + ":" + listenPort + "/ledgers";
+ }
+
+ private int listenPort(String peerVerify) throws Exception {
+
+ String portArg = mainArg(peerVerify, PORT_ARG);
+
+ if (portArg != null && portArg.length() > 0) {
+ return Integer.parseInt(portArg);
+ }
+
+ return 0;
+ }
+
+ private String mainArg(String processName, String argKey) throws Exception {
+
+ String[] cmdLineArray = mainArgs(processName);
+
+ if (cmdLineArray != null && cmdLineArray.length > 0) {
+ for (int i = 0; i < cmdLineArray.length; i++) {
+ String currArg = cmdLineArray[i].trim();
+ if (currArg.equals(argKey) && (i + 1) < cmdLineArray.length) {
+ return cmdLineArray[i+1].trim();
+ }
+ }
+ }
+ return null;
+ }
+
+ private String[] mainArgs(String processName) throws Exception {
+
+ String mainArgs = CommandUtils.mainArgs(processName);
+
+ if (mainArgs != null && mainArgs.length() > 0) {
+ ///Users/shaozhuguang/Documents/newenv/peer4/system/deployment-peer-1.1.0-SNAPSHOT.jar -home=/Users/shaozhuguang/Documents/newenv/peer4 -c /Users/shaozhuguang/Documents/newenv/peer4/config/ledger-binding.conf -p 7080
+ return mainArgs.split(" ");
+ }
+
+ return null;
+ }
+
+ private synchronized int maxIndex(String key) {
+ int maxIndex = 1;
+ String maxIndexChars = dbConnection.get(key);
+ if (maxIndexChars != null && maxIndexChars.length() > 0) {
+ maxIndex = Integer.parseInt(maxIndexChars) + 1;
+ }
+ return maxIndex;
+ }
+
+ private String usersKey(int userId) {
+ return String.format(USERS_KEY_FORMAT, userId);
+ }
+
+ private String peerInstallKey(int index) {
+ return String.format(PEER_INSTALL_KEY_FORMAT, index);
+ }
+
+ private String masterInstallKey(int index) {
+ return String.format(MASTER_INSTALL_KEY_FORMAT, index);
+ }
+
+ private String ledgerAndNodeConfigKey(String ledgerAndNodeKey) {
+
+ return ledgerAndNodeKey + LEDGER_NODE_KEY_CONFIG_SUFFIX;
+ }
+
+ private String ledgerAllNodeKey(String ledgerKey) {
+
+ return ledgerKey + LEDGER_NODE_KEY_SUFFIX;
+ }
+
+ private String ledgerAndNodeMaxKey(String ledgerAndNodeKey) {
+
+ return ledgerAndNodeKey + MAX_SIZE_KEY_SUFFIX;
+ }
+
+ private String ledgerAndNodeHashKey(String ledgerAndNodeKey) {
+
+ return ledgerAndNodeKey + LEDGER_HASH_KEY_SUFFIX;
+ }
+
+ private String ledgerAndNodeCurrentNewKey(String ledgerAndNodeKey, int currentId) {
+
+ return String.format(
+ ledgerAndNodeKey + CURRENT_INDEX_KEY_SUFFIX_FORMAT,
+ currentId);
+ }
+
+ private void saveKeys2Files(String keysDirPath, UserKeys userKeys) throws IOException {
+
+ // 写入私钥
+ write(keysDirPath, userKeys.getName(), UmpConstant.PRIVATE_KEY_SUFFIX, userKeys.getPrivKey());
+ // 写入公钥
+ write(keysDirPath, userKeys.getName(), UmpConstant.PUBLIC_KEY_SUFFIX, userKeys.getPubKey());
+ // 写入密钥
+ write(keysDirPath, userKeys.getName(), UmpConstant.PWD_SUFFIX, userKeys.getEncodePwd());
+ }
+
+ private void write(String keysDirPath, String name, String suffix, String writeContent) throws IOException {
+
+ String keyeFilePath = keysDirPath + File.separator + name + suffix;
+
+ File keysFile = new File(keyeFilePath);
+
+ if (keysFile.exists()) {
+ // 文件存在,备份文件
+ FileUtils.copyFile(keysFile, new File(keyeFilePath + "_bak_" + currentTime()));
+ }
+
+ // 将Priv文件内容写入
+ FileUtils.writeStringToFile(keysFile, writeContent, StandardCharsets.UTF_8);
+ }
+
+ private String currentTime() {
+ return SDF.format(new Date());
+ }
+}
diff --git a/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UtilService.java b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UtilService.java
new file mode 100644
index 00000000..a2083d88
--- /dev/null
+++ b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UtilService.java
@@ -0,0 +1,15 @@
+package com.jd.blockchain.ump.service;
+
+import com.jd.blockchain.ump.model.user.UserKeyBuilder;
+import com.jd.blockchain.ump.model.user.UserKeys;
+
+public interface UtilService {
+
+ UserKeys create(UserKeyBuilder builder);
+
+ UserKeys create(String name, String seed, String pwd);
+
+ UserKeys read(int id);
+
+ boolean verify(UserKeys userKeys, String pwd);
+}
diff --git a/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UtilServiceHandler.java b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UtilServiceHandler.java
new file mode 100644
index 00000000..3abf5bb4
--- /dev/null
+++ b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/UtilServiceHandler.java
@@ -0,0 +1,80 @@
+package com.jd.blockchain.ump.service;
+
+import com.jd.blockchain.crypto.PrivKey;
+import com.jd.blockchain.crypto.PubKey;
+import com.jd.blockchain.crypto.service.classic.ClassicAlgorithm;
+import com.jd.blockchain.crypto.utils.classic.ED25519Utils;
+import com.jd.blockchain.ump.model.user.UserKeyBuilder;
+import com.jd.blockchain.ump.model.user.UserKeys;
+import com.jd.blockchain.utils.codec.Base58Utils;
+import com.jd.blockchain.utils.security.ShaUtils;
+import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
+import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;
+import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters;
+import org.bouncycastle.crypto.prng.FixedSecureRandom;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.nio.charset.Charset;
+
+import static com.jd.blockchain.tools.keygen.KeyGenCommand.encodePrivKey;
+import static com.jd.blockchain.tools.keygen.KeyGenCommand.encodePubKey;
+
+@Service
+public class UtilServiceHandler implements UtilService {
+
+ private static final String UTF_8 = "UTF-8";
+
+ @Autowired
+ private UmpStateService umpStateService;
+
+ @Override
+ public UserKeys create(UserKeyBuilder builder) {
+
+ return create(builder.getName(), builder.getSeed(), builder.getPwd());
+ }
+
+ @Override
+ public UserKeys create(String name, String seed, String pwd) {
+
+ AsymmetricCipherKeyPair keyPair = ED25519Utils.generateKeyPair(
+ new FixedSecureRandom(seed.getBytes(Charset.forName(UTF_8))));
+
+ PubKey pubKey = new PubKey(ClassicAlgorithm.ED25519,
+ ((Ed25519PublicKeyParameters) keyPair.getPublic()).getEncoded());
+
+ PrivKey privKey = new PrivKey(ClassicAlgorithm.ED25519,
+ ((Ed25519PrivateKeyParameters) keyPair.getPrivate()).getEncoded());
+
+ return create(name, pubKey, privKey, pwd);
+ }
+
+ @Override
+ public UserKeys read(int userId) {
+
+ return umpStateService.readUserKeys(userId);
+ }
+
+ @Override
+ public boolean verify(UserKeys userKeys, String pwd) {
+
+ String encodePwd = Base58Utils.encode((ShaUtils.hash_256(pwd.getBytes(Charset.forName(UTF_8)))));
+
+ if (encodePwd.equals(userKeys.getEncodePwd())) {
+ return true;
+ }
+ return false;
+ }
+
+ private UserKeys create(String name, PubKey pubKey, PrivKey privKey, String pwd) {
+
+ byte[] pwdBytes = ShaUtils.hash_256(pwd.getBytes(Charset.forName(UTF_8)));
+
+ return new UserKeys(
+ name,
+ encodePrivKey(privKey, pwdBytes),
+ encodePubKey(pubKey),
+// pwd, // 密码不保存到数据库,防止泄露
+ Base58Utils.encode(pwdBytes));
+ }
+}
diff --git a/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/consensus/ConsensusProvider.java b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/consensus/ConsensusProvider.java
new file mode 100644
index 00000000..124b6d10
--- /dev/null
+++ b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/consensus/ConsensusProvider.java
@@ -0,0 +1,21 @@
+package com.jd.blockchain.ump.service.consensus;
+
+import com.jd.blockchain.ump.model.config.PeerLocalConfig;
+
+import java.util.List;
+import java.util.Properties;
+
+public interface ConsensusProvider {
+
+ String NEXT_LINE = "\r\n";
+
+ String provider();
+
+ String configFilePath();
+
+ void setConfig(Properties properties);
+
+ Properties getConfig();
+
+ byte[] handleSharedConfigs(List sharedConfigs);
+}
diff --git a/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/consensus/ConsensusService.java b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/consensus/ConsensusService.java
new file mode 100644
index 00000000..aeb5fcba
--- /dev/null
+++ b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/consensus/ConsensusService.java
@@ -0,0 +1,10 @@
+package com.jd.blockchain.ump.service.consensus;
+
+import com.jd.blockchain.ump.model.config.PeerLocalConfig;
+
+import java.util.List;
+
+public interface ConsensusService {
+
+ String initConsensusConf(String consensusProvider, List sharedConfigs);
+}
diff --git a/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/consensus/ConsensusServiceHandler.java b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/consensus/ConsensusServiceHandler.java
new file mode 100644
index 00000000..50cdb00f
--- /dev/null
+++ b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/consensus/ConsensusServiceHandler.java
@@ -0,0 +1,79 @@
+package com.jd.blockchain.ump.service.consensus;
+
+import com.jd.blockchain.ump.model.config.PeerLocalConfig;
+import com.jd.blockchain.ump.util.Base58Utils;
+import org.reflections.Reflections;
+import org.springframework.stereotype.Service;
+
+import java.io.File;
+import java.io.InputStream;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+@Service
+public class ConsensusServiceHandler implements ConsensusService {
+
+ private static final Map CONSENSUS_PROVIDERS = new ConcurrentHashMap<>();
+
+ static {
+ try {
+ initProviders();
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ @Override
+ public String initConsensusConf(String consensusProvider, List sharedConfigs) {
+ // 首先根据provider获取对应的配置信息
+ ConsensusProvider provider = CONSENSUS_PROVIDERS.get(consensusProvider);
+
+ if (provider == null) {
+ throw new IllegalStateException(
+ String.format("ConsensusProvider[%s] can not find Manage-Class !!!", consensusProvider));
+ }
+
+ byte[] result = provider.handleSharedConfigs(sharedConfigs);
+
+ return Base58Utils.encode(result);
+ }
+
+ private static void initProviders() {
+ // 初始化所有实现类
+ Reflections reflections = new Reflections("com.jd.blockchain.ump.service.consensus");
+
+ Set> providerSet =
+ reflections.getSubTypesOf(ConsensusProvider.class);
+
+ for (Class extends ConsensusProvider> clazz : providerSet) {
+
+ if (!clazz.isInterface()) {
+ try {
+ // 根据class生成对象
+ ConsensusProvider provider = clazz.newInstance();
+ String providerKey = provider.provider();
+ if (providerKey != null && providerKey.length() > 0 &&
+ !CONSENSUS_PROVIDERS.containsKey(providerKey)) {
+
+ // 根据value读取配置文件中的内容
+ InputStream currentFileInputStream = ConsensusServiceHandler.class.getResourceAsStream(
+ File.separator + provider.configFilePath());
+
+ Properties currentProps = new Properties();
+
+ currentProps.load(currentFileInputStream);
+
+ provider.setConfig(currentProps);
+
+ CONSENSUS_PROVIDERS.put(providerKey, provider);
+ }
+ } catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+ }
+ }
+}
diff --git a/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/consensus/providers/BftsmartConsensusProvider.java b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/consensus/providers/BftsmartConsensusProvider.java
new file mode 100644
index 00000000..acb89a84
--- /dev/null
+++ b/source/manager/ump-service/src/main/java/com/jd/blockchain/ump/service/consensus/providers/BftsmartConsensusProvider.java
@@ -0,0 +1,162 @@
+package com.jd.blockchain.ump.service.consensus.providers;
+
+
+import com.jd.blockchain.ump.model.config.PeerLocalConfig;
+import com.jd.blockchain.ump.model.config.PeerSharedConfig;
+import com.jd.blockchain.ump.service.consensus.ConsensusProvider;
+
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+
+public class BftsmartConsensusProvider implements ConsensusProvider {
+
+ public static final String BFTSMART_PROVIDER = "com.jd.blockchain.consensus.bftsmart.BftsmartConsensusProvider";
+
+ public static final String BFTSMART_CONFIG_FILE = "bftsmart.config";
+
+ private static final int MIN_PARTI_SIZE = 4;
+
+ private Properties bftsmartProps;
+
+ @Override
+ public String provider() {
+ return BFTSMART_PROVIDER;
+ }
+
+ @Override
+ public String configFilePath() {
+ return BFTSMART_CONFIG_FILE;
+ }
+
+ @Override
+ public void setConfig(Properties properties) {
+ bftsmartProps = properties;
+ }
+
+ @Override
+ public Properties getConfig() {
+ return bftsmartProps;
+ }
+
+ @Override
+ public byte[] handleSharedConfigs(List sharedConfigs) {
+
+ // 首先校验其中的ConsensusNode是否完全一致,若完全一致则不可以
+ verify(sharedConfigs);
+
+ StringBuilder sBuilder = new StringBuilder();
+
+ // 先加入当前节点信息
+ List nodeConfigs = nodeConfigs(sharedConfigs);
+
+ for (String nodeConfig : nodeConfigs) {
+ sBuilder.append(nodeConfig).append(NEXT_LINE);
+ }
+
+ int nodeNum = sharedConfigs.size();
+
+ // 写入之前配置文件中的内容
+ for (Map.Entry
-
+
@@ -38,8 +38,8 @@
-
+
@@ -51,7 +51,7 @@
-
+
diff --git a/source/pom.xml b/source/pom.xml
index 13ce9e10..6d34bb90 100644
--- a/source/pom.xml
+++ b/source/pom.xml
@@ -32,6 +32,7 @@
storage
gateway
peer
+ manager
sdk
tools
test
@@ -42,6 +43,8 @@
0.8.1-SNAPSHOT
0.0.8.RELEASE
0.7.0.RELEASE
+ 1.0.0-SNAPSHOT
+ 2.4
@@ -92,11 +95,6 @@
mockito-core
test
-
- org.springframework.boot
- spring-boot-starter-log4j2
- test
-
@@ -120,6 +118,18 @@
${explorer.version}
+
+ com.jd.blockchain
+ ump-explorer
+ ${ump-explorer.version}
+
+
+
+ commons-io
+ commons-io
+ ${commons-io.version}
+
+
junit
@@ -512,4 +522,4 @@
-
\ No newline at end of file
+
diff --git a/source/sdk/sdk-base/src/main/java/com/jd/blockchain/sdk/converters/ClientResolveUtil.java b/source/sdk/sdk-base/src/main/java/com/jd/blockchain/sdk/converters/ClientResolveUtil.java
index 68b82f14..3c251a66 100644
--- a/source/sdk/sdk-base/src/main/java/com/jd/blockchain/sdk/converters/ClientResolveUtil.java
+++ b/source/sdk/sdk-base/src/main/java/com/jd/blockchain/sdk/converters/ClientResolveUtil.java
@@ -8,41 +8,19 @@
*/
package com.jd.blockchain.sdk.converters;
-import java.lang.reflect.Field;
-
-import org.apache.commons.codec.binary.Base64;
-
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.jd.blockchain.crypto.CryptoProvider;
import com.jd.blockchain.crypto.PubKey;
-import com.jd.blockchain.ledger.BlockchainIdentityData;
-import com.jd.blockchain.ledger.BytesData;
-import com.jd.blockchain.ledger.BytesValue;
-import com.jd.blockchain.ledger.BytesValueEncoding;
-import com.jd.blockchain.ledger.ContractCodeDeployOperation;
-import com.jd.blockchain.ledger.ContractEventSendOperation;
-import com.jd.blockchain.ledger.CryptoSetting;
-import com.jd.blockchain.ledger.DataAccountKVSetOperation;
-import com.jd.blockchain.ledger.DataAccountRegisterOperation;
-import com.jd.blockchain.ledger.DataType;
-import com.jd.blockchain.ledger.KVDataEntry;
-import com.jd.blockchain.ledger.LedgerInitOperation;
-import com.jd.blockchain.ledger.Operation;
-import com.jd.blockchain.ledger.ParticipantNode;
-import com.jd.blockchain.ledger.UserRegisterOperation;
-import com.jd.blockchain.transaction.ContractCodeDeployOpTemplate;
-import com.jd.blockchain.transaction.ContractEventSendOpTemplate;
-import com.jd.blockchain.transaction.DataAccountKVSetOpTemplate;
-import com.jd.blockchain.transaction.DataAccountRegisterOpTemplate;
-import com.jd.blockchain.transaction.KVData;
-import com.jd.blockchain.transaction.LedgerInitOpTemplate;
-import com.jd.blockchain.transaction.LedgerInitData;
-import com.jd.blockchain.transaction.UserRegisterOpTemplate;
+import com.jd.blockchain.ledger.*;
+import com.jd.blockchain.transaction.*;
import com.jd.blockchain.utils.Bytes;
import com.jd.blockchain.utils.codec.Base58Utils;
import com.jd.blockchain.utils.codec.HexUtils;
import com.jd.blockchain.utils.io.BytesUtils;
+import org.apache.commons.codec.binary.Base64;
+
+import java.lang.reflect.Field;
/**
*
@@ -53,348 +31,349 @@ import com.jd.blockchain.utils.io.BytesUtils;
public class ClientResolveUtil {
- public static KVDataEntry[] read(KVDataEntry[] kvDataEntries) {
- if (kvDataEntries == null || kvDataEntries.length == 0) {
- return kvDataEntries;
- }
- KVDataEntry[] resolveKvDataEntries = new KVDataEntry[kvDataEntries.length];
- // kvDataEntries是代理对象,需要处理
- for (int i = 0; i < kvDataEntries.length; i++) {
- KVDataEntry kvDataEntry = kvDataEntries[i];
- String key = kvDataEntry.getKey();
- long version = kvDataEntry.getVersion();
- DataType dataType = kvDataEntry.getType();
- KvData innerKvData = new KvData(key, version, dataType);
- Object valueObj = kvDataEntry.getValue();
- switch (dataType) {
- case NIL:
- break;
- case BYTES:
- case TEXT:
- case JSON:
- innerKvData.setValue(valueObj.toString());
- break;
- case INT32:
- innerKvData.setValue(Integer.parseInt(valueObj.toString()));
- break;
- case INT64:
- innerKvData.setValue(Long.parseLong(valueObj.toString()));
- break;
- default:
- throw new IllegalStateException("Unsupported value type[" + dataType + "] to resolve!");
- }
- resolveKvDataEntries[i] = innerKvData;
- }
- return resolveKvDataEntries;
- }
-
- public static Operation read(Operation operation) {
-
- try {
- // Class
- Class> clazz = operation.getClass();
- Field field = clazz.getSuperclass().getDeclaredField("h");
- field.setAccessible(true);
- Object object = field.get(operation);
- if (object instanceof JSONObject) {
- JSONObject jsonObject = (JSONObject) object;
- if (jsonObject.containsKey("accountID")) {
- return convertDataAccountRegisterOperation(jsonObject);
- } else if (jsonObject.containsKey("userID")) {
- return convertUserRegisterOperation(jsonObject);
- } else if (jsonObject.containsKey("contractID")) {
- return convertContractCodeDeployOperation(jsonObject);
- } else if (jsonObject.containsKey("writeSet")) {
- return convertDataAccountKVSetOperation(jsonObject);
- } else if (jsonObject.containsKey("initSetting")) {
- return convertLedgerInitOperation(jsonObject);
- } else if (jsonObject.containsKey("contractAddress")) {
- return convertContractEventSendOperation(jsonObject);
- }
- }
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
-
- return null;
- }
-
- public static Object readValueByBytesValue(BytesValue bytesValue) {
- DataType dataType = bytesValue.getType();
- Bytes saveVal = bytesValue.getValue();
- Object showVal;
- switch (dataType) {
- case BYTES:
- // return hex
- showVal = HexUtils.encode(saveVal.toBytes());
- break;
- case TEXT:
- case JSON:
- showVal = saveVal.toUTF8String();
- break;
- case INT64:
- showVal = BytesUtils.toLong(saveVal.toBytes());
- break;
- default:
- showVal = HexUtils.encode(saveVal.toBytes());
- break;
- }
- return showVal;
- }
-
- public static DataAccountRegisterOperation convertDataAccountRegisterOperation(JSONObject jsonObject) {
- JSONObject account = jsonObject.getJSONObject("accountID");
- return new DataAccountRegisterOpTemplate(blockchainIdentity(account));
- }
-
- public static DataAccountKVSetOperation convertDataAccountKVSetOperation(JSONObject jsonObject) {
- // 写入集合处理
- JSONArray writeSetObj = jsonObject.getJSONArray("writeSet");
- JSONObject accountAddrObj = jsonObject.getJSONObject("accountAddress");
- String addressBase58 = accountAddrObj.getString("value");
- Bytes address = Bytes.fromBase58(addressBase58);
-
- DataAccountKVSetOpTemplate kvOperation = new DataAccountKVSetOpTemplate(address);
- for (int i = 0; i < writeSetObj.size(); i++) {
- JSONObject currWriteSetObj = writeSetObj.getJSONObject(i);
- long expectedVersion = currWriteSetObj.getLong("expectedVersion");
- JSONObject valueObj = currWriteSetObj.getJSONObject("value");
- String typeStr = valueObj.getString("type");
- String realValBase58 = valueObj.getString("value");
- String key = currWriteSetObj.getString("key");
- DataType dataType = DataType.valueOf(typeStr);
- BytesValue bytesValue = BytesData.fromType(dataType, Base58Utils.decode(realValBase58));
- KVData kvData = new KVData(key, bytesValue, expectedVersion);
- kvOperation.set(kvData);
- }
-
- return kvOperation;
- }
-
- public static LedgerInitOperation convertLedgerInitOperation(JSONObject jsonObject) {
- JSONObject legerInitObj = jsonObject.getJSONObject("initSetting");
- LedgerInitData ledgerInitSettingData = new LedgerInitData();
- String ledgerSeedStr = legerInitObj.getString("ledgerSeed");
-
- // 种子需要做Base64转换
- ledgerInitSettingData.setLedgerSeed(Base64.decodeBase64(BytesUtils.toBytes(ledgerSeedStr)));
-
- String consensusProvider = legerInitObj.getString("consensusProvider");
-
- ledgerInitSettingData.setConsensusProvider(consensusProvider);
-
- JSONObject cryptoSettingObj = legerInitObj.getJSONObject("cryptoSetting");
- boolean autoVerifyHash = cryptoSettingObj.getBoolean("autoVerifyHash");
- short hashAlgorithm = cryptoSettingObj.getShort("hashAlgorithm");
-
- CryptoConfig cryptoConfig = new CryptoConfig();
-
- cryptoConfig.setAutoVerifyHash(autoVerifyHash);
-
- cryptoConfig.setHashAlgorithm(hashAlgorithm);
-
- ledgerInitSettingData.setCryptoSetting(cryptoConfig);
-
- JSONObject consensusSettingsObj = legerInitObj.getJSONObject("consensusSettings");
- Bytes consensusSettings = Bytes.fromBase58(consensusSettingsObj.getString("value"));
-
- ledgerInitSettingData.setConsensusSettings(consensusSettings);
-
- JSONArray consensusParticipantsArray = legerInitObj.getJSONArray("consensusParticipants");
-
- if (!consensusParticipantsArray.isEmpty()) {
- ParticipantNode[] participantNodes = new ParticipantNode[consensusParticipantsArray.size()];
- for (int i = 0; i < consensusParticipantsArray.size(); i++) {
- JSONObject currConsensusParticipant = consensusParticipantsArray.getJSONObject(i);
- String addressBase58 = currConsensusParticipant.getString("address");
- String name = currConsensusParticipant.getString("name");
- int id = currConsensusParticipant.getInteger("id");
- JSONObject pubKeyObj = currConsensusParticipant.getJSONObject("pubKey");
- String pubKeyBase58 = pubKeyObj.getString("value");
- // 生成ParticipantNode对象
- ParticipantCertData participantCertData = new ParticipantCertData(id, Bytes.fromBase58(addressBase58),
- name, new PubKey(Bytes.fromBase58(pubKeyBase58).toBytes()));
- participantNodes[i] = participantCertData;
- }
- ledgerInitSettingData.setConsensusParticipants(participantNodes);
- }
-
- return new LedgerInitOpTemplate(ledgerInitSettingData);
- }
-
- public static UserRegisterOperation convertUserRegisterOperation(JSONObject jsonObject) {
- JSONObject user = jsonObject.getJSONObject("userID");
- return new UserRegisterOpTemplate(blockchainIdentity(user));
- }
-
- public static ContractCodeDeployOperation convertContractCodeDeployOperation(JSONObject jsonObject) {
- JSONObject contract = jsonObject.getJSONObject("contractID");
- BlockchainIdentityData blockchainIdentity = blockchainIdentity(contract);
-
- String chainCodeStr = jsonObject.getString("chainCode");
- ContractCodeDeployOpTemplate contractCodeDeployOpTemplate = new ContractCodeDeployOpTemplate(blockchainIdentity,
- BytesUtils.toBytes(chainCodeStr));
- return contractCodeDeployOpTemplate;
- }
-
- public static ContractEventSendOperation convertContractEventSendOperation(JSONObject jsonObject) {
- JSONObject contractAddressObj = jsonObject.getJSONObject("contractAddress");
- String contractAddress = contractAddressObj.getString("value");
- String argsStr = jsonObject.getString("args");
- String event = jsonObject.getString("event");
- return new ContractEventSendOpTemplate(Bytes.fromBase58(contractAddress), event,
- BytesValueEncoding.encodeArray(new Object[] { argsStr }, null));
- }
-
- private static BlockchainIdentityData blockchainIdentity(JSONObject jsonObject) {
- JSONObject addressObj = jsonObject.getJSONObject("address");
- // base58值
- String addressBase58 = addressObj.getString("value");
- Bytes address = Bytes.fromBase58(addressBase58);
-
- JSONObject pubKeyObj = jsonObject.getJSONObject("pubKey");
- // base58值
- String pubKeyBase58 = pubKeyObj.getString("value");
- PubKey pubKey = new PubKey(Bytes.fromBase58(pubKeyBase58).toBytes());
-
- // 生成对应的对象
- return new BlockchainIdentityData(address, pubKey);
- }
-
- public static class CryptoConfig implements CryptoSetting {
-
- private short hashAlgorithm;
-
- private boolean autoVerifyHash;
-
- @Override
- public CryptoProvider[] getSupportedProviders() {
- return new CryptoProvider[0];
- }
-
- @Override
- public short getHashAlgorithm() {
- return hashAlgorithm;
- }
-
- @Override
- public boolean getAutoVerifyHash() {
- return autoVerifyHash;
- }
-
- public void setHashAlgorithm(short hashAlgorithm) {
- this.hashAlgorithm = hashAlgorithm;
- }
-
- public void setAutoVerifyHash(boolean autoVerifyHash) {
- this.autoVerifyHash = autoVerifyHash;
- }
- }
-
- public static class ParticipantCertData implements ParticipantNode {
- private int id;
- private Bytes address;
- private String name;
- private PubKey pubKey;
-
- public ParticipantCertData() {
- }
-
- public ParticipantCertData(ParticipantNode participantNode) {
- this.address = participantNode.getAddress();
- this.name = participantNode.getName();
- this.pubKey = participantNode.getPubKey();
- }
-
- public ParticipantCertData(int id, Bytes address, String name, PubKey pubKey) {
- this.id = id;
- this.address = address;
- this.name = name;
- this.pubKey = pubKey;
- }
-
- @Override
- public Bytes getAddress() {
- return address;
- }
-
- @Override
- public String getName() {
- return name;
- }
-
- @Override
- public PubKey getPubKey() {
- return pubKey;
- }
-
- public int getId() {
- return id;
- }
-
- public void setId(int id) {
- this.id = id;
- }
- }
-
- public static class KvData implements KVDataEntry {
-
- private String key;
-
- private long version;
-
- private DataType dataType;
-
- private Object value;
-
- public KvData() {
- }
-
- public KvData(String key, long version, DataType dataType) {
- this(key, version, dataType, null);
- }
-
- public KvData(String key, long version, DataType dataType, Object value) {
- this.key = key;
- this.version = version;
- this.dataType = dataType;
- this.value = value;
- }
-
- public void setKey(String key) {
- this.key = key;
- }
-
- public void setVersion(long version) {
- this.version = version;
- }
-
- public void setDataType(DataType dataType) {
- this.dataType = dataType;
- }
-
- public void setValue(Object value) {
- this.value = value;
- }
-
- @Override
- public String getKey() {
- return key;
- }
-
- @Override
- public long getVersion() {
- return version;
- }
-
- @Override
- public DataType getType() {
- return dataType;
- }
-
- @Override
- public Object getValue() {
- return value;
- }
- }
+ public static KVDataEntry[] read(KVDataEntry[] kvDataEntries) {
+ if (kvDataEntries == null || kvDataEntries.length == 0) {
+ return kvDataEntries;
+ }
+ KVDataEntry[] resolveKvDataEntries = new KVDataEntry[kvDataEntries.length];
+ // kvDataEntries是代理对象,需要处理
+ for (int i = 0; i < kvDataEntries.length; i++) {
+ KVDataEntry kvDataEntry = kvDataEntries[i];
+ String key = kvDataEntry.getKey();
+ long version = kvDataEntry.getVersion();
+ DataType dataType = kvDataEntry.getType();
+ KvData innerKvData = new KvData(key, version, dataType);
+ Object valueObj = kvDataEntry.getValue();
+ switch (dataType) {
+ case NIL:
+ break;
+ case BYTES:
+ case TEXT:
+ case JSON:
+ case XML:
+ innerKvData.setValue(valueObj.toString());
+ break;
+ case INT32:
+ innerKvData.setValue(Integer.parseInt(valueObj.toString()));
+ break;
+ case INT64:
+ innerKvData.setValue(Long.parseLong(valueObj.toString()));
+ break;
+ default:
+ throw new IllegalStateException("Unsupported value type[" + dataType + "] to resolve!");
+ }
+ resolveKvDataEntries[i] = innerKvData;
+ }
+ return resolveKvDataEntries;
+ }
+
+ public static Operation read(Operation operation) {
+
+ try {
+ // Class
+ Class> clazz = operation.getClass();
+ Field field = clazz.getSuperclass().getDeclaredField("h");
+ field.setAccessible(true);
+ Object object = field.get(operation);
+ if (object instanceof JSONObject) {
+ JSONObject jsonObject = (JSONObject) object;
+ if (jsonObject.containsKey("accountID")) {
+ return convertDataAccountRegisterOperation(jsonObject);
+ } else if (jsonObject.containsKey("userID")) {
+ return convertUserRegisterOperation(jsonObject);
+ } else if (jsonObject.containsKey("contractID")) {
+ return convertContractCodeDeployOperation(jsonObject);
+ } else if (jsonObject.containsKey("writeSet")) {
+ return convertDataAccountKVSetOperation(jsonObject);
+ } else if (jsonObject.containsKey("initSetting")) {
+ return convertLedgerInitOperation(jsonObject);
+ } else if (jsonObject.containsKey("contractAddress")) {
+ return convertContractEventSendOperation(jsonObject);
+ }
+ }
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+
+ return null;
+ }
+
+ public static Object readValueByBytesValue(BytesValue bytesValue) {
+ DataType dataType = bytesValue.getType();
+ Bytes saveVal = bytesValue.getValue();
+ Object showVal;
+ switch (dataType) {
+ case BYTES:
+ // return hex
+ showVal = HexUtils.encode(saveVal.toBytes());
+ break;
+ case TEXT:
+ case JSON:
+ showVal = saveVal.toUTF8String();
+ break;
+ case INT64:
+ showVal = BytesUtils.toLong(saveVal.toBytes());
+ break;
+ default:
+ showVal = HexUtils.encode(saveVal.toBytes());
+ break;
+ }
+ return showVal;
+ }
+
+ public static DataAccountRegisterOperation convertDataAccountRegisterOperation(JSONObject jsonObject) {
+ JSONObject account = jsonObject.getJSONObject("accountID");
+ return new DataAccountRegisterOpTemplate(blockchainIdentity(account));
+ }
+
+ public static DataAccountKVSetOperation convertDataAccountKVSetOperation(JSONObject jsonObject) {
+ // 写入集合处理
+ JSONArray writeSetObj = jsonObject.getJSONArray("writeSet");
+ JSONObject accountAddrObj = jsonObject.getJSONObject("accountAddress");
+ String addressBase58 = accountAddrObj.getString("value");
+ Bytes address = Bytes.fromBase58(addressBase58);
+
+ DataAccountKVSetOpTemplate kvOperation = new DataAccountKVSetOpTemplate(address);
+ for (int i = 0; i 0) {
+ for (Operation operation : operations) {
+ operation = ClientResolveUtil.read(operation);
+ // 操作类型:数据账户注册操作
+ if (operation instanceof DataAccountRegisterOperation) {
+ DataAccountRegisterOperation daro = (DataAccountRegisterOperation) operation;
+ BlockchainIdentity blockchainIdentity = daro.getAccountID();
+ }
+ // 操作类型:用户注册操作
+ else if (operation instanceof UserRegisterOperation) {
+ UserRegisterOperation uro = (UserRegisterOperation) operation;
+ BlockchainIdentity blockchainIdentity = uro.getUserID();
+ }
+ // 操作类型:账本注册操作
+ else if (operation instanceof LedgerInitOperation) {
+
+ LedgerInitOperation ledgerInitOperation = (LedgerInitOperation)operation;
+ LedgerInitSetting ledgerInitSetting = ledgerInitOperation.getInitSetting();
+
+ ParticipantNode[] participantNodes = ledgerInitSetting.getConsensusParticipants();
+ }
+ // 操作类型:合约发布操作
+ else if (operation instanceof ContractCodeDeployOperation) {
+ ContractCodeDeployOperation ccdo = (ContractCodeDeployOperation) operation;
+ BlockchainIdentity blockchainIdentity = ccdo.getContractID();
+ }
+ // 操作类型:合约执行操作
+ else if (operation instanceof ContractEventSendOperation) {
+ ContractEventSendOperation ceso = (ContractEventSendOperation) operation;
+ }
+ // 操作类型:KV存储操作
+ else if (operation instanceof DataAccountKVSetOperation) {
+ DataAccountKVSetOperation.KVWriteEntry[] kvWriteEntries =
+ ((DataAccountKVSetOperation) operation).getWriteSet();
+ if (kvWriteEntries != null && kvWriteEntries.length > 0) {
+ for (DataAccountKVSetOperation.KVWriteEntry kvWriteEntry : kvWriteEntries) {
+ BytesValue bytesValue = kvWriteEntry.getValue();
+ DataType dataType = bytesValue.getType();
+ Object showVal = ClientResolveUtil.readValueByBytesValue(bytesValue);
+ System.out.println("writeSet.key=" + kvWriteEntry.getKey());
+ System.out.println("writeSet.value=" + showVal);
+ System.out.println("writeSet.type=" + dataType);
+ System.out.println("writeSet.version=" + kvWriteEntry.getExpectedVersion());
+ }
+ }
+ }
+ }
+ }
+ }
+
+ //根据交易的 hash 获得交易;注:客户端生成 PrepareTransaction 时得到交易hash;
+ HashDigest txHash = txList[0].getTransactionContent().getHash();
+// Transaction tx = blockchainService.getTransactionByContentHash(ledgerHash, txHash);
+// String[] objKeys = new String[] { "x001", "x002" };
+// KVDataEntry[] kvData = blockchainService.getDataEntries(ledgerHash, commerceAccount, objKeys);
+
+ // 获取数据账户下所有的KV列表
+ KVDataEntry[] kvData = blockchainService.getDataEntries(ledgerHash, commerceAccount, 0, 100);
+ if (kvData != null && kvData.length > 0) {
+ for (KVDataEntry kvDatum : kvData) {
+ System.out.println("kvData.key=" + kvDatum.getKey());
+ System.out.println("kvData.version=" + kvDatum.getVersion());
+ System.out.println("kvData.type=" + kvDatum.getType());
+ System.out.println("kvData.value=" + kvDatum.getValue());
+ }
+ }
+ }
+}
diff --git a/source/sdk/sdk-samples/src/main/java/com/jd/blockchain/sdk/samples/SDK_Threads_KvInsert_Demo.java b/source/sdk/sdk-samples/src/main/java/com/jd/blockchain/sdk/samples/SDK_Threads_KvInsert_Demo.java
new file mode 100644
index 00000000..c4924af3
--- /dev/null
+++ b/source/sdk/sdk-samples/src/main/java/com/jd/blockchain/sdk/samples/SDK_Threads_KvInsert_Demo.java
@@ -0,0 +1,56 @@
+package com.jd.blockchain.sdk.samples;
+
+import com.jd.blockchain.ledger.*;
+import com.jd.blockchain.utils.codec.Base58Utils;
+
+import java.util.Random;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class SDK_Threads_KvInsert_Demo extends SDK_Base_Demo {
+
+ public static void main(String[] args) throws Exception {
+ new SDK_Threads_KvInsert_Demo().executeThreadsInsert();
+ }
+
+ public void executeThreadsInsert() throws Exception {
+
+ final int MAX = 30;
+
+ final String dataAddress = "LdeNqP4S88t1YjkGQaCGbX95ygD6hA2B6yjp6";
+
+ ExecutorService threadPool = Executors.newFixedThreadPool(50);
+
+ final CountDownLatch latch = new CountDownLatch(MAX);
+
+ for (int i = 0; i < MAX; i++) {
+
+ threadPool.execute(() -> {
+ TransactionTemplate txTemp = blockchainService.newTransaction(ledgerHash);
+
+ String key = System.currentTimeMillis() + "-" +
+ System.nanoTime() + "-" +
+ new Random(Thread.currentThread().getId()).nextInt(1024);
+
+ txTemp.dataAccount(dataAddress).setText(key,"value1",-1);
+
+ // TX 准备就绪
+ PreparedTransaction prepTx = txTemp.prepare();
+ prepTx.sign(adminKey);
+
+ // 提交交易;
+ TransactionResponse response = prepTx.commit();
+
+ System.out.printf("Key = %s, Result = %s \r\n", key, response.isSuccess());
+
+ latch.countDown();
+
+ });
+ }
+
+ latch.await();
+ System.out.println("It is Over !!!");
+ System.exit(0);
+ }
+}
diff --git a/source/test/test-integration/src/test/resources/ledger-binding-mem-0.conf b/source/test/test-integration/src/test/resources/ledger-binding-mem-0.conf
index 1976cb9e..0c79d2ba 100644
--- a/source/test/test-integration/src/test/resources/ledger-binding-mem-0.conf
+++ b/source/test/test-integration/src/test/resources/ledger-binding-mem-0.conf
@@ -3,8 +3,12 @@ ledger.bindings=6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ
#第 1 个账本[6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ]的配置;
+#账本的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.name=myledger
#账本的当前共识参与方的ID;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.id=0
+#账本的当前共识参与方的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.name=a.com
#账本的当前共识参与方的私钥文件的保存路径;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.pk-path=
#账本的当前共识参与方的私钥内容(Base58编码);如果指定了,优先选用此属性,其次是 pk-path 属性;
diff --git a/source/test/test-integration/src/test/resources/ledger-binding-mem-1.conf b/source/test/test-integration/src/test/resources/ledger-binding-mem-1.conf
index de4e8387..8c0b420f 100644
--- a/source/test/test-integration/src/test/resources/ledger-binding-mem-1.conf
+++ b/source/test/test-integration/src/test/resources/ledger-binding-mem-1.conf
@@ -3,8 +3,12 @@ ledger.bindings=6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ
#第 1 个账本[6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ]的配置;
+#账本的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.name=myledger
#账本的当前共识参与方的ID;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.id=1
+#账本的当前共识参与方的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.name=b.com
#账本的当前共识参与方的私钥文件的保存路径;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.pk-path=
#账本的当前共识参与方的私钥内容(Base58编码);如果指定了,优先选用此属性,其次是 pk-path 属性;
diff --git a/source/test/test-integration/src/test/resources/ledger-binding-mem-2.conf b/source/test/test-integration/src/test/resources/ledger-binding-mem-2.conf
index 09d8c70a..8605cdb8 100644
--- a/source/test/test-integration/src/test/resources/ledger-binding-mem-2.conf
+++ b/source/test/test-integration/src/test/resources/ledger-binding-mem-2.conf
@@ -3,8 +3,12 @@ ledger.bindings=6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ
#第 1 个账本[6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ]的配置;
+#账本的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.name=myledger
#账本的当前共识参与方的ID;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.id=2
+#账本的当前共识参与方的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.name=c.com
#账本的当前共识参与方的私钥文件的保存路径;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.pk-path=
#账本的当前共识参与方的私钥内容(Base58编码);如果指定了,优先选用此属性,其次是 pk-path 属性;
diff --git a/source/test/test-integration/src/test/resources/ledger-binding-mem-3.conf b/source/test/test-integration/src/test/resources/ledger-binding-mem-3.conf
index de8e48b3..bfc77145 100644
--- a/source/test/test-integration/src/test/resources/ledger-binding-mem-3.conf
+++ b/source/test/test-integration/src/test/resources/ledger-binding-mem-3.conf
@@ -3,8 +3,12 @@ ledger.bindings=6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ
#第 1 个账本[6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ]的配置;
+#账本的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.name=myledger
#账本的当前共识参与方的ID;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.id=3
+#账本的当前共识参与方的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.name=d.com
#账本的当前共识参与方的私钥文件的保存路径;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.pk-path=
#账本的当前共识参与方的私钥内容(Base58编码);如果指定了,优先选用此属性,其次是 pk-path 属性;
diff --git a/source/test/test-integration/src/test/resources/ledger-binding-redis-0.conf b/source/test/test-integration/src/test/resources/ledger-binding-redis-0.conf
index 81ebfdfa..958d8846 100644
--- a/source/test/test-integration/src/test/resources/ledger-binding-redis-0.conf
+++ b/source/test/test-integration/src/test/resources/ledger-binding-redis-0.conf
@@ -3,8 +3,12 @@ ledger.bindings=6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ
#第 1 个账本[6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ]的配置;
+#账本的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.name=myledger
#账本的当前共识参与方的ID;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.id=0
+#账本的当前共识参与方的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.name=a.com
#账本的当前共识参与方的私钥文件的保存路径;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.pk-path=
#账本的当前共识参与方的私钥内容(Base58编码);如果指定了,优先选用此属性,其次是 pk-path 属性;
diff --git a/source/test/test-integration/src/test/resources/ledger-binding-redis-1.conf b/source/test/test-integration/src/test/resources/ledger-binding-redis-1.conf
index 04a378c9..c311a690 100644
--- a/source/test/test-integration/src/test/resources/ledger-binding-redis-1.conf
+++ b/source/test/test-integration/src/test/resources/ledger-binding-redis-1.conf
@@ -3,8 +3,12 @@ ledger.bindings=6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ
#第 1 个账本[6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ]的配置;
+#账本的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.name=myledger
#账本的当前共识参与方的ID;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.id=1
+#账本的当前共识参与方的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.name=b.com
#账本的当前共识参与方的私钥文件的保存路径;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.pk-path=
#账本的当前共识参与方的私钥内容(Base58编码);如果指定了,优先选用此属性,其次是 pk-path 属性;
diff --git a/source/test/test-integration/src/test/resources/ledger-binding-redis-2.conf b/source/test/test-integration/src/test/resources/ledger-binding-redis-2.conf
index 5054b7bc..d5a8ce58 100644
--- a/source/test/test-integration/src/test/resources/ledger-binding-redis-2.conf
+++ b/source/test/test-integration/src/test/resources/ledger-binding-redis-2.conf
@@ -3,8 +3,12 @@ ledger.bindings=6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ
#第 1 个账本[6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ]的配置;
+#账本的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.name=myledger
#账本的当前共识参与方的ID;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.id=2
+#账本的当前共识参与方的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.name=c.com
#账本的当前共识参与方的私钥文件的保存路径;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.pk-path=
#账本的当前共识参与方的私钥内容(Base58编码);如果指定了,优先选用此属性,其次是 pk-path 属性;
diff --git a/source/test/test-integration/src/test/resources/ledger-binding-redis-3.conf b/source/test/test-integration/src/test/resources/ledger-binding-redis-3.conf
index 7b7bb525..68ef1bd3 100644
--- a/source/test/test-integration/src/test/resources/ledger-binding-redis-3.conf
+++ b/source/test/test-integration/src/test/resources/ledger-binding-redis-3.conf
@@ -3,8 +3,12 @@ ledger.bindings=6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ
#第 1 个账本[6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ]的配置;
+#账本的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.name=myledger
#账本的当前共识参与方的ID;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.id=3
+#账本的当前共识参与方的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.name=d.com
#账本的当前共识参与方的私钥文件的保存路径;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.pk-path=
#账本的当前共识参与方的私钥内容(Base58编码);如果指定了,优先选用此属性,其次是 pk-path 属性;
diff --git a/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-0.conf b/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-0.conf
index a47d1ddd..73ac4731 100644
--- a/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-0.conf
+++ b/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-0.conf
@@ -3,8 +3,12 @@ ledger.bindings=6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ
#第 1 个账本[6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ]的配置;
+#账本的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.name=myledger
#账本的当前共识参与方的ID;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.id=0
+#账本的当前共识参与方的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.name=a.com
#账本的当前共识参与方的私钥文件的保存路径;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.pk-path=
#账本的当前共识参与方的私钥内容(Base58编码);如果指定了,优先选用此属性,其次是 pk-path 属性;
diff --git a/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-1.conf b/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-1.conf
index ccd3679f..9af1f941 100644
--- a/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-1.conf
+++ b/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-1.conf
@@ -3,8 +3,12 @@ ledger.bindings=6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ
#第 1 个账本[6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ]的配置;
+#账本的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.name=myledger
#账本的当前共识参与方的ID;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.id=1
+#账本的当前共识参与方的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.name=b.com
#账本的当前共识参与方的私钥文件的保存路径;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.pk-path=
#账本的当前共识参与方的私钥内容(Base58编码);如果指定了,优先选用此属性,其次是 pk-path 属性;
diff --git a/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-2.conf b/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-2.conf
index 0d440618..087955da 100644
--- a/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-2.conf
+++ b/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-2.conf
@@ -3,8 +3,12 @@ ledger.bindings=6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ
#第 1 个账本[6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ]的配置;
+#账本的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.name=myledger
#账本的当前共识参与方的ID;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.id=2
+#账本的当前共识参与方的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.name=c.com
#账本的当前共识参与方的私钥文件的保存路径;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.pk-path=
#账本的当前共识参与方的私钥内容(Base58编码);如果指定了,优先选用此属性,其次是 pk-path 属性;
diff --git a/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-3.conf b/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-3.conf
index 6fd34834..2e27c865 100644
--- a/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-3.conf
+++ b/source/test/test-integration/src/test/resources/ledger-binding-rocksdb-3.conf
@@ -3,8 +3,12 @@ ledger.bindings=6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ
#第 1 个账本[6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ]的配置;
+#账本的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.name=myledger
#账本的当前共识参与方的ID;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.id=3
+#账本的当前共识参与方的名字;
+binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.name=d.com
#账本的当前共识参与方的私钥文件的保存路径;
binding.6BCg5vgU57ykY6g2CpyUnt5ZMgdxfD1b3qXxQrRyfiXTQ.parti.pk-path=
#账本的当前共识参与方的私钥内容(Base58编码);如果指定了,优先选用此属性,其次是 pk-path 属性;
diff --git a/source/test/test-integration/src/test/resources/ledger_init_test_web2.init b/source/test/test-integration/src/test/resources/ledger_init_test_web2.init
index 90dbedc1..5be0e69d 100644
--- a/source/test/test-integration/src/test/resources/ledger_init_test_web2.init
+++ b/source/test/test-integration/src/test/resources/ledger_init_test_web2.init
@@ -2,7 +2,7 @@
ledger.seed=932dfe23-fe23232f-283f32fa-dd32aa76-8322ca2f-56236cda-7136b322-cb323ffe
#账本的描述名称;此属性不参与共识,仅仅在当前参与方的本地节点用于描述用途;
-#ledger.name=
+ledger.name==myledger
#声明的账本创建时间;格式为 “yyyy-MM-dd HH:mm:ss.SSSZ”,表示”年-月-日 时:分:秒:毫秒时区“;例如:“2019-08-01 14:26:58.069+0800”,其中,+0800 表示时区是东8区
created-time=2019-08-01 14:26:58.069+0800
diff --git a/source/tools/tools-initializer-booter/src/main/java/com/jd/blockchain/tools/initializer/boot/LedgerInitCommandBooter.java b/source/tools/tools-initializer-booter/src/main/java/com/jd/blockchain/tools/initializer/boot/LedgerInitCommandBooter.java
index 0f333e1d..1a25ac34 100644
--- a/source/tools/tools-initializer-booter/src/main/java/com/jd/blockchain/tools/initializer/boot/LedgerInitCommandBooter.java
+++ b/source/tools/tools-initializer-booter/src/main/java/com/jd/blockchain/tools/initializer/boot/LedgerInitCommandBooter.java
@@ -11,6 +11,8 @@ import java.util.List;
public class LedgerInitCommandBooter {
+ private static final String[] JAR_DIRS = new String[]{"libs", "system"};
+
public static void main(String[] args) {
// 加载当前包及../system包下的所有class
load();
@@ -32,7 +34,7 @@ public class LedgerInitCommandBooter {
Method method = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);
boolean accessible = method.isAccessible();
try {
- if (accessible == false) {
+ if (!accessible) {
method.setAccessible(true);
}
// 获取系统类加载器
@@ -64,9 +66,12 @@ public class LedgerInitCommandBooter {
}
File file = new File(currPath);
loadJarFiles.addAll(dirJars(file));
- // 获取上级路径
- String systemPath = file.getParent() + File.separator + "system";
- loadJarFiles.addAll(dirJars(new File(systemPath)));
+
+ for (String jarDir : JAR_DIRS) {
+ // 获取上级路径
+ String jarPath = file.getParent() + File.separator + jarDir;
+ loadJarFiles.addAll(dirJars(new File(jarPath)));
+ }
} catch (Exception e) {
throw new RuntimeException(e);
}
diff --git a/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/LedgerBindingConfig.java b/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/LedgerBindingConfig.java
index 33fa7674..25fc6519 100644
--- a/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/LedgerBindingConfig.java
+++ b/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/LedgerBindingConfig.java
@@ -35,6 +35,8 @@ public class LedgerBindingConfig {
// Participant Attribute Key;
public static final String PARTI_ADDRESS = PARTI_PREFIX + "address";
+ // 参与方名称
+ public static final String PARTI_NAME = PARTI_PREFIX + "name";
public static final String PARTI_PK_PATH = PARTI_PREFIX + "pk-path";
public static final String PARTI_PK = PARTI_PREFIX + "pk";
public static final String PARTI_PASSWORD = PARTI_PREFIX + "pwd";
@@ -47,6 +49,9 @@ public class LedgerBindingConfig {
public static final String DB_CONN = DB_PREFIX + "uri";
public static final String DB_PASSWORD = DB_PREFIX + "pwd";
+ // 账本名字
+ public static final String LEDGER_NAME = "name";
+
// ------------------------------
private Map bindings = new LinkedHashMap<>();
@@ -89,6 +94,7 @@ public class LedgerBindingConfig {
for (int i = 0; i < hashs.length; i++) {
writeLine(builder, "#第 %s 个账本[%s]的配置;", i + 1, hashs[i].toBase58());
BindingConfig binding = getLedger(hashs[i]);
+ writeLedger(builder, hashs[i], binding);
writeParticipant(builder, hashs[i], binding);
writeDB(builder, hashs[i], binding);
writeLine(builder);
@@ -113,11 +119,14 @@ public class LedgerBindingConfig {
// 参与方配置;
String partiAddressKey = String.join(ATTR_SEPERATOR, ledgerPrefix, PARTI_ADDRESS);
String partiPkPathKey = String.join(ATTR_SEPERATOR, ledgerPrefix, PARTI_PK_PATH);
+ String partiNameKey = String.join(ATTR_SEPERATOR, ledgerPrefix, PARTI_NAME);
String partiPKKey = String.join(ATTR_SEPERATOR, ledgerPrefix, PARTI_PK);
String partiPwdKey = String.join(ATTR_SEPERATOR, ledgerPrefix, PARTI_PASSWORD);
writeLine(builder, "#账本的当前共识参与方的节点地址 Address;");
writeLine(builder, "%s=%s", partiAddressKey, stringOf(binding.getParticipant().getAddress()));
+ writeLine(builder, "#账本的当前共识参与方的节点名称 NodeName;");
+ writeLine(builder, "%s=%s", partiNameKey, stringOf(binding.getParticipant().getName()));
writeLine(builder, "#账本的当前共识参与方的私钥文件的保存路径;");
writeLine(builder, "%s=%s", partiPkPathKey, stringOf(binding.getParticipant().getPkPath()));
writeLine(builder, "#账本的当前共识参与方的私钥内容(Base58编码);如果指定了,优先选用此属性,其次是 pk-path 属性;");
@@ -140,6 +149,16 @@ public class LedgerBindingConfig {
writeLine(builder);
}
+ private void writeLedger(StringBuilder builder, HashDigest ledgerHash, BindingConfig binding) {
+ String ledgerPrefix = String.join(ATTR_SEPERATOR, BINDING_PREFIX, ledgerHash.toBase58());
+ // 账本相关信息配置;
+ String ledgerNameKey = String.join(ATTR_SEPERATOR, ledgerPrefix, LEDGER_NAME);
+
+ writeLine(builder, "#账本的名称;");
+ writeLine(builder, "%s=%s", ledgerNameKey, stringOf(binding.getLedgerName()));
+ writeLine(builder);
+ }
+
private static String stringOf(Object obj) {
if (obj == null) {
return "";
@@ -219,11 +238,12 @@ public class LedgerBindingConfig {
// 参与方配置;
String partiAddrKey = String.join(ATTR_SEPERATOR, ledgerPrefix, PARTI_ADDRESS);
String partiPkPathKey = String.join(ATTR_SEPERATOR, ledgerPrefix, PARTI_PK_PATH);
+ String partiNameKey = String.join(ATTR_SEPERATOR, ledgerPrefix, PARTI_NAME);
String partiPKKey = String.join(ATTR_SEPERATOR, ledgerPrefix, PARTI_PK);
String partiPwdKey = String.join(ATTR_SEPERATOR, ledgerPrefix, PARTI_PASSWORD);
- String strPartiAddr = getProperty(props, partiAddrKey, true);
- binding.participant.address = strPartiAddr;
+ binding.participant.address = getProperty(props, partiAddrKey, true);
+ binding.participant.name = getProperty(props, partiNameKey, true);
binding.participant.pkPath = getProperty(props, partiPkPathKey, false);
binding.participant.pk = getProperty(props, partiPKKey, false);
binding.participant.password = getProperty(props, partiPwdKey, false);
@@ -247,6 +267,10 @@ public class LedgerBindingConfig {
String.format("No db connection config of participant of ledger binding[%s]!", ledgerHash));
}
+ // 设置账本名称
+ String ledgerNameKey = String.join(ATTR_SEPERATOR, ledgerPrefix, LEDGER_NAME);
+ binding.ledgerName = getProperty(props, ledgerNameKey, true);
+
return binding;
}
@@ -296,6 +320,9 @@ public class LedgerBindingConfig {
public static class BindingConfig {
+ private String ledgerName;
+
+ // 账本名字
private ParticipantBindingConfig participant = new ParticipantBindingConfig();
private DBConnectionConfig dbConnection = new DBConnectionConfig();
@@ -308,18 +335,35 @@ public class LedgerBindingConfig {
return dbConnection;
}
+ public void setLedgerName(String ledgerName) {
+ this.ledgerName = ledgerName;
+ }
+
+ public String getLedgerName() {
+ return ledgerName;
+ }
}
public static class ParticipantBindingConfig {
private String address;
+ private String name;
+
private String pkPath;
private String pk;
private String password;
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
public String getAddress() {
return address;
}
diff --git a/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/LedgerInitCommand.java b/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/LedgerInitCommand.java
index 65c8138a..4617076a 100644
--- a/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/LedgerInitCommand.java
+++ b/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/LedgerInitCommand.java
@@ -2,6 +2,8 @@ package com.jd.blockchain.tools.initializer;
import java.io.File;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
@@ -14,7 +16,7 @@ import com.jd.blockchain.crypto.AddressEncoding;
import com.jd.blockchain.crypto.HashDigest;
import com.jd.blockchain.crypto.PrivKey;
import com.jd.blockchain.crypto.PubKey;
-import com.jd.blockchain.ledger.core.LedgerManager;
+import com.jd.blockchain.ledger.core.impl.LedgerManager;
import com.jd.blockchain.tools.initializer.LedgerBindingConfig.BindingConfig;
import com.jd.blockchain.tools.initializer.LedgerInitProperties.ConsensusParticipantConfig;
import com.jd.blockchain.tools.keygen.KeyGenCommand;
@@ -46,8 +48,14 @@ public class LedgerInitCommand {
// 是否输出调试信息;
private static final String DEBUG_OPT = "-debug";
+ private static final String MONITOR_OPT = "-monitor";
+
private static final Prompter DEFAULT_PROMPTER = new ConsolePrompter();
+ private static final Prompter ANSWER_PROMPTER = new PresetAnswerPrompter("Y");
+
+ private static final Prompter LOG_PROMPTER = new LogPrompter();
+
/**
* 入口;
*
@@ -56,18 +64,22 @@ public class LedgerInitCommand {
public static void main(String[] args) {
Prompter prompter = DEFAULT_PROMPTER;
- Setting argSetting = ArgumentSet.setting().prefix(LOCAL_ARG, INI_ARG).option(DEBUG_OPT);
- ArgumentSet argset = ArgumentSet.resolve(args, argSetting);
+ Setting argSetting = ArgumentSet.setting().prefix(LOCAL_ARG, INI_ARG).option(DEBUG_OPT).option(MONITOR_OPT);
+ ArgumentSet argSet = ArgumentSet.resolve(args, argSetting);
try {
- ArgEntry localArg = argset.getArg(LOCAL_ARG);
+ if (argSet.hasOption(MONITOR_OPT)) {
+ prompter = LOG_PROMPTER;
+ }
+
+ ArgEntry localArg = argSet.getArg(LOCAL_ARG);
if (localArg == null) {
prompter.info("Miss local config file which can be specified with arg [%s]!!!", LOCAL_ARG);
}
LocalConfig localConf = LocalConfig.resolve(localArg.getValue());
- ArgEntry iniArg = argset.getArg(INI_ARG);
+ ArgEntry iniArg = argSet.getArg(INI_ARG);
if (iniArg == null) {
prompter.info("Miss ledger initializing config file which can be specified with arg [%s]!!!", INI_ARG);
return;
@@ -135,7 +147,7 @@ public class LedgerInitCommand {
} catch (Exception e) {
prompter.error("\r\nError!! -- %s\r\n", e.getMessage());
- if (argset.hasOption(DEBUG_OPT)) {
+ if (argSet.hasOption(DEBUG_OPT)) {
e.printStackTrace();
}
@@ -143,6 +155,10 @@ public class LedgerInitCommand {
}
prompter.confirm(InitializingStep.LEDGER_INIT_COMPLETED.toString(), "\r\n\r\n Press any key to quit. :>");
+ if (argSet.hasOption(MONITOR_OPT)) {
+ // 管理工具启动的方式下,需自动退出
+ System.exit(0);
+ }
}
private LedgerManager ledgerManager;
@@ -166,8 +182,14 @@ public class LedgerInitCommand {
// generate binding config;
BindingConfig bindingConf = new BindingConfig();
- bindingConf.getParticipant()
- .setAddress(ledgerInitProperties.getConsensusParticipant(currId).getAddress().toBase58());
+
+ // 设置账本名称
+ bindingConf.setLedgerName(ledgerInitProperties.getLedgerName());
+
+ bindingConf.getParticipant().setAddress(ledgerInitProperties.getConsensusParticipant(currId).getAddress());
+ // 设置参与方名称
+ bindingConf.getParticipant().setName(ledgerInitProperties.getConsensusParticipant(currId).getName());
+
String encodedPrivKey = KeyGenCommand.encodePrivKey(privKey, base58Pwd);
bindingConf.getParticipant().setPk(encodedPrivKey);
bindingConf.getParticipant().setPassword(base58Pwd);
diff --git a/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/LedgerInitProperties.java b/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/LedgerInitProperties.java
index 657d237b..7b48cec6 100644
--- a/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/LedgerInitProperties.java
+++ b/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/LedgerInitProperties.java
@@ -9,11 +9,11 @@ import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
+import com.jd.blockchain.consts.Global;
import com.jd.blockchain.crypto.AddressEncoding;
import com.jd.blockchain.crypto.PubKey;
import com.jd.blockchain.ledger.ParticipantNode;
import com.jd.blockchain.tools.keygen.KeyGenCommand;
-import com.jd.blockchain.utils.Bytes;
import com.jd.blockchain.utils.PropertiesUtils;
import com.jd.blockchain.utils.codec.HexUtils;
import com.jd.blockchain.utils.io.FileUtils;
@@ -24,10 +24,13 @@ public class LedgerInitProperties {
// 账本种子;
public static final String LEDGER_SEED = "ledger.seed";
+ // 账本名称
+ public static final String LEDGER_NAME = "ledger.name";
+
// 声明的账本建立时间;
public static final String CREATED_TIME = "created-time";
// 创建时间的格式;
- public static final String CREATED_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss.SSSZ";
+ public static final String CREATED_TIME_FORMAT = Global.DEFAULT_TIME_FORMAT;
// 共识参与方的个数,后续以 part.id 分别标识每一个参与方的配置;
public static final String PART_COUNT = "cons_parti.count";
@@ -60,6 +63,8 @@ public class LedgerInitProperties {
private byte[] ledgerSeed;
+ private String ledgerName;
+
private List consensusParticipants = new ArrayList<>();
private String consensusProvider;
@@ -74,6 +79,10 @@ public class LedgerInitProperties {
return ledgerSeed.clone();
}
+ public String getLedgerName() {
+ return ledgerName;
+ }
+
public long getCreatedTime() {
return createdTime;
}
@@ -152,12 +161,16 @@ public class LedgerInitProperties {
public static LedgerInitProperties resolve(Properties props) {
return resolve(null, props);
}
-
+
public static LedgerInitProperties resolve(String dir, Properties props) {
String hexLedgerSeed = PropertiesUtils.getRequiredProperty(props, LEDGER_SEED).replace("-", "");
byte[] ledgerSeed = HexUtils.decode(hexLedgerSeed);
LedgerInitProperties initProps = new LedgerInitProperties(ledgerSeed);
+ // 账本名称
+ String ledgerName = PropertiesUtils.getRequiredProperty(props, LEDGER_NAME);
+ initProps.ledgerName = ledgerName;
+
// 创建时间;
String strCreatedTime = PropertiesUtils.getRequiredProperty(props, CREATED_TIME);
try {
@@ -249,7 +262,7 @@ public class LedgerInitProperties {
private int id;
- private Bytes address;
+ private String address;
private String name;
@@ -270,7 +283,7 @@ public class LedgerInitProperties {
}
@Override
- public Bytes getAddress() {
+ public String getAddress() {
return address;
}
@@ -304,7 +317,7 @@ public class LedgerInitProperties {
public void setPubKey(PubKey pubKey) {
this.pubKey = pubKey;
- this.address = AddressEncoding.generateAddress(pubKey);
+ this.address = AddressEncoding.generateAddress(pubKey).toBase58();
}
}
diff --git a/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/LogPrompter.java b/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/LogPrompter.java
new file mode 100644
index 00000000..ccc6a850
--- /dev/null
+++ b/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/LogPrompter.java
@@ -0,0 +1,52 @@
+package com.jd.blockchain.tools.initializer;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class LogPrompter implements Prompter {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(LogPrompter.class);
+
+ private static final String ANSWER_DEFAULT = "Yes";
+
+ private boolean debug = true;
+
+ @Override
+ public void info(String format, Object... args) {
+ LOGGER.info(format, args);
+ }
+
+ @Override
+ public void error(String format, Object... args) {
+ LOGGER.error(format, args);
+ }
+
+ @Override
+ public void error(Exception error, String format, Object... args) {
+ if (debug) {
+ error.printStackTrace();
+ LOGGER.error(error.toString());
+ }
+ }
+
+ @Override
+ public String confirm(String format, Object... args) {
+ return confirm("", format, args);
+ }
+
+ @Override
+ public String confirm(String tag, String format, Object... args) {
+ String msg = String.format(format, args);
+ LOGGER.info(msg);
+ return ANSWER_DEFAULT;
+ }
+
+ public boolean isDebug() {
+ return debug;
+ }
+
+ public void setDebug(boolean debug) {
+ this.debug = debug;
+ }
+
+}
\ No newline at end of file
diff --git a/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/PresetAnswerPrompter.java b/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/PresetAnswerPrompter.java
new file mode 100644
index 00000000..dbd06917
--- /dev/null
+++ b/source/tools/tools-initializer/src/main/java/com/jd/blockchain/tools/initializer/PresetAnswerPrompter.java
@@ -0,0 +1,30 @@
+package com.jd.blockchain.tools.initializer;
+
+import java.util.Properties;
+
+public class PresetAnswerPrompter extends ConsolePrompter {
+
+ private Properties answers = new Properties();
+
+ private String defaultAnswer;
+
+ public PresetAnswerPrompter(String defaultAnswer) {
+ this.defaultAnswer = defaultAnswer;
+ }
+
+ public void setAnswer(String tag, String answer) {
+ answers.setProperty(tag, answer);
+ }
+
+ public void setDefaultAnswer(String defaultAnswer) {
+ this.defaultAnswer = defaultAnswer;
+ }
+
+ @Override
+ public String confirm(String tag, String format, Object... args) {
+ System.out.print(String.format(format, args));
+ String answer = answers.getProperty(tag, defaultAnswer);
+ System.out.println(String.format("\r\n [Default answer:%s]", answer));
+ return answer;
+ }
+}
diff --git a/source/tools/tools-initializer/src/main/resources/application.properties b/source/tools/tools-initializer/src/main/resources/application.properties
index 2090d209..16cdc6bf 100644
--- a/source/tools/tools-initializer/src/main/resources/application.properties
+++ b/source/tools/tools-initializer/src/main/resources/application.properties
@@ -1,17 +1,13 @@
server.address=127.0.0.1
server.port=8900
-#server.ssl.key-store=classpath:mykeys.jks
-#server.ssl.key-store-password=abc123
-#server.ssl.key-password=abc123
-
server.tomcat.accesslog.enabled=true
debug=false
+logging.config=classpath:log4j2-init.xml
#logging.file=logs/peer.log
logging.level.com.jd.blockchain=DEBUG
logging.level.org.org.springframework=DEBUG
-spring.mvc.favicon.enabled=false
-
+spring.mvc.favicon.enabled=false
\ No newline at end of file
diff --git a/source/tools/tools-initializer/src/main/resources/banner2.txt b/source/tools/tools-initializer/src/main/resources/banner2.txt
deleted file mode 100644
index f1c960f7..00000000
--- a/source/tools/tools-initializer/src/main/resources/banner2.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
- 888888 8888888b. 888888b. 888 888 .d8888b. 888 d8b
- "88b 888 "Y88b 888 "88b 888 888 d88P Y88b 888 Y8P
- 888 888 888 888 .88P 888 888 888 888 888
- 888 888 888 8888888K. 888 .d88b. .d8888b 888 888 888 88888b. 8888b. 888 88888b.
- 888 888 888 888 "Y88b 888 d88""88b d88P" 888 .88P 888 888 "88b "88b 888 888 "88b
- 888 888 888 888 888 888 888 888 888 888888K 888 888 888 888 .d888888 888 888 888
- 88P 888 .d88P 888 d88P 888 Y88..88P Y88b. 888 "88b Y88b d88P 888 888 888 888 888 888 888
- 888 8888888P" 8888888P" 888 "Y88P" "Y8888P 888 888 "Y8888P" 888 888 "Y888888 888 888 888
- .d88P
- .d88P"
-888P"
diff --git a/source/tools/tools-initializer/src/main/resources/banner3.txt b/source/tools/tools-initializer/src/main/resources/banner3.txt
deleted file mode 100644
index a8e93d02..00000000
--- a/source/tools/tools-initializer/src/main/resources/banner3.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
- $$$$$\ $$$$$$$\ $$$$$$$\ $$\ $$\ $$$$$$\ $$\ $$\
- \__$$ |$$ __$$\ $$ __$$\ $$ | $$ | $$ __$$\ $$ | \__|
- $$ |$$ | $$ | $$ | $$ |$$ | $$$$$$\ $$$$$$$\ $$ | $$\ $$ / \__|$$$$$$$\ $$$$$$\ $$\ $$$$$$$\
- $$ |$$ | $$ | $$$$$$$\ |$$ |$$ __$$\ $$ _____|$$ | $$ | $$ | $$ __$$\ \____$$\ $$ |$$ __$$\
-$$\ $$ |$$ | $$ | $$ __$$\ $$ |$$ / $$ |$$ / $$$$$$ / $$ | $$ | $$ | $$$$$$$ |$$ |$$ | $$ |
-$$ | $$ |$$ | $$ | $$ | $$ |$$ |$$ | $$ |$$ | $$ _$$< $$ | $$\ $$ | $$ |$$ __$$ |$$ |$$ | $$ |
-\$$$$$$ |$$$$$$$ | $$$$$$$ |$$ |\$$$$$$ |\$$$$$$$\ $$ | \$$\ \$$$$$$ |$$ | $$ |\$$$$$$$ |$$ |$$ | $$ |
- \______/ \_______/ \_______/ \__| \______/ \_______|\__| \__| \______/ \__| \__| \_______|\__|\__| \__|
-
-
-
diff --git a/source/tools/tools-initializer/src/main/resources/log4j2-init.xml b/source/tools/tools-initializer/src/main/resources/log4j2-init.xml
new file mode 100644
index 00000000..6ef49baf
--- /dev/null
+++ b/source/tools/tools-initializer/src/main/resources/log4j2-init.xml
@@ -0,0 +1,62 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/source/tools/tools-initializer/src/test/java/test/com/jd/blockchain/tools/initializer/LedgerInitPropertiesTest.java b/source/tools/tools-initializer/src/test/java/test/com/jd/blockchain/tools/initializer/LedgerInitPropertiesTest.java
index 703b86b4..3e0a004e 100644
--- a/source/tools/tools-initializer/src/test/java/test/com/jd/blockchain/tools/initializer/LedgerInitPropertiesTest.java
+++ b/source/tools/tools-initializer/src/test/java/test/com/jd/blockchain/tools/initializer/LedgerInitPropertiesTest.java
@@ -1,17 +1,18 @@
package test.com.jd.blockchain.tools.initializer;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
import java.io.IOException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
+import java.util.TimeZone;
-import com.jd.blockchain.crypto.AddressEncoding;
import org.junit.Test;
import org.springframework.core.io.ClassPathResource;
+import com.jd.blockchain.crypto.AddressEncoding;
import com.jd.blockchain.crypto.PubKey;
import com.jd.blockchain.tools.initializer.LedgerInitProperties;
import com.jd.blockchain.tools.initializer.LedgerInitProperties.ConsensusParticipantConfig;
@@ -22,12 +23,21 @@ public class LedgerInitPropertiesTest {
private static String expectedCreatedTimeStr = "2019-08-01 14:26:58.069+0800";
+ private static String expectedCreatedTimeStr1 = "2019-08-01 13:26:58.069+0700";
+
@Test
public void testTimeFormat() throws ParseException {
SimpleDateFormat timeFormat = new SimpleDateFormat(LedgerInitProperties.CREATED_TIME_FORMAT);
+// timeFormat.setTimeZone(TimeZone.getTimeZone("GMT+08:00"));
+ TimeZone.setDefault(TimeZone.getTimeZone("GMT+08:00"));
+
Date time = timeFormat.parse(expectedCreatedTimeStr);
String actualTimeStr = timeFormat.format(time);
assertEquals(expectedCreatedTimeStr, actualTimeStr);
+
+ Date time1 = timeFormat.parse(expectedCreatedTimeStr1);
+ String actualTimeStr1 = timeFormat.format(time1);
+ assertEquals(expectedCreatedTimeStr, actualTimeStr1);
}
@Test
@@ -43,6 +53,7 @@ public class LedgerInitPropertiesTest {
assertEquals(expectedLedgerSeed, actualLedgerSeed);
SimpleDateFormat timeFormat = new SimpleDateFormat(LedgerInitProperties.CREATED_TIME_FORMAT);
+ timeFormat.setTimeZone(TimeZone.getTimeZone("GMT+08:00"));
long expectedTs = timeFormat.parse(expectedCreatedTimeStr).getTime();
assertEquals(expectedTs, initProps.getCreatedTime());
diff --git a/source/tools/tools-initializer/src/test/resources/ledger.init b/source/tools/tools-initializer/src/test/resources/ledger.init
index ad2b5f1f..2d574f93 100644
--- a/source/tools/tools-initializer/src/test/resources/ledger.init
+++ b/source/tools/tools-initializer/src/test/resources/ledger.init
@@ -3,7 +3,7 @@
ledger.seed=932dfe23-fe23232f-283f32fa-dd32aa76-8322ca2f-56236cda-7136b322-cb323ffe
#账本的描述名称;此属性不参与共识,仅仅在当前参与方的本地节点用于描述用途;
-ledger.name=
+ledger.name=test
#声明的账本创建时间;格式为 “yyyy-MM-dd HH:mm:ss.SSSZ”,表示”年-月-日 时:分:秒:毫秒时区“;例如:“2019-08-01 14:26:58.069+0800”,其中,+0800 表示时区是东8区
created-time=2019-08-01 14:26:58.069+0800
diff --git a/source/tools/tools-joiner/src/test/java/com/jd/blockchain/AppTest.java b/source/tools/tools-joiner/src/test/java/com/jd/blockchain/AppTest.java
new file mode 100644
index 00000000..941b907f
--- /dev/null
+++ b/source/tools/tools-joiner/src/test/java/com/jd/blockchain/AppTest.java
@@ -0,0 +1,20 @@
+package com.jd.blockchain;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/**
+ * Unit test for simple App.
+ */
+public class AppTest
+{
+ /**
+ * Rigorous Test :-)
+ */
+ @Test
+ public void shouldAnswerWithTrue()
+ {
+ assertTrue( true );
+ }
+}
diff --git a/source/utils/utils-http/pom.xml b/source/utils/utils-http/pom.xml
index 53053a54..e62e9564 100644
--- a/source/utils/utils-http/pom.xml
+++ b/source/utils/utils-http/pom.xml
@@ -43,6 +43,11 @@
org.springframework
spring-beans
+
+ org.springframework.boot
+ spring-boot-starter-log4j2
+ test
+
-
\ No newline at end of file
+
diff --git a/tools/core-0.1.4.jar b/tools/core-0.1.4.jar
new file mode 100644
index 00000000..85ea3a4a
Binary files /dev/null and b/tools/core-0.1.4.jar differ