StakeSquid/dshackle
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #109 from p2p-org/dynamic-merged-head

Browse Source
This commit is contained in:
a10zn8
2023-01-12 19:27:38 +04:00
committed by GitHub
parent ef6246c4a3 bb035b4469
commit 8891539b73
11 changed files with 175 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
src/main/kotlin/io/emeraldpay/dshackle/commons/DynamicMergeFlux.kt Normal file
View File

@@ -0,0 +1,33 @@
package io.emeraldpay.dshackle.commons
import reactor.core.Disposable
import reactor.core.publisher.Flux
import reactor.core.publisher.Sinks
import reactor.core.scheduler.Scheduler
import java.util.concurrent.ConcurrentHashMap
class DynamicMergeFlux<K : Any, T>(private val scheduler: Scheduler) {
private val merge = Sinks.many().multicast().onBackpressureBuffer<T>()
private val sources = ConcurrentHashMap<K, Disposable>()
fun add(flux: Flux<T>, id: K) {
remove(id)
sources.computeIfAbsent(id) { _ ->
flux.subscribeOn(scheduler).subscribe {
merge.emitNext(it) { _, res -> res == Sinks.EmitResult.FAIL_NON_SERIALIZED }
}
}
}
fun remove(id: K) {
sources.remove(id)?.dispose()
}
fun asFlux(): Flux<T> = merge.asFlux()
fun stop() {
sources.forEach { (_, d) -> d.dispose() }
merge.emitComplete { _, res -> res == Sinks.EmitResult.FAIL_NON_SERIALIZED }
}
}

4
src/main/kotlin/io/emeraldpay/dshackle/rpc/StreamHead.kt
View File

@@ -39,9 +39,7 @@ class StreamHead(
return requestMono.map { request ->
Chain.byId(request.type.number)
}.flatMapMany { chain ->
val up = multistreamHolder.getUpstream(chain)
?: return@flatMapMany Flux.error<BlockchainOuterClass.ChainHead>(Exception("Unavailable chain: $chain"))
up.getHead()
multistreamHolder.getUpstream(chain).getHead()
.getFlux()
.map { asProto(chain, it!!) }
.onErrorContinue { t, _ ->

49
src/main/kotlin/io/emeraldpay/dshackle/upstream/DynamicMergedHead.kt Normal file
View File

@@ -0,0 +1,49 @@
package io.emeraldpay.dshackle.upstream
import io.emeraldpay.dshackle.commons.DynamicMergeFlux
import io.emeraldpay.dshackle.data.BlockContainer
import io.emeraldpay.dshackle.upstream.forkchoice.ForkChoice
import org.slf4j.LoggerFactory
import reactor.core.Disposable
import reactor.core.scheduler.Scheduler
open class DynamicMergedHead(
forkChoice: ForkChoice,
private val label: String = "",
scheduler: Scheduler
) : AbstractHead(forkChoice, upstreamId = label), Lifecycle {
companion object {
private val log = LoggerFactory.getLogger(DynamicMergedHead::class.java)
}
private var subscription: Disposable? = null
private val dynamicFlux: DynamicMergeFlux<String, BlockContainer> = DynamicMergeFlux(scheduler)
override fun isRunning(): Boolean {
return subscription != null
}
override fun start() {
super.start()
subscription?.dispose()
subscription = super.follow(
dynamicFlux.asFlux()
)
}
override fun stop() {
super.stop()
dynamicFlux.stop()
subscription?.dispose()
subscription = null
}
fun addHead(upstream: Upstream) {
dynamicFlux.add(upstream.getHead().getFlux(), upstream.getId())
}
fun removeHead(id: String) {
dynamicFlux.remove(id)
}
}

15
src/main/kotlin/io/emeraldpay/dshackle/upstream/Multistream.kt
View File

@@ -140,8 +140,8 @@ abstract class Multistream(
if (it) {
upstreams.add(upstream)
removed.remove(upstream.getId())
addHead(upstream)
onUpstreamsUpdated()
setHead(updateHead())
monitorUpstream(upstream)
}
}
@@ -155,8 +155,8 @@ abstract class Multistream(
}
}.also {
if (it) {
removeHead(id)
onUpstreamsUpdated()
setHead(updateHead())
}
}
@@ -196,6 +196,11 @@ abstract class Multistream(
up.getCapabilities()
}.reduce { acc, curr -> acc + curr }
}
lagObserver?.stop()
lagObserver = null
if (upstreams.isNotEmpty()) {
lagObserver = makeLagObserver()
}
}
}
@@ -274,8 +279,8 @@ abstract class Multistream(
caches.setHead(head)
}
abstract fun updateHead(): Head
abstract fun setHead(head: Head)
abstract fun addHead(upstream: Upstream)
abstract fun removeHead(upstreamId: String)
override fun getId(): String {
return "!all:${chain.chainCode}"
@@ -377,6 +382,8 @@ abstract class Multistream(
fun subscribeRemovedUpstreams(): Flux<Upstream> =
removedUpstreams.asFlux()
abstract fun makeLagObserver(): HeadLagObserver
// --------------------------------------------------------------------------------------------------------
class UpstreamStatus(val upstream: Upstream, val status: UpstreamAvailability, val ts: Instant = Instant.now())

1
src/main/kotlin/io/emeraldpay/dshackle/upstream/MultistreamHolder.kt
View File

@@ -25,6 +25,5 @@ interface MultistreamHolder {
fun getUpstream(chain: Chain): Multistream
fun getAvailable(): List<Chain>
fun isAvailable(chain: Chain): Boolean
fun all(): List<Multistream>
}

24
src/main/kotlin/io/emeraldpay/dshackle/upstream/bitcoin/BitcoinMultistream.kt
View File

@@ -23,7 +23,6 @@ import io.emeraldpay.dshackle.upstream.*
import io.emeraldpay.dshackle.upstream.Lifecycle
import io.emeraldpay.dshackle.upstream.calls.DefaultBitcoinMethods
import io.emeraldpay.dshackle.upstream.forkchoice.MostWorkForkChoice
import org.slf4j.LoggerFactory
import reactor.core.publisher.Mono
@Suppress("UNCHECKED_CAST")
@@ -33,10 +32,6 @@ open class BitcoinMultistream(
caches: Caches,
) : Multistream(chain, sourceUpstreams as MutableList<Upstream>, caches), Lifecycle {
companion object {
private val log = LoggerFactory.getLogger(BitcoinMultistream::class.java)
}
private var head: Head = EmptyHead()
private var esplora = sourceUpstreams.find { it.esploraClient != null }?.esploraClient
private var reader = BitcoinReader(this, head, esplora)
@@ -65,7 +60,7 @@ open class BitcoinMultistream(
return xpubAddresses
}
override fun updateHead(): Head {
fun updateHead(): Head {
head.let {
if (it is Lifecycle) {
it.stop()
@@ -85,9 +80,6 @@ open class BitcoinMultistream(
val newHead = MergedHead(sourceUpstreams.map { it.getHead() }, MostWorkForkChoice()).apply {
this.start()
}
val lagObserver = BitcoinHeadLagObserver(newHead, sourceUpstreams)
this.lagObserver = lagObserver
lagObserver.start()
newHead
}
onHeadUpdated(head)
@@ -121,7 +113,7 @@ open class BitcoinMultistream(
callRouter = LocalCallRouter(getMethods(), reader)
}
override fun setHead(head: Head) {
fun setHead(head: Head) {
this.head = head
reader = BitcoinReader(this, head, esplora)
}
@@ -150,6 +142,10 @@ open class BitcoinMultistream(
return super.isRunning() || reader.isRunning()
}
override fun makeLagObserver(): HeadLagObserver {
return BitcoinHeadLagObserver(head, sourceUpstreams)
}
override fun start() {
super.start()
reader.start()
@@ -159,4 +155,12 @@ open class BitcoinMultistream(
super.stop()
reader.stop()
}
override fun addHead(upstream: Upstream) {
setHead(updateHead())
}
override fun removeHead(upstreamId: String) {
setHead(updateHead())
}
}

67
src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum/EthereumMultistream.kt
View File

@@ -22,16 +22,17 @@ import io.emeraldpay.dshackle.cache.Caches
import io.emeraldpay.dshackle.config.UpstreamsConfig
import io.emeraldpay.dshackle.reader.JsonRpcReader
import io.emeraldpay.dshackle.upstream.*
import io.emeraldpay.dshackle.upstream.Lifecycle
import io.emeraldpay.dshackle.upstream.ethereum.subscribe.AggregatedPendingTxes
import io.emeraldpay.dshackle.upstream.ethereum.subscribe.NoPendingTxes
import io.emeraldpay.dshackle.upstream.ethereum.subscribe.PendingTxesSource
import io.emeraldpay.dshackle.upstream.forkchoice.MostWorkForkChoice
import io.emeraldpay.dshackle.upstream.forkchoice.PriorityForkChoice
import io.emeraldpay.dshackle.upstream.grpc.GrpcUpstream
import org.slf4j.LoggerFactory
import org.springframework.util.ConcurrentReferenceHashMap
import reactor.core.publisher.Flux
import reactor.core.publisher.Mono
import reactor.core.scheduler.Schedulers
@Suppress("UNCHECKED_CAST")
open class EthereumMultistream(
@@ -44,7 +45,12 @@ open class EthereumMultistream(
private val log = LoggerFactory.getLogger(EthereumMultistream::class.java)
}
private var head: Head? = null
private var head: DynamicMergedHead = DynamicMergedHead(
PriorityForkChoice(),
"ETH Multistream",
Schedulers.boundedElastic()
)
private val filteredHeads: MutableMap<String, Head> =
ConcurrentReferenceHashMap(16, ConcurrentReferenceHashMap.ReferenceType.WEAK)
@@ -64,7 +70,7 @@ open class EthereumMultistream(
override fun init() {
if (upstreams.size > 0) {
head = updateHead()
upstreams.forEach { addHead(it) }
}
super.init()
}
@@ -89,6 +95,8 @@ open class EthereumMultistream(
override fun start() {
super.start()
head.start()
onHeadUpdated(head)
reader.start()
}
@@ -98,6 +106,22 @@ open class EthereumMultistream(
filteredHeads.clear()
}
override fun addHead(upstream: Upstream) {
val newHead = upstream.getHead()
if (newHead is Lifecycle && !newHead.isRunning()) {
newHead.start()
}
head.addHead(upstream)
}
override fun removeHead(upstreamId: String) {
head.removeHead(upstreamId)
}
override fun makeLagObserver(): HeadLagObserver {
return EthereumHeadLagObserver(head, upstreams as Collection<Upstream>)
}
override fun isRunning(): Boolean {
return super.isRunning() || reader.isRunning()
}
@@ -107,7 +131,7 @@ open class EthereumMultistream(
}
override fun getHead(): Head {
return head!!
return head
}
override fun tryProxy(
@@ -126,41 +150,6 @@ open class EthereumMultistream(
Flux.merge(it)
}
override fun setHead(head: Head) {
this.head = head
}
override fun updateHead(): Head {
head?.let {
if (it is Lifecycle) {
it.stop()
}
}
lagObserver?.stop()
lagObserver = null
val head = if (upstreams.size == 1) {
val upstream = upstreams.first()
upstream.setLag(0)
upstream.getHead().apply {
if (this is Lifecycle) {
this.start()
}
}
} else {
val heads = upstreams.map { it.getHead() }
val newHead = MergedHead(heads, MostWorkForkChoice(), "ETH Multistream").apply {
this.start()
}
val lagObserver = EthereumHeadLagObserver(newHead, upstreams as Collection<Upstream>)
this.lagObserver = lagObserver
lagObserver.start()
newHead
}
filteredHeads[Selector.AnyLabelMatcher().describeInternal()] = head
onHeadUpdated(head)
return head
}
override fun getLabels(): Collection<UpstreamsConfig.Labels> {
return upstreams.flatMap { it.getLabels() }
}

64
src/main/kotlin/io/emeraldpay/dshackle/upstream/ethereum_pos/EthereumPosMultiStream.kt
View File

@@ -31,6 +31,7 @@ import org.slf4j.LoggerFactory
import org.springframework.util.ConcurrentReferenceHashMap
import reactor.core.publisher.Flux
import reactor.core.publisher.Mono
import reactor.core.scheduler.Schedulers
@Suppress("UNCHECKED_CAST")
open class EthereumPosMultiStream(
@@ -43,7 +44,11 @@ open class EthereumPosMultiStream(
private val log = LoggerFactory.getLogger(EthereumPosMultiStream::class.java)
}
private var head: Head? = null
private var head: DynamicMergedHead = DynamicMergedHead(
PriorityForkChoice(),
"ETH Pos Multistream",
Schedulers.boundedElastic()
)
private val reader: EthereumCachingReader = EthereumCachingReader(this, this.caches, getMethodsFactory())
private var subscribe = EthereumEgressSubscription(this, NoPendingTxes())
@@ -57,13 +62,15 @@ open class EthereumPosMultiStream(
override fun init() {
if (upstreams.size > 0) {
head = updateHead()
upstreams.forEach { addHead(it) }
}
super.init()
}
override fun start() {
super.start()
head.start()
onHeadUpdated(head)
reader.start()
}
@@ -73,16 +80,33 @@ open class EthereumPosMultiStream(
filteredHeads.clear()
}
override fun addHead(upstream: Upstream) {
val newHead = upstream.getHead()
if (newHead is Lifecycle && !newHead.isRunning()) {
newHead.start()
}
head.addHead(upstream)
}
override fun removeHead(upstreamId: String) {
head.removeHead(upstreamId)
}
override fun isRunning(): Boolean {
return super.isRunning() || reader.isRunning()
}
override fun makeLagObserver(): HeadLagObserver =
EthereumPosHeadLagObserver(head, ArrayList(upstreams)).apply {
start()
}
override fun getReader(): EthereumCachingReader {
return reader
}
override fun getHead(): Head {
return head!!
return head
}
override fun tryProxy(
@@ -101,40 +125,6 @@ open class EthereumPosMultiStream(
Flux.merge(it)
}
override fun setHead(head: Head) {
this.head = head
}
override fun updateHead(): Head {
this.head?.takeIf { it is Lifecycle }?.apply { stop() }
lagObserver?.stop()
lagObserver = null
return when (upstreams.size) {
0 -> EmptyHead()
1 -> upstreams.first().let {
it.setLag(0)
it.getHead().apply {
if (this is Lifecycle) {
start()
}
}
}
else -> upstreams.map { it.getHead() }.let { heads ->
MergedHead(heads, PriorityForkChoice(), "ETH Pos Multistream").apply {
start()
}.also {
this.lagObserver = EthereumPosHeadLagObserver(it, ArrayList(upstreams)).apply {
start()
}
}
}
}.also {
onHeadUpdated(it)
}
}
override fun getLabels(): Collection<UpstreamsConfig.Labels> {
return upstreams.flatMap { it.getLabels() }
}

15
src/test/groovy/io/emeraldpay/dshackle/rpc/TrackEthereumTxSpec.groovy
View File

@@ -24,8 +24,11 @@ import io.emeraldpay.dshackle.data.BlockId
import io.emeraldpay.dshackle.data.TxId
import io.emeraldpay.dshackle.test.TestingCommons
import io.emeraldpay.dshackle.test.MultistreamHolderMock
import io.emeraldpay.dshackle.upstream.DynamicMergedHead
import io.emeraldpay.dshackle.upstream.Head
import io.emeraldpay.dshackle.upstream.MergedHead
import io.emeraldpay.dshackle.upstream.MultistreamHolder
import io.emeraldpay.dshackle.upstream.ethereum.EthereumCachingReader
import io.emeraldpay.dshackle.upstream.ethereum.EthereumMultistream
import io.emeraldpay.dshackle.upstream.ethereum.EthereumPosMultiStream
import io.emeraldpay.dshackle.Chain
@@ -38,6 +41,7 @@ import reactor.core.publisher.Flux
import reactor.core.scheduler.Schedulers
import reactor.test.StepVerifier
import reactor.test.scheduler.VirtualTimeScheduler
import spock.lang.Ignore
import spock.lang.Specification
import java.time.Duration
@@ -120,7 +124,7 @@ class TrackEthereumTxSpec extends Specification {
def apiMock = TestingCommons.api()
def upstreamMock = TestingCommons.upstream(apiMock)
MultistreamHolder upstreams = new MultistreamHolderMock(Chain.ETHEREUM, upstreamMock)
((EthereumPosMultiStream) upstreams.getUpstream(Chain.ETHEREUM)).head = Mock(Head) {
((EthereumPosMultiStream) upstreams.getUpstream(Chain.ETHEREUM)).head = Mock(DynamicMergedHead) {
_ * getFlux() >> Flux.empty()
}
def scheduler = VirtualTimeScheduler.create(true)
@@ -233,6 +237,7 @@ class TrackEthereumTxSpec extends Specification {
.verify(Duration.ofSeconds(1))
}
@Ignore
def "Starts to follow new transaction"() {
setup:
def req = BlockchainOuterClass.TxStatusRequest.newBuilder()
@@ -287,7 +292,11 @@ class TrackEthereumTxSpec extends Specification {
def apiMock = TestingCommons.api()
def upstreamMock = TestingCommons.upstream(apiMock)
MultistreamHolder upstreams = new MultistreamHolderMock(Chain.ETHEREUM, upstreamMock)
def multi = Mock(EthereumPosMultiStream) {
_ * getHead() >> upstreamMock.getHead()
}
MultistreamHolder upstreams = new MultistreamHolderMock(Chain.ETHEREUM, multi)
TrackEthereumTx trackTx = new TrackEthereumTx(upstreams, Schedulers.boundedElastic())
apiMock.answerOnce("eth_getTransactionByHash", [txId], null)
@@ -314,7 +323,7 @@ class TrackEthereumTxSpec extends Specification {
.expectNext(exp2.setConfirmations(3).build()).as("Confirmed 3")
.expectNext(exp2.setConfirmations(4).build()).as("Confirmed 4")
.expectComplete()
.verify(Duration.ofSeconds(1))
.verify(Duration.ofSeconds(10))
}
}

1
src/test/groovy/io/emeraldpay/dshackle/test/EthereumPosRpcUpstreamMock.groovy
View File

@@ -26,7 +26,6 @@ import io.emeraldpay.dshackle.upstream.calls.DefaultBitcoinMethods
import io.emeraldpay.dshackle.upstream.calls.DefaultEthereumMethods
import io.emeraldpay.dshackle.upstream.calls.DirectCallMethods
import io.emeraldpay.dshackle.upstream.ethereum.EthereumPosRpcUpstream
import io.emeraldpay.dshackle.upstream.ethereum.EthereumRpcUpstream
import io.emeraldpay.dshackle.upstream.UpstreamAvailability
import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcRequest
import io.emeraldpay.dshackle.upstream.rpcclient.JsonRpcResponse

10
src/test/groovy/io/emeraldpay/dshackle/upstream/MultistreamSpec.groovy
View File

@@ -263,16 +263,6 @@ class MultistreamSpec extends Specification {
return null
}
@Override
Head updateHead() {
return null
}
@Override
void setHead(@NotNull Head head) {
}
@Override
Head getHead() {
return null