【quorum源码】quorum tessera源码剖析

大家好，又见面了，我是你们的朋友全栈君。

概述

tessera是quorum的一种隐私管理器实现，使用Java语言编写，用于对quorum隐私交易的加密、解密和分发。
原理参考:Quorum工作原理

1. 项目结构

tessera
├── argon2 hash函数库,类似的函数还有pbkdf2、bcrypt、 scrypt
├── cli 使用picocli实现的命令行tessera（包含子命令keygen|keyupdate|admin）
├── config 配置数据模型,给各个模块使用的配置
├── config-migration 提供命令行可以将Constellation TOML转换成Tessera JSON
├── data-migration 创建表结构
├── ddls ddl语句,包含两张表(支持mysq、oracle、postgresql、h2、hsql、sqllite)
├── enclave 提供加密、解密接口/Restful api(调用encryption模块)
├── encryption 生成主密钥、共享密钥、加密解密payload、生成随机数等.实现有ec、jnacl、kalium三种
├── key-generation 公钥私钥生成,包含aws、azure、hashcorp三种实现
├── key-vault 密钥保险箱 ,有aws、azure、hashcorp三种实现,可将密钥保存在这些在线服务上
├── security ssl通信相关工具
├── server 包含两个TesseraServer的实现:1、使用Jersey和Jetty 实现的RestServer;2 WebSocketServer
├── service-locator 获取服务实例,默认使用spring 配置文件 tessera-spring.xml中的定义(不使用注解?)
├── shared 大杂烩,包含一些工具类:控制台密码读取、ReflectCallback、JaxbCallback等CallBack
├── tessera-context 上下文,见下面的RuntimeContext
├── tessera-core 主要包含TransactionManager
├── tessera-data 主要包含EncryptedTransactionDAO、EncryptedRawTransactionDAO的实现
├── tessera-dist 系统launcher入口,包含tessera-spring.xml配置文件
├── tessera-jaxrs 系统RESTful API(OpenAPI)定义
├── tessera-partyinfo 参与者之间的服务发现、p2p连接、推送EncodedPayload到其他节点
├── tessera-sync peer节点之间Transaction的同步
├── test-utils 测试mock工具
└── tests 测试用例
参考下面的接口和类

2. 数据库结构

存储hash和加密playload对应关系

CREATE TABLE ENCRYPTED_TRANSACTION (
ENCODED_PAYLOAD BLOB NOT NULL, 
HASH VARBINARY(100) NOT NULL, 
TIMESTAMP BIGINT, PRIMARY KEY (HASH)
);

CREATE TABLE ENCRYPTED_RAW_TRANSACTION (
ENCRYPTED_KEY BLOB NOT NULL,
ENCRYPTED_PAYLOAD BLOB NOT NULL,
NONCE BLOB NOT NULL,
SENDER BLOB NOT NULL, 
TIMESTAMP BIGINT, 
HASH VARBINARY(100) NOT NULL, PRIMARY KEY (HASH)
);

3. 主要流程

3.1 服务启动

a. 首先通过cli从配置文件tessera-config.json读取配置，根据配置创建运行时上下文（上下文持有当前节点公私钥对，peers列表等引用）
b. 再将当前partyInfo保存到集合中(内存)
c. 根据的serverConfigs循环创建ThirdPartyRestApp、P2PRestApp、Q2TRestApp(未包含EnclaveApplication)Restful服务
d 启动服务监听

顺序图：

主要代码：
main方法

 PicoCliDelegate picoCliDelegate = new PicoCliDelegate();
LOGGER.debug("Execute PicoCliDelegate with args [{}]",String.join(",",args));
final CliResult cliResult = picoCliDelegate.execute(args);
LOGGER.debug("Executed PicoCliDelegate with args [{}].",String.join(",",args));
CliDelegate.instance().setConfig(cliResult.getConfig().orElse(null));
if (cliResult.isSuppressStartup()) { 

System.exit(0);
}
if (cliResult.getStatus() != 0) { 

System.exit(cliResult.getStatus());
}
final Config config =
cliResult
.getConfig()
.orElseThrow(() -> new NoSuchElementException("No config found. Tessera will not run."));
RuntimeContext runtimeContext = RuntimeContextFactory.newFactory().create(config);
LOGGER.debug("Creating service locator");
ServiceLocator serviceLocator = ServiceLocator.create();
LOGGER.debug("Created service locator {}",serviceLocator);
Set<Object> services = serviceLocator.getServices();
LOGGER.debug("Created {} services",services.size());
services.forEach(o -> LOGGER.debug("Service : {}",o));
services.stream()
.filter(PartyInfoService.class::isInstance)
.map(PartyInfoService.class::cast)
.findAny()
.ifPresent(p -> p.populateStore());
runWebServer(config);   

runWebServer

final List<TesseraServer> servers =
config.getServerConfigs().stream()
.filter(server -> !AppType.ENCLAVE.equals(server.getApp()))
.map(
conf -> { 

Object app =
TesseraAppFactory.create(conf.getCommunicationType(), conf.getApp())
.orElseThrow(
() ->
new IllegalStateException(
"Cant create app for " + conf.getApp()));
return TesseraServerFactory.create(conf.getCommunicationType())
.createServer(conf, Collections.singleton(app));
})
.filter(Objects::nonNull)
.collect(Collectors.toList());
for (TesseraServer ts : servers) { 

ts.start();
}

3.2 交易处理

a.收到交易请求后，将请求交给TransactionManager处理，TransactionManager调用Enclave加密tx(详见下一个流程【加密交易】)，根据加密的payload，调用MessageHashFactory生成tx Hash，
b. 调用DAO将数据保存到数据库
c. 循环接收者列表，将加密了的playload推送给其他Tessera节点处理
d.将tx hash使用base64编码后返回给quorum几点

主要代码：

public SendResponse send(SendRequest sendRequest) { 

final String sender = sendRequest.getFrom();
final PublicKey senderPublicKey =
Optional.ofNullable(sender)
.map(base64Decoder::decode)
.map(PublicKey::from)
.orElseGet(enclave::defaultPublicKey);
final byte[][] recipients =
Stream.of(sendRequest)
.filter(sr -> Objects.nonNull(sr.getTo()))
.flatMap(s -> Stream.of(s.getTo()))
.map(base64Decoder::decode)
.toArray(byte[][]::new);
final List<PublicKey> recipientList = Stream.of(recipients).map(PublicKey::from).collect(Collectors.toList());
recipientList.add(senderPublicKey);
recipientList.addAll(enclave.getForwardingKeys());
final List<PublicKey> recipientListNoDuplicate =
recipientList.stream().distinct().collect(Collectors.toList());
final byte[] raw = sendRequest.getPayload();
final EncodedPayload payload = enclave.encryptPayload(raw, senderPublicKey, recipientListNoDuplicate);
final MessageHash transactionHash =
Optional.of(payload)
.map(EncodedPayload::getCipherText)
.map(messageHashFactory::createFromCipherText)
.get();
final EncryptedTransaction newTransaction =
new EncryptedTransaction(transactionHash, this.payloadEncoder.encode(payload));
this.encryptedTransactionDAO.save(newTransaction);
recipientListNoDuplicate.forEach(
recipient -> { 

final EncodedPayload outgoing = payloadEncoder.forRecipient(payload, recipient);
partyInfoService.publishPayload(outgoing, recipient);
});
final byte[] key = transactionHash.getHashBytes();
final String encodedKey = base64Decoder.encodeToString(key);
return new SendResponse(encodedKey);
}

3.3 加密交易

a. 生成随机主密钥（RMK：NonceMasterKey）和随机数Nonce、接收者随机数Nonce
b.使用步骤a的随机数Nonce和RMK加密message(Transaction Payload)。
c. 根据发送者的公钥从keymanager中获取发送者私钥
d.遍历接收者列表：根据发送者的私钥和接收者的公钥生成共享秘钥，根据共享密钥和接收者随机数加密RMK，最后返回RMK列表
e.返回加密的playload、随机数、RMKs给Transaction Manager

注：图中使用的Encryptor实现是EllipticalCurveEncryptor

主要代码：

 public EncodedPayload encryptPayload(
final RawTransaction rawTransaction, final List<PublicKey> recipientPublicKeys) { 

final MasterKey masterKey =
this.getMasterKey(
rawTransaction.getFrom(), rawTransaction.getFrom(),
rawTransaction.getNonce(), rawTransaction.getEncryptedKey());
final Nonce recipientNonce = encryptor.randomNonce();
final List<byte[]> encryptedMasterKeys =
buildRecipientMasterKeys(rawTransaction.getFrom(), recipientPublicKeys, recipientNonce, masterKey);
return EncodedPayload.Builder.create()
.withSenderKey(rawTransaction.getFrom())
.withCipherText(rawTransaction.getEncryptedPayload())
.withCipherTextNonce(rawTransaction.getNonce())
.withRecipientBoxes(encryptedMasterKeys)
.withRecipientNonce(recipientNonce)
.withRecipientKeys(recipientPublicKeys)
.build();
}
private List<byte[]> buildRecipientMasterKeys(
final PublicKey senderPublicKey,
final List<PublicKey> recipientPublicKeys,
final Nonce recipientNonce,
final MasterKey masterKey) { 

final PrivateKey privateKey = keyManager.getPrivateKeyForPublicKey(senderPublicKey);
return recipientPublicKeys.stream()
.map(publicKey -> encryptor.computeSharedKey(publicKey, privateKey))
.map(sharedKey -> encryptor.sealAfterPrecomputation(masterKey.getKeyBytes(), recipientNonce, sharedKey))
.collect(Collectors.toList());
}

4. Restful API

4.1 Q2TRestApp

quorum节点和tessera之间的数据交换

4.2 ThirdPartyRestApp

4.3 P2PRestApp

tessera节点之间的数据交换

4.4 EnclaveApplication

提供main方法,可以独立启动成web服务提供Restful API,也可以走内部调用(默认)

5. 一些核心接口

App、Enclave相关的类图：

某些接口手工加了成员变量

com.quorum.tessera.server.TesseraServer

public interface TesseraServer { 

void start() throws Exception;
void stop() throws Exception;
}

com.quorum.tessera.key.generation.KeyGenerator

public interface KeyGenerator { 

ConfigKeyPair generate(String filename, ArgonOptions encryptionOptions, KeyVaultOptions keyVaultOptions);
}

com.quorum.tessera.encryption.Encryptor

/** * The API provided to the application that all implementation of this API * module should extend * <p> * Provides all function relating to encrypting and decrypting messages * using public/private and symmetric keys. */
public interface Encryptor { 

/** * Compute the shared key from a public/private key combination * The keys must be from different keysets. * Providing the public key for the corresponding private key (and vice versa) results in an error * <p> * The shared key for a public/private key combo is the same as if the private/public corresponding keys * were provided. * i.e. public1/private2 == private1/public2 * * @param publicKey A public key from the first keyset * @param privateKey A private key from the second keyset * @return The shared key for this key pair. */
SharedKey computeSharedKey(PublicKey publicKey, PrivateKey privateKey);
/** * Encrypt a payload directly using the given public/private key pair for the sender/recipient * * @param message The payload to be encrypted * @param nonce A unique nonce for this public/private pair * @param publicKey The key from either sender or recipient * @param privateKey The other key from either sender or recipient * @return The encrypted payload */
byte[] seal(byte[] message, Nonce nonce, PublicKey publicKey, PrivateKey privateKey);
/** * Decrypt a payload directly using the given public/private key pair for the sender/recipient * * @param cipherText The payload to be encrypted * @param nonce A unique nonce for this public/private pair * @param publicKey The key from either sender or recipient * @param privateKey The other key from either sender or recipient * @return The encrypted payload */
byte[] open(byte[] cipherText, Nonce nonce, PublicKey publicKey, PrivateKey privateKey);
/** * Encrypt a payload using the given public/private key pair for the sender/recipient * * @param message The payload to be encrypted * @param nonce A unique nonce for this public/private pair * @param sharedKey The shared key between the sender and recipient of the payload * @return The encrypted payload */
byte[] sealAfterPrecomputation(byte[] message, Nonce nonce, SharedKey sharedKey);
default byte[] sealAfterPrecomputation(byte[] message, Nonce nonce, MasterKey masterKey) { 

SharedKey sharedKey = SharedKey.from(masterKey.getKeyBytes());
return sealAfterPrecomputation(message, nonce, sharedKey);
}
/** * Decrypts a payload using the shared key between the sender and recipient * * @param cipherText The encrypted payload * @param nonce The nonce that was used to encrypt this payload * @param sharedKey The shared key for the sender and recipient * @return The decrypted payload */
byte[] openAfterPrecomputation(byte[] cipherText, Nonce nonce, SharedKey sharedKey);
/** * Generates a new random nonce of the correct size * * @return a {@link Nonce} containing random data to be used as a nonce */
Nonce randomNonce();
/** * Generates a new public and private keypair * * @return A pair of public and private keys */
KeyPair generateNewKeys();
/** * Creates a single standalone key * * @return The randomly generated key */
SharedKey createSingleKey();
/** * Create a randomly generated {@link MasterKey} * * @return a random {@link MasterKey} */
default MasterKey createMasterKey() { 

SharedKey sharedKey = createSingleKey();
return MasterKey.from(sharedKey.getKeyBytes());
}
/** * Decrypts a payload using the given {@link MasterKey} * * @param cipherText the ciphertext to decrypt * @param cipherTextNonce the nonce that was used to encrypt the payload * @param masterKey the key used to encrypt the payload * @return the decrypted payload * @see Encryptor#openAfterPrecomputation(byte[], Nonce, SharedKey) */
default byte[] openAfterPrecomputation(byte[] cipherText, Nonce cipherTextNonce, MasterKey masterKey) { 

SharedKey sharedKey = SharedKey.from(masterKey.getKeyBytes());
return openAfterPrecomputation(cipherText, cipherTextNonce, sharedKey);
}
}

com.quorum.tessera.enclave.Enclave

/** * An {@link Enclave} provides encryption/decryption functions and keeps hold * of all the nodes private keys so the do not leak into other services. */
public interface Enclave extends Service { 

private final Encryptor encryptor;
private final KeyManager keyManager;
/** * Retrieves the public key to use if no key is specified for an operation * There is no guarantee this key remains the same between runs of the Enclave. * * @return the public key that has been assigned as the default */
PublicKey defaultPublicKey();
/** * Returns a set of public keys that should be included as recipients to * all transactions produced by this node. The keys are not be managed by * this node. * * @return the set of public keys to be added to transactions */
Set<PublicKey> getForwardingKeys();
/** * Returns all the public keys that are managed by this Enclave. * * @return all public keys managed by this Enclave */
Set<PublicKey> getPublicKeys();
/** * Encrypts a message using the specified sender and a list of recipients. * Returns a {@link EncodedPayload} which contains all the encrypted * information, including the recipients and their encrypted master keys. * * @param message the message to be encrypted * @param senderPublicKey the public key which this enclave manages * @param recipientPublicKeys the recipients to encrypt this message for * @return the encrypted information, represented by an {@link EncodedPayload} */
EncodedPayload encryptPayload(byte[] message, PublicKey senderPublicKey, List<PublicKey> recipientPublicKeys);
/** * Decrypts a {@link RawTransaction} so that it can be re-encrypted into a * {@link EncodedPayload} with the given recipient list * * @param rawTransaction the transactiopn to decrypt and re-encrypt with recipients * @param recipientPublicKeys the recipients to encrypt the transaction for * @return the encrypted information, represented by an {@link EncodedPayload} */
EncodedPayload encryptPayload(RawTransaction rawTransaction, List<PublicKey> recipientPublicKeys);
/** * Encrypt a payload without any recipients that can be retrieved later. * The payload is encrypted using the private key that is related to the * given public key. * * @param message the message to be encrypted * @param sender the sender's public key to encrypt the transaction with * @return the encrypted transaction */
RawTransaction encryptRawPayload(byte[] message, PublicKey sender);
/** * Decrypt a transaction and fetch the original message using the given * public key. Throws an {@link com.quorum.tessera.nacl.NaclException} if * the provided public key OR one of the Enclave's managed keys cannot be * used to decrypt the payload * * @param payload the encrypted payload * @param providedKey the key to use for decryption, if the payload wasn't sent by this Enclave * @return the original, decrypted message */
byte[] unencryptTransaction(EncodedPayload payload, PublicKey providedKey);
/** * Creates a new recipient box for the payload, for which we must be the originator. * At least one recipient must already be available to be able to decrypt the master key. * * @param payload the payload to add a recipient to * @param recipientKey the new recipient key to add */
byte[] createNewRecipientBox(EncodedPayload payload, PublicKey recipientKey);
@Override
default void start() { 

}
@Override
default void stop() { 

}
}

com.quorum.tessera.context.RuntimeContext

public interface RuntimeContext { 

List<KeyPair> getKeys();
KeyEncryptor getKeyEncryptor();
List<PublicKey> getAlwaysSendTo();
List<URI> getPeers();
Client getP2pClient();
boolean isRemoteKeyValidation();
URI getP2pServerUri();
static RuntimeContext getInstance() { 

return ContextHolder.INSTANCE.getContext().get();
}
boolean isDisablePeerDiscovery();
default Set<PublicKey> getPublicKeys() { 

return getKeys().stream().map(KeyPair::getPublicKey).collect(Collectors.toSet());
}
boolean isUseWhiteList();
}

com.quorum.tessera.partyinfo.PartyInfoService

public interface PartyInfoService { 

/** * Request PartyInfo data from all remote nodes that this node is aware of * * @return PartyInfo object */
PartyInfo getPartyInfo();
/** * Update the PartyInfo data store with the provided encoded data.This can happen when endpoint /partyinfo is * triggered, or by a response from this node hitting another node /partyinfo endpoint * * @param partyInfo * @return updated PartyInfo object */
PartyInfo updatePartyInfo(PartyInfo partyInfo);
// Set<String> getUrlsForKey(PublicKey key);
PartyInfo removeRecipient(String uri);
/** * Formats, encodes and publishes encrypted messages using the target public key as the identifier, instead of the * URL * * @param payload the pre-formatted payload object (i.e. with all recipients still present) * @param recipientKey the target public key to publish the payload to * @throws com.quorum.tessera.encryption.KeyNotFoundException if the target public key is not known */
void publishPayload(EncodedPayload payload, PublicKey recipientKey);
// TODO: Added as lifecycle call once RuntimeContext has been created.
void populateStore();
}

com.quorum.tessera.transaction.TransactionManager

	public interface TransactionManager { 

private final PayloadEncoder payloadEncoder;
private final Base64Decoder base64Decoder;
private final EncryptedTransactionDAO encryptedTransactionDAO;
private final EncryptedRawTransactionDAO encryptedRawTransactionDAO;
private final PartyInfoService partyInfoService;
private final Enclave enclave;
private final ResendManager resendManager;
private final MessageHashFactory messageHashFactory = MessageHashFactory.create();
private int resendFetchSize;
SendResponse send(SendRequest sendRequest);
SendResponse sendSignedTransaction(SendSignedRequest sendRequest);
void delete(DeleteRequest request);
ResendResponse resend(ResendRequest request);
MessageHash storePayload(byte[] toByteArray);
ReceiveResponse receive(ReceiveRequest request);
StoreRawResponse store(StoreRawRequest storeRequest);
}

com.quorum.tessera.config.AppType

public enum AppType { 

P2P(CommunicationType.REST),
Q2T(CommunicationType.REST),
THIRD_PARTY(CommunicationType.REST),
ENCLAVE(CommunicationType.REST),
ADMIN(CommunicationType.REST);
}

6. 主要配置文件

tessera-config.json 示例

 { 

"useWhiteList": false,
"jdbc": { 

"username": "sa",
"password": "",
"url": "jdbc:h2:test/db;MODE=Oracle;TRACE_LEVEL_SYSTEM_OUT=0",
"autoCreateTables": true
},
"serverConfigs":[
{ 

"app":"ThirdParty",
"enabled": true,
"serverAddress": "http://$$(hostname -i):9080",
"communicationType" : "REST"
},
{ 

"app":"Q2T",
"enabled": true,
"serverAddress": "unix:$${DDIR}/tm.ipc",
"communicationType" : "REST"
},
{ 

"app":"P2P",
"enabled": true,
"serverAddress": "http://$$(hostname -i):9000",
"sslConfig": { 

"tls": "OFF"
},
"communicationType" : "REST"
}
],
"peer": [
{ 

"url": "http://txmanager1:9000"
},
{ 

"url": "http://txmanager2:9000"
},
{ 

"url": "http://txmanager3:9000"
},
{ 

"url": "http://txmanager4:9000"
},
{ 

"url": "http://txmanager5:9000"
},
{ 

"url": "http://txmanager6:9000"
},
{ 

"url": "http://txmanager7:9000"
}
],
"keys": { 

"passwords": [],
"keyData": [
{ 

"config": "tm.key",
"publicKey": "tm.pub"
}
]
},
"alwaysSendTo": []
}

tessera-dist/tessera-app/src/main/resources/tessera-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<import resource="classpath:/tessera-core-spring.xml" />
<import resource="classpath:/tessera-partyinfo-spring.xml" />
</beans>

tessera-core/src/main/resources/tessera-core-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<tx:annotation-driven transaction-manager="jpaTransactionManager"/>
<context:component-scan base-package="com.quorum.tessera"/>
<bean id="enclaveFactory" class="com.quorum.tessera.enclave.EnclaveFactory" factory-method="create" />
<bean id="enclave" factory-bean="enclaveFactory" factory-method="create">
<constructor-arg ref="config" />
</bean>
<bean class="com.quorum.tessera.service.ServiceContainer">
<constructor-arg ref="enclave" />
</bean>
<bean id="transactionManager" class="com.quorum.tessera.transaction.TransactionManagerImpl">
<constructor-arg ref="encryptedTransactionDAO" />
<constructor-arg ref="enclave" />
<constructor-arg ref="encryptedRawTransactionDAO" />
<constructor-arg ref="resendManager" />
<constructor-arg ref="partyInfoService" />
<constructor-arg value="#{config.getJdbcConfig().getFetchSize() > 0 ? config.getJdbcConfig().getFetchSize() : 1000}"/>
</bean>
<bean id="cliDelegate" class="com.quorum.tessera.cli.CliDelegate" factory-method="instance"/>
<bean id="config" factory-bean="cliDelegate" factory-method="getConfig"/>
<bean name="encryptedTransactionDAO" class="com.quorum.tessera.data.EncryptedTransactionDAOImpl"/>
<bean name="encryptedRawTransactionDAO" class="com.quorum.tessera.data.EncryptedRawTransactionDAOImpl"/>
<bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource">
<property name="jdbcUrl" value="#{ config.getJdbcConfig().getUrl() }" />
<property name="username" value="#{ config.getJdbcConfig().getUsername() }" />
<property name="password" value="#{ resolver.resolve(config.getJdbcConfig().getPassword()) }" />
</bean>
<bean id="jpaTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="persistenceUnitName" value="tessera"/>
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.EclipseLinkJpaVendorAdapter" />
</property>
<property name="jpaDialect">
<bean class="org.springframework.orm.jpa.vendor.EclipseLinkJpaDialect"/>
</property>
<property name="jpaPropertyMap">
<props>
<prop key="eclipselink.weaving">false</prop>
<prop key="eclipselink.session-name">tessera</prop>
<prop key="eclipselink.logging.logger">org.eclipse.persistence.logging.slf4j.SLF4JLogger</prop>
<prop key="eclipselink.logging.session">false</prop>
<prop key="javax.persistence.schema-generation.database.action">#{config.getJdbcConfig().isAutoCreateTables() ? 'create' : 'none'}</prop>
</props>
</property>
</bean>
<bean id="resolver" class="com.quorum.tessera.config.util.EncryptedStringResolver"/>
</beans>

tessera-partyinfo/src/main/resources/tessera-partyinfo-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="p2pClientFactory" class="com.quorum.tessera.partyinfo.P2pClientFactory" factory-method="newFactory">
<constructor-arg ref="config" />
</bean>
<bean id="p2pClient" factory-bean="p2pClientFactory" factory-method="create">
<constructor-arg ref="config"/>
</bean>
<bean id="resendClientFactory" class="com.quorum.tessera.sync.ResendClientFactory" factory-method="newFactory">
<constructor-arg ref="config"/>
</bean>
<bean id="resendClient" factory-bean="resendClientFactory" factory-method="create">
<constructor-arg ref="config"/>
</bean>
<bean id="payloadPublisherFactory" class="com.quorum.tessera.partyinfo.PayloadPublisherFactory" factory-method="newFactory">
<constructor-arg ref="config" />
</bean>
<bean id="payloadPublisher" class="com.quorum.tessera.partyinfo.PayloadPublisher" factory-bean="payloadPublisherFactory" factory-method="create">
<constructor-arg ref="config" />
</bean>
<!-- Party Info management -->
<bean name="partyInfoStore" class="com.quorum.tessera.partyinfo.PartyInfoStore">
<constructor-arg value="#{config.getP2PServerConfig().getServerUri()}"/>
</bean>
<bean name="partyInfoService" class="com.quorum.tessera.partyinfo.PartyInfoServiceImpl">
<constructor-arg ref="partyInfoStore"/>
<constructor-arg ref="enclave"/>
<constructor-arg ref="payloadPublisher"/>
</bean>
<bean name="partyInfoPoller" class="com.quorum.tessera.partyinfo.PartyInfoPoller">
<constructor-arg ref="partyInfoService"/>
<constructor-arg ref="p2pClient"/>
</bean>
<bean name="propertyHelper" class="com.quorum.tessera.config.util.IntervalPropertyHelper">
<constructor-arg value="#{config.getP2PServerConfig().getProperties()}"/>
</bean>
<bean name="partyInfoPollExecutor" class="com.quorum.tessera.threading.TesseraScheduledExecutor">
<constructor-arg>
<bean class="java.util.concurrent.Executors" factory-method="newSingleThreadScheduledExecutor"/>
</constructor-arg>
<constructor-arg ref="partyInfoPoller"/>
<constructor-arg value="#{propertyHelper.partyInfoInterval()}"/>
<constructor-arg value="5000"/>
</bean>
<bean id="resendManager" class="com.quorum.tessera.partyinfo.ResendManagerImpl">
<constructor-arg ref="encryptedTransactionDAO" />
<constructor-arg ref="enclave" />
</bean>
<!-- Local key sync -->
<bean name="enclaveKeySynchroniser" class="com.quorum.tessera.partyinfo.EnclaveKeySynchroniser">
<constructor-arg ref="enclave" />
<constructor-arg ref="partyInfoStore" />
<constructor-arg value="#{config.getP2PServerConfig().getServerUri()}" />
</bean>
<bean name="enclaveKeySynchroniserExecutor" class="com.quorum.tessera.threading.TesseraScheduledExecutor">
<constructor-arg>
<bean class="java.util.concurrent.Executors" factory-method="newSingleThreadScheduledExecutor"/>
</constructor-arg>
<constructor-arg ref="enclaveKeySynchroniser"/>
<constructor-arg value="#{propertyHelper.enclaveKeySyncInterval()}"/>
<constructor-arg value="5000"/>
</bean>
<!-- Node synchronization management-->
<beans profile="enable-sync-poller">
<bean name="resendPartyStore" class="com.quorum.tessera.sync.ResendPartyStoreImpl"/>
<bean name="transactionRequester" class="com.quorum.tessera.sync.TransactionRequesterImpl">
<constructor-arg ref="enclave" />
<constructor-arg ref="resendClient" />
</bean>
<bean name="syncPoller" class="com.quorum.tessera.sync.SyncPoller">
<constructor-arg ref="resendPartyStore" />
<constructor-arg ref="transactionRequester" />
<constructor-arg ref="partyInfoService"/>
<constructor-arg ref="p2pClient"/>
</bean>
<bean class="com.quorum.tessera.threading.TesseraScheduledExecutor">
<constructor-arg>
<bean class="java.util.concurrent.Executors" factory-method="newSingleThreadScheduledExecutor"/>
</constructor-arg>
<constructor-arg ref="syncPoller"/>
<constructor-arg value="#{propertyHelper.syncInterval()}"/>
<constructor-arg value="5000"/>
</bean>
</beans>
</beans>