digital-asset/daml
1
1
Fork 0
mirror of https://github.com/digital-asset/daml.git synced 2024-09-20 01:07:18 +03:00
Code Issues Projects Releases Wiki Activity

remove unused definitions, params, args from sandbox Scala code (#7035)

Browse Source 
* remove unused definitions, params, args from sandbox Scala code

CHANGELOG_BEGIN
CHANGELOG_END

* remove unused loggingContext from sandbox

* pass pageSize along in JdbcLedgerDaoTransactionsSpec

- seems to have been the intent of the parameter, and at the moment it
  is semantically identical
This commit is contained in:
Stephen Compall 2020-08-06 13:12:59 -04:00 committed by GitHub
parent aa22c3a1cc
commit 3d5e96c9bb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
45 changed files with 75 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
ledger/ledger-on-memory/src/app/scala/com/daml/ledger/on/memory/Main.scala
View File

@ -62,7 +62,6 @@ object Main {
def owner(config: Config[ExtraConfig], participantConfig: ParticipantConfig, engine: Engine)(
implicit materializer: Materializer,
loggingContext: LoggingContext,
): ResourceOwner[KeyValueLedger] = {
val metrics = createMetrics(participantConfig, config)
if (config.extra.alwaysPreExecute)

17
ledger/ledger-on-memory/src/main/scala/com/daml/ledger/on/memory/InMemoryLedgerReaderWriter.scala
View File

@ -43,7 +43,7 @@ final class InMemoryLedgerReaderWriter(
dispatcher: Dispatcher[Index],
state: InMemoryState,
validateAndCommit: ValidateAndCommit,
metrics: Metrics)(implicit materializer: Materializer, executionContext: ExecutionContext)
metrics: Metrics)(implicit executionContext: ExecutionContext)
extends LedgerReader
with LedgerWriter {
override def commit(
@ -76,8 +76,7 @@ object InMemoryLedgerReaderWriter {
validateAndCommit: ValidateAndCommit,
metrics: Metrics,
)(
implicit materializer: Materializer,
executionContext: ExecutionContext,
implicit executionContext: ExecutionContext,
): InMemoryLedgerReaderWriter =
new InMemoryLedgerReaderWriter(
participantId,
@ -172,8 +171,7 @@ object InMemoryLedgerReaderWriter {
dispatcher: Dispatcher[Index],
state: InMemoryState,
engine: Engine,
)(implicit materializer: Materializer)
extends ResourceOwner[KeyValueLedger] {
) extends ResourceOwner[KeyValueLedger] {
override def acquire()(
implicit executionContext: ExecutionContext): Resource[KeyValueLedger] = {
val keyValueCommitting =
@ -200,8 +198,8 @@ object InMemoryLedgerReaderWriter {
batchingLedgerWriterConfig: BatchingLedgerWriterConfig,
state: InMemoryState,
metrics: Metrics,
timeProvider: TimeProvider = DefaultTimeProvider,
stateValueCache: Cache[DamlStateKey, DamlStateValue] = Cache.none,
timeProvider: TimeProvider,
stateValueCache: Cache[DamlStateKey, DamlStateValue],
)(
implicit materializer: Materializer,
executionContext: ExecutionContext,
@ -233,11 +231,10 @@ object InMemoryLedgerReaderWriter {
keySerializationStrategy: StateKeySerializationStrategy,
state: InMemoryState,
metrics: Metrics,
timeProvider: TimeProvider = DefaultTimeProvider,
timeProvider: TimeProvider,
stateValueCacheForPreExecution: Cache[DamlStateKey, (DamlStateValue, Fingerprint)],
)(
implicit materializer: Materializer,
executionContext: ExecutionContext,
implicit executionContext: ExecutionContext,
): ValidateAndCommit = {
val commitStrategy = new LogAppenderPreExecutingCommitStrategy(keySerializationStrategy)
val valueToFingerprint: Option[Value] => Fingerprint =

2
ledger/ledger-on-sql/src/app/scala/com/daml/ledger/on/sql/SqlLedgerFactory.scala
View File

@ -58,7 +58,7 @@ object SqlLedgerFactory extends LedgerFactory[ReadWriteService, ExtraConfig] {
config: Config[ExtraConfig],
participantConfig: ParticipantConfig,
engine: Engine,
)(implicit materializer: Materializer, loggingContext: LoggingContext)
)(implicit loggingContext: LoggingContext)
extends ResourceOwner[KeyValueParticipantState] {
override def acquire()(
implicit executionContext: ExecutionContext

10
ledger/ledger-on-sql/src/main/scala/com/daml/ledger/on/sql/Database.scala
View File

@ -29,19 +29,19 @@ final class Database(
) {
def inReadTransaction[T](name: String)(
body: ReadQueries => Future[T],
)(implicit loggingContext: LoggingContext): Future[T] =
): Future[T] =
inTransaction(name, readerConnectionPool)(connection =>
Future(body(new TimedQueries(queries(connection), metrics)))(readerExecutionContext).flatten)
def inWriteTransaction[T](name: String)(
body: Queries => Future[T],
)(implicit loggingContext: LoggingContext): Future[T] =
): Future[T] =
inTransaction(name, writerConnectionPool)(connection =>
Future(body(new TimedQueries(queries(connection), metrics)))(writerExecutionContext).flatten)
private def inTransaction[T](name: String, connectionPool: DataSource)(
body: Connection => Future[T],
)(implicit loggingContext: LoggingContext): Future[T] = {
): Future[T] = {
val connection = Timed.value(
metrics.daml.ledger.database.transactions.acquireConnection(name),
connectionPool.getConnection())
@ -226,9 +226,7 @@ object Database {
)
}
def migrateAndReset()(
implicit executionContext: ExecutionContext,
loggerCtx: LoggingContext): Future[Database] = {
def migrateAndReset()(implicit executionContext: ExecutionContext): Future[Database] = {
val db = migrate()
db.inWriteTransaction("ledger_reset") { queries =>
Future.fromTry(queries.truncate())

15
ledger/ledger-on-sql/src/main/scala/com/daml/ledger/on/sql/SqlLedgerReaderWriter.scala
View File

@ -6,7 +6,6 @@ package com.daml.ledger.on.sql
import java.util.UUID
import akka.NotUsed
import akka.stream.Materializer
import akka.stream.scaladsl.Source
import com.daml.api.util.TimeProvider
import com.daml.caching.Cache
@ -50,8 +49,6 @@ final class SqlLedgerReaderWriter(
seedService: SeedService
)(
implicit executionContext: ExecutionContext,
materializer: Materializer,
loggingContext: LoggingContext,
) extends LedgerWriter
with LedgerReader {
@ -137,7 +134,7 @@ object SqlLedgerReaderWriter {
stateValueCache: Cache[Bytes, DamlStateValue] = Cache.none,
timeProvider: TimeProvider = DefaultTimeProvider,
seedService: SeedService,
)(implicit materializer: Materializer, loggingContext: LoggingContext)
)(implicit loggingContext: LoggingContext)
extends ResourceOwner[SqlLedgerReaderWriter] {
override def acquire()(
implicit executionContext: ExecutionContext
@ -163,10 +160,9 @@ object SqlLedgerReaderWriter {
)
}
private def updateOrRetrieveLedgerId(providedLedgerId: LedgerId, database: Database)(
implicit executionContext: ExecutionContext,
loggingContext: LoggingContext,
): Future[LedgerId] =
private def updateOrRetrieveLedgerId(
providedLedgerId: LedgerId,
database: Database): Future[LedgerId] =
database.inWriteTransaction("retrieve_ledger_id") { queries =>
Future.fromTry(
queries
@ -184,8 +180,7 @@ object SqlLedgerReaderWriter {
})
}
private final class DispatcherOwner(database: Database)(implicit loggingContext: LoggingContext)
extends ResourceOwner[Dispatcher[Index]] {
private final class DispatcherOwner(database: Database) extends ResourceOwner[Dispatcher[Index]] {
override def acquire()(
implicit executionContext: ExecutionContext
): Resource[Dispatcher[Index]] =

3
ledger/ledger-on-sql/src/test/suite/scala/com/daml/ledger/on/sql/ImmutableMigrationsSpec.scala
View File

@ -32,7 +32,7 @@ class ImmutableMigrationsSpec extends WordSpec {
resources.foreach { resource =>
val migrationFile = resource.getRelativePath
val digestFile = migrationFile + ".sha256"
val expectedDigest = readExpectedDigest(migrationFile, digestFile, resourceScanner)
val expectedDigest = readExpectedDigest(digestFile, resourceScanner)
val currentDigest = computeCurrentDigest(resource, configuration.getEncoding)
assert(
currentDigest == expectedDigest,
@ -58,7 +58,6 @@ object ImmutableMigrationsSpec {
)
private def readExpectedDigest(
sourceFile: String,
digestFile: String,
resourceScanner: Scanner[_],
): String = {

3
ledger/participant-integration-api/src/main/scala/platform/apiserver/ApiServices.scala
View File

@ -206,7 +206,6 @@ private[daml] object ApiServices {
val apiSubmissionService = ApiSubmissionService.create(
ledgerId,
contractStore,
writeService,
submissionService,
partyManagementService,
@ -249,7 +248,7 @@ private[daml] object ApiServices {
val apiPackageManagementService =
ApiPackageManagementService
.createApiService(indexService, transactionsService, writeService, timeProvider)
.createApiService(indexService, transactionsService, writeService)
val apiConfigManagementService =
ApiConfigManagementService

3
ledger/participant-integration-api/src/main/scala/platform/apiserver/LedgerApiServer.scala
View File

@ -4,7 +4,6 @@
package com.daml.platform.apiserver
import akka.actor.ActorSystem
import akka.stream.Materializer
import com.daml.logging.{ContextualizedLogger, LoggingContext}
import com.daml.metrics.Metrics
import com.daml.ports.Port
@ -22,7 +21,7 @@ private[daml] final class LedgerApiServer(
sslContext: Option[SslContext] = None,
interceptors: List[ServerInterceptor] = List.empty,
metrics: Metrics,
)(implicit actorSystem: ActorSystem, materializer: Materializer, loggingContext: LoggingContext)
)(implicit actorSystem: ActorSystem, loggingContext: LoggingContext)
extends ResourceOwner[ApiServer] {
private val logger = ContextualizedLogger.get(this.getClass)

8
ledger/participant-integration-api/src/main/scala/platform/apiserver/services/ApiActiveContractsService.scala
View File

@ -19,13 +19,10 @@ import com.daml.platform.api.grpc.GrpcApiService
import com.daml.platform.server.api.validation.ActiveContractsServiceValidation
import io.grpc.{BindableService, ServerServiceDefinition}
import scala.concurrent.ExecutionContext
private[apiserver] final class ApiActiveContractsService private (
backend: ACSBackend,
)(
implicit executionContext: ExecutionContext,
protected val mat: Materializer,
implicit protected val mat: Materializer,
protected val esf: ExecutionSequencerFactory,
loggingContext: LoggingContext,
) extends ActiveContractsServiceAkkaGrpc
@ -52,8 +49,7 @@ private[apiserver] final class ApiActiveContractsService private (
private[apiserver] object ApiActiveContractsService {
def create(ledgerId: LedgerId, backend: ACSBackend)(
implicit ec: ExecutionContext,
mat: Materializer,
implicit mat: Materializer,
esf: ExecutionSequencerFactory,
loggingContext: LoggingContext,
): ActiveContractsService with GrpcApiService =

7
ledger/participant-integration-api/src/main/scala/platform/apiserver/services/ApiCommandService.scala
View File

@ -10,7 +10,6 @@ import akka.actor.Cancellable
import akka.stream.Materializer
import akka.stream.scaladsl.{Flow, Keep, Source}
import com.daml.api.util.TimeProvider
import com.daml.grpc.adapter.ExecutionSequencerFactory
import com.daml.ledger.api.domain.LedgerId
import com.daml.ledger.api.v1.command_completion_service.{
CompletionEndResponse,
@ -52,8 +51,7 @@ private[apiserver] final class ApiCommandService private (
)(
implicit grpcExecutionContext: ExecutionContext,
actorMaterializer: Materializer,
esf: ExecutionSequencerFactory,
loggingContext: LoggingContext,
loggingContext: LoggingContext
) extends CommandServiceGrpc.CommandService
with AutoCloseable {
@ -172,8 +170,7 @@ private[apiserver] object ApiCommandService {
)(
implicit grpcExecutionContext: ExecutionContext,
actorMaterializer: Materializer,
esf: ExecutionSequencerFactory,
loggingContext: LoggingContext,
loggingContext: LoggingContext
): CommandServiceGrpc.CommandService with GrpcApiService =
new GrpcCommandService(
new ApiCommandService(services, configuration, ledgerConfigProvider),

5
ledger/participant-integration-api/src/main/scala/platform/apiserver/services/ApiLedgerConfigurationService.scala
View File

@ -17,8 +17,6 @@ import com.daml.platform.api.grpc.GrpcApiService
import com.daml.platform.server.api.validation.LedgerConfigurationServiceValidation
import io.grpc.{BindableService, ServerServiceDefinition}
import scala.concurrent.ExecutionContext
private[apiserver] final class ApiLedgerConfigurationService private (
configurationService: IndexConfigurationService,
)(
@ -49,8 +47,7 @@ private[apiserver] final class ApiLedgerConfigurationService private (
private[apiserver] object ApiLedgerConfigurationService {
def create(ledgerId: LedgerId, configurationService: IndexConfigurationService)(
implicit ec: ExecutionContext,
esf: ExecutionSequencerFactory,
implicit esf: ExecutionSequencerFactory,
mat: Materializer,
loggingContext: LoggingContext,
): LedgerConfigurationServiceGrpc.LedgerConfigurationService with GrpcApiService =

11
ledger/participant-integration-api/src/main/scala/platform/apiserver/services/ApiSubmissionService.scala
View File

@ -6,7 +6,6 @@ package com.daml.platform.apiserver.services
import java.time.{Duration, Instant}
import java.util.UUID
import akka.stream.Materializer
import com.daml.api.util.TimeProvider
import com.daml.ledger.api.domain.{LedgerId, Commands => ApiCommands}
import com.daml.ledger.api.messages.command.submission.SubmitRequest
@ -48,7 +47,6 @@ private[apiserver] object ApiSubmissionService {
def create(
ledgerId: LedgerId,
contractStore: ContractStore,
writeService: WriteService,
submissionService: IndexSubmissionService,
partyManagementService: IndexPartyManagementService,
@ -61,12 +59,10 @@ private[apiserver] object ApiSubmissionService {
metrics: Metrics,
)(
implicit ec: ExecutionContext,
mat: Materializer,
loggingContext: LoggingContext,
): GrpcCommandSubmissionService with GrpcApiService =
new GrpcCommandSubmissionService(
service = new ApiSubmissionService(
contractStore,
writeService,
submissionService,
partyManagementService,
@ -93,7 +89,6 @@ private[apiserver] object ApiSubmissionService {
}
private[apiserver] final class ApiSubmissionService private (
contractStore: ContractStore,
writeService: WriteService,
submissionService: IndexSubmissionService,
partyManagementService: IndexPartyManagementService,
@ -104,7 +99,7 @@ private[apiserver] final class ApiSubmissionService private (
commandExecutor: CommandExecutor,
configuration: ApiSubmissionService.Configuration,
metrics: Metrics,
)(implicit ec: ExecutionContext, mat: Materializer, loggingContext: LoggingContext)
)(implicit ec: ExecutionContext, loggingContext: LoggingContext)
extends CommandSubmissionService
with ErrorFactories
with AutoCloseable {
@ -235,7 +230,7 @@ private[apiserver] final class ApiSubmissionService private (
transactionInfo: CommandExecutionResult,
partyAllocationResults: Seq[SubmissionResult],
ledgerConfig: Configuration,
)(implicit loggingContext: LoggingContext): Future[SubmissionResult] =
): Future[SubmissionResult] =
partyAllocationResults.find(_ != SubmissionResult.Acknowledged) match {
case Some(result) =>
Future.successful(result)
@ -263,7 +258,7 @@ private[apiserver] final class ApiSubmissionService private (
private def submitTransaction(
result: CommandExecutionResult,
)(implicit loggingContext: LoggingContext): Future[SubmissionResult] = {
): Future[SubmissionResult] = {
metrics.daml.commands.validSubmissions.mark()
writeService
.submitTransaction(

3
ledger/participant-integration-api/src/main/scala/platform/apiserver/services/LedgerConfigProvider.scala
View File

@ -25,7 +25,7 @@ import com.daml.logging.{ContextualizedLogger, LoggingContext}
import com.daml.platform.configuration.LedgerConfiguration
import scala.compat.java8.FutureConverters
import scala.concurrent.{ExecutionContext, Future, Promise}
import scala.concurrent.{Future, Promise}
import scala.concurrent.duration.{DurationInt, DurationLong}
/**
@ -121,7 +121,6 @@ private[apiserver] final class LedgerConfigProvider private (
}
private[this] def submitInitialConfig(writeService: WriteService): Future[Unit] = {
implicit val executionContext: ExecutionContext = DE
// There are several reasons why the change could be rejected:
// - The participant is not authorized to set the configuration
// - There already is a configuration, it just didn't appear in the index yet

16
ledger/participant-integration-api/src/main/scala/platform/apiserver/services/admin/ApiPackageManagementService.scala
View File

@ -7,12 +7,10 @@ import java.io.ByteArrayInputStream
import java.util.UUID
import java.util.zip.ZipInputStream
import akka.actor.Scheduler
import akka.stream.Materializer
import akka.stream.scaladsl.Sink
import com.daml.ledger.participant.state.index.v2.{IndexPackagesService, IndexTransactionsService}
import com.daml.ledger.participant.state.v1.{SubmissionId, SubmissionResult, WritePackagesService}
import com.daml.api.util.TimeProvider
import com.daml.lf.archive.DarReader
import com.daml.daml_lf_dev.DamlLf.Archive
import com.daml.dec.{DirectExecutionContext => DE}
@ -34,9 +32,7 @@ private[apiserver] final class ApiPackageManagementService private (
packagesIndex: IndexPackagesService,
transactionsService: IndexTransactionsService,
packagesWrite: WritePackagesService,
timeProvider: TimeProvider,
materializer: Materializer,
scheduler: Scheduler)(implicit loggingContext: LoggingContext)
materializer: Materializer)(implicit loggingContext: LoggingContext)
extends PackageManagementService
with GrpcApiService {
@ -134,13 +130,7 @@ private[apiserver] object ApiPackageManagementService {
readBackend: IndexPackagesService,
transactionsService: IndexTransactionsService,
writeBackend: WritePackagesService,
timeProvider: TimeProvider)(implicit mat: Materializer, loggingContext: LoggingContext)
)(implicit mat: Materializer, loggingContext: LoggingContext)
: PackageManagementServiceGrpc.PackageManagementService with GrpcApiService =
new ApiPackageManagementService(
readBackend,
transactionsService,
writeBackend,
timeProvider,
mat,
mat.system.scheduler)
new ApiPackageManagementService(readBackend, transactionsService, writeBackend, mat)
}

16
ledger/participant-integration-api/src/main/scala/platform/apiserver/services/admin/ApiPartyManagementService.scala
View File

@ -5,7 +5,6 @@ package com.daml.platform.apiserver.services.admin
import java.util.UUID
import akka.actor.Scheduler
import akka.stream.Materializer
import akka.stream.scaladsl.Sink
import com.daml.ledger.participant.state.index.v2.{
@ -16,7 +15,6 @@ import com.daml.ledger.participant.state.v1
import com.daml.ledger.participant.state.v1.{SubmissionId, SubmissionResult, WritePartyService}
import com.daml.lf.data.Ref
import com.daml.dec.{DirectExecutionContext => DE}
import com.daml.grpc.adapter.ExecutionSequencerFactory
import com.daml.ledger.api.domain
import com.daml.ledger.api.domain.PartyEntry.{AllocationAccepted, AllocationRejected}
import com.daml.ledger.api.domain.{LedgerOffset, PartyEntry}
@ -29,14 +27,13 @@ import io.grpc.ServerServiceDefinition
import scala.compat.java8.FutureConverters
import scala.concurrent.duration.DurationInt
import scala.concurrent.{ExecutionContext, Future}
import scala.concurrent.Future
private[apiserver] final class ApiPartyManagementService private (
partyManagementService: IndexPartyManagementService,
transactionService: IndexTransactionsService,
writeService: WritePartyService,
materializer: Materializer,
scheduler: Scheduler,
)(implicit loggingContext: LoggingContext)
extends PartyManagementService
with GrpcApiService {
@ -137,17 +134,12 @@ private[apiserver] object ApiPartyManagementService {
partyManagementServiceBackend: IndexPartyManagementService,
transactionsService: IndexTransactionsService,
writeBackend: WritePartyService,
)(
implicit ec: ExecutionContext,
esf: ExecutionSequencerFactory,
mat: Materializer,
loggingContext: LoggingContext,
): PartyManagementServiceGrpc.PartyManagementService with GrpcApiService =
)(implicit mat: Materializer, loggingContext: LoggingContext)
: PartyManagementServiceGrpc.PartyManagementService with GrpcApiService =
new ApiPartyManagementService(
partyManagementServiceBackend,
transactionsService,
writeBackend,
mat,
mat.system.scheduler)
mat)
}

1
ledger/participant-integration-api/src/main/scala/platform/apiserver/services/tracking/TrackerImpl.scala
View File

@ -43,7 +43,6 @@ private[services] final class TrackerImpl(queue: SourceQueueWithComplete[Tracker
private def submitNewRequest(request: SubmitAndWaitRequest, promise: Promise[Completion])(
implicit ec: ExecutionContext,
loggingContext: LoggingContext,
): Future[Completion] = {
queue
.offer(

9
ledger/participant-integration-api/src/main/scala/platform/apiserver/services/transaction/ApiTransactionService.scala
View File

@ -52,13 +52,8 @@ private[apiserver] object ApiTransactionService {
private[apiserver] final class ApiTransactionService private (
transactionsService: IndexTransactionsService,
parallelism: Int = 4,
)(
implicit executionContext: ExecutionContext,
materializer: Materializer,
esf: ExecutionSequencerFactory,
loggingContext: LoggingContext,
) extends TransactionService
)(implicit executionContext: ExecutionContext, loggingContext: LoggingContext)
extends TransactionService
with ErrorFactories {
private val logger = ContextualizedLogger.get(this.getClass)

4
ledger/participant-integration-api/src/main/scala/platform/index/LedgerBackedIndexService.scala
View File

@ -6,7 +6,6 @@ package com.daml.platform.index
import java.time.Instant
import akka.NotUsed
import akka.stream.Materializer
import akka.stream.scaladsl.Source
import com.daml.ledger.participant.state.index.v2._
import com.daml.ledger.participant.state.v1.{Configuration, Offset, ParticipantId}
@ -53,8 +52,7 @@ import scala.concurrent.Future
private[platform] final class LedgerBackedIndexService(
ledger: ReadOnlyLedger,
participantId: ParticipantId,
)(implicit mat: Materializer)
extends IndexService {
) extends IndexService {
override def getLedgerId()(implicit loggingContext: LoggingContext): Future[LedgerId] =
Future.successful(ledger.ledgerId)

2
ledger/participant-integration-api/src/main/scala/platform/index/ReadOnlySqlLedger.scala
View File

@ -69,7 +69,7 @@ private[platform] object ReadOnlySqlLedger {
val retryDelay = 5.seconds
val maxAttempts = 100
RetryStrategy.constant(attempts = Some(maxAttempts), waitTime = retryDelay)(predicate) {
(attempt, _wait) =>
(attempt, _) =>
ledgerDao
.lookupLedgerId()
.flatMap {

2
ledger/participant-integration-api/src/main/scala/platform/index/TransactionConversion.scala
View File

@ -105,7 +105,6 @@ private[platform] object TransactionConversion {
}
private def disclosureForParties(
transactionId: TransactionId,
transaction: Transaction,
parties: Set[Ref.Party],
): Option[Relation[NodeId, Ref.Party]] =
@ -201,7 +200,6 @@ private[platform] object TransactionConversion {
val filteredTree =
for {
disclosure <- disclosureForParties(
entry.transactionId,
entry.transaction,
requestingParties,
)

3
ledger/participant-integration-api/src/main/scala/platform/store/dao/DbDispatcher.scala
View File

@ -24,8 +24,7 @@ private[platform] final class DbDispatcher private (
executor: Executor,
overallWaitTimer: Timer,
overallExecutionTimer: Timer,
)(implicit loggingContext: LoggingContext)
extends ReportsHealth {
) extends ReportsHealth {
private val logger = ContextualizedLogger.get(this.getClass)

2
ledger/participant-integration-api/src/main/scala/platform/store/dao/HikariJdbcConnectionProvider.scala
View File

@ -99,8 +99,6 @@ private[platform] object HikariConnection {
private[platform] class HikariJdbcConnectionProvider(
dataSource: HikariDataSource,
healthPoller: Timer,
)(
implicit loggingContext: LoggingContext
) extends JdbcConnectionProvider {
private val transientFailureCount = new AtomicInteger(0)

5
ledger/participant-integration-api/src/main/scala/platform/store/dao/events/ContractsTable.scala
View File

@ -50,13 +50,12 @@ private[events] sealed abstract class ContractsTable extends PostCommitValidatio
transientContracts.contains(contractId)
private def prepareRawNonEmpty(
query: String,
contractIdToParameters: Map[ContractId, PartialParameters],
): Option[(Set[ContractId], RawBatch)] = {
if (contractIdToParameters.nonEmpty) {
val contractIds = contractIdToParameters.keySet
val parameters = contractIdToParameters.valuesIterator.toVector
val batch = new RawBatch(query, parameters)
val batch = new RawBatch(parameters)
Some(contractIds -> batch)
} else {
None
@ -79,7 +78,7 @@ private[events] sealed abstract class ContractsTable extends PostCommitValidatio
def prepare: RawBatches =
new RawBatches(
insertions = prepareRawNonEmpty(insertContractQuery, insertions),
insertions = prepareRawNonEmpty(insertions),
deletions = prepareNonEmpty(deleteContractQuery, deletions),
transientContracts = transientContracts,
)

2
ledger/participant-integration-api/src/main/scala/platform/store/dao/events/EventsTableFlatEvents.scala
View File

@ -123,7 +123,6 @@ private[events] trait EventsTableFlatEvents { this: EventsTable =>
private def getFlatTransactionsQueries(sqlFunctions: SqlFunctions) =
new EventsTableFlatEventsRangeQueries.GetTransactions(
selectColumns = selectColumns,
groupByColumns = groupByColumns,
sqlFunctions = sqlFunctions,
)
@ -141,7 +140,6 @@ private[events] trait EventsTableFlatEvents { this: EventsTable =>
private def getActiveContractsQueries(sqlFunctions: SqlFunctions) =
new EventsTableFlatEventsRangeQueries.GetActiveContracts(
selectColumns = selectColumns,
groupByColumns = groupByColumns,
sqlFunctions = sqlFunctions
)

2
ledger/participant-integration-api/src/main/scala/platform/store/dao/events/EventsTableFlatEventsRangeQueries.scala
View File

@ -137,7 +137,6 @@ private[events] object EventsTableFlatEventsRangeQueries {
final class GetTransactions(
selectColumns: String,
groupByColumns: String,
sqlFunctions: SqlFunctions,
) extends EventsTableFlatEventsRangeQueries[EventsRange[Long]] {
@ -283,7 +282,6 @@ private[events] object EventsTableFlatEventsRangeQueries {
final class GetActiveContracts(
selectColumns: String,
groupByColumns: String,
sqlFunctions: SqlFunctions,
) extends EventsTableFlatEventsRangeQueries[EventsRange[(Offset, Long)]] {

5
ledger/participant-integration-api/src/main/scala/platform/store/dao/events/EventsTableInsert.scala
View File

@ -112,10 +112,9 @@ private[events] trait EventsTableInsert { this: EventsTable =>
copy(archives = archives :+ archive)
private def prepareRawNonEmpty(
query: String,
params: Vector[RawBatch.Event[_]],
): Option[RawBatch] =
if (params.nonEmpty) Some(new RawBatch(query, params)) else None
if (params.nonEmpty) Some(new RawBatch(params)) else None
private def prepareNonEmpty(
query: String,
@ -125,7 +124,7 @@ private[events] trait EventsTableInsert { this: EventsTable =>
def prepare: RawBatches =
new RawBatches(
prepareRawNonEmpty(insertEvent, events),
prepareRawNonEmpty(events),
prepareNonEmpty(updateArchived, archives),
)

3
ledger/participant-integration-api/src/main/scala/platform/store/dao/events/PostCommitValidation.scala
View File

@ -179,8 +179,7 @@ private[dao] object PostCommitValidation {
}
// `causalMonotonicity` already reports unknown contracts, no need to check it here
def removeKeyIfDefined(maybeKey: Option[Key])(
implicit connection: Connection): Right[RejectionReason, State] =
def removeKeyIfDefined(maybeKey: Option[Key]): Right[RejectionReason, State] =
Right(maybeKey.fold(this)(remove))
def validateLookupByKey(key: Key, expectation: Option[ContractId])(

2
ledger/participant-integration-api/src/main/scala/platform/store/dao/events/RawBatch.scala
View File

@ -13,7 +13,7 @@ import com.daml.ledger.{ApplicationId, CommandId, TransactionId, WorkflowId}
import com.daml.platform.store.Conversions._
import com.daml.platform.store.dao.events.RawBatch.PartialParameters
private[events] final class RawBatch(query: String, parameters: Vector[PartialParameters]) {
private[events] final class RawBatch(parameters: Vector[PartialParameters]) {
def applySerialization(
lfValueTranslation: LfValueTranslation,
): Vector[Vector[NamedParameter]] =

2
ledger/participant-integration-api/src/test/lib/scala/platform/store/dao/JdbcLedgerDaoTransactionsSpec.scala
View File

@ -575,7 +575,7 @@ private[dao] trait JdbcLedgerDaoTransactionsSpec extends OptionValues with Insid
private def createLedgerDao(pageSize: Int) =
LoggingContext.newLoggingContext { implicit loggingContext =>
daoOwner(eventsPageSize = 2).acquire()
daoOwner(eventsPageSize = pageSize).acquire()
}.asFuture
// XXX SC much of this is repeated because we're more concerned here

2
ledger/participant-integration-api/src/test/suite/scala/platform/store/dao/events/PostCommitValidationSpec.scala
View File

@ -438,7 +438,7 @@ object PostCommitValidationSpec {
private def committed(
id: String,
ledgerEffectiveTime: Instant,
key: Option[Key] = None,
key: Option[Key],
): ContractFixture =
ContractFixture(
ContractId.assertFromString(id),

11
ledger/sandbox-classic/src/main/scala/platform/sandbox/SandboxServer.scala
View File

@ -106,9 +106,7 @@ object SandboxServer {
def port(implicit executionContext: ExecutionContext): Future[Port] =
apiServer.map(_.port)
private[SandboxServer] def apiServer(
implicit executionContext: ExecutionContext
): Future[ApiServer] =
private[SandboxServer] def apiServer: Future[ApiServer] =
apiServerResource.asFuture
private[SandboxServer] def reset(
@ -126,7 +124,7 @@ object SandboxServer {
_ <- replacementApiServer.asFuture
} yield new SandboxState(materializer, metrics, packageStore, replacementApiServer)
def release()(implicit executionContext: ExecutionContext): Future[Unit] =
def release(): Future[Unit] =
apiServerResource.release()
}
@ -233,8 +231,6 @@ final class SandboxServer(
implicit val actorSystem: ActorSystem = materializer.system
implicit val executionContext: ExecutionContext = materializer.executionContext
val defaultConfiguration = config.ledgerConfig.initialConfiguration
val (acs, ledgerEntries, mbLedgerTime) = createInitialState(config, packageStore)
val timeProviderType = config.timeProviderType.getOrElse(SandboxConfig.DefaultTimeProviderType)
@ -264,9 +260,7 @@ final class SandboxServer(
config.ledgerIdMode,
config.participantId,
jdbcUrl,
defaultConfiguration,
timeProvider,
acs,
ledgerEntries,
startMode,
config.commandConfig.maxParallelSubmissions,
@ -282,7 +276,6 @@ final class SandboxServer(
name,
config.ledgerIdMode,
config.participantId,
defaultConfiguration,
timeProvider,
acs,
ledgerEntries,

10
ledger/sandbox-classic/src/main/scala/platform/sandbox/stores/SandboxIndexAndWriteService.scala
View File

@ -58,9 +58,7 @@ object SandboxIndexAndWriteService {
initialLedgerId: LedgerIdMode,
participantId: ParticipantId,
jdbcUrl: String,
initialConfig: ParticipantState.Configuration,
timeProvider: TimeProvider,
acs: InMemoryActiveLedgerState,
ledgerEntries: ImmArray[LedgerEntryOrBump],
startMode: SqlStartMode,
queueDepth: Int,
@ -80,7 +78,6 @@ object SandboxIndexAndWriteService {
initialLedgerId = initialLedgerId,
participantId = participantId,
timeProvider = timeProvider,
acs = acs,
packages = templateStore,
initialLedgerEntries = ledgerEntries,
queueDepth = queueDepth,
@ -89,14 +86,12 @@ object SandboxIndexAndWriteService {
eventsPageSize = eventsPageSize,
metrics = metrics,
lfValueTranslationCache
).flatMap(ledger =>
owner(MeteredLedger(ledger, metrics), participantId, initialConfig, timeProvider))
).flatMap(ledger => owner(MeteredLedger(ledger, metrics), participantId, timeProvider))
def inMemory(
name: LedgerName,
initialLedgerId: LedgerIdMode,
participantId: ParticipantId,
intialConfig: ParticipantState.Configuration,
timeProvider: TimeProvider,
acs: InMemoryActiveLedgerState,
ledgerEntries: ImmArray[LedgerEntryOrBump],
@ -117,13 +112,12 @@ object SandboxIndexAndWriteService {
templateStore,
ledgerEntries,
)
owner(MeteredLedger(ledger, metrics), participantId, intialConfig, timeProvider)
owner(MeteredLedger(ledger, metrics), participantId, timeProvider)
}
private def owner(
ledger: Ledger,
participantId: ParticipantId,
initialConfig: Configuration,
timeProvider: TimeProvider,
)(
implicit mat: Materializer,

13
ledger/sandbox-classic/src/main/scala/platform/sandbox/stores/ledger/ScenarioLoader.scala
View File

@ -14,14 +14,12 @@ import com.daml.platform.packages.InMemoryPackageStore
import com.daml.platform.sandbox.SandboxServer
import com.daml.platform.sandbox.stores.InMemoryActiveLedgerState
import com.daml.platform.store.entries.LedgerEntry
import org.slf4j.LoggerFactory
import scala.annotation.tailrec
import scala.collection.breakOut
import scala.collection.mutable.ArrayBuffer
object ScenarioLoader {
private val logger = LoggerFactory.getLogger(this.getClass)
/** When loading from the scenario, we also specify by how much to bump the
* ledger end after each entry. This is because in the scenario transaction
@ -57,7 +55,7 @@ object ScenarioLoader {
scenario: String,
transactionSeed: crypto.Hash,
): (InMemoryActiveLedgerState, ImmArray[LedgerEntryOrBump], Instant) = {
val (scenarioLedger, scenarioRef) =
val (scenarioLedger, _) =
buildScenarioLedger(packages, compiledPackages, scenario, transactionSeed)
// we store the tx id since later we need to recover how much to bump the
// ledger end by, and here the transaction id _is_ the ledger end.
@ -65,11 +63,11 @@ object ScenarioLoader {
new ArrayBuffer[(ScenarioLedger.TransactionId, LedgerEntry)](
scenarioLedger.scenarioSteps.size)
type Acc = (InMemoryActiveLedgerState, Time.Timestamp, Option[ScenarioLedger.TransactionId])
val (acs, time, txId) =
val (acs, time, _) =
scenarioLedger.scenarioSteps.iterator
.foldLeft[Acc]((InMemoryActiveLedgerState.empty, Time.Timestamp.Epoch, None)) {
case ((acs, time, mbOldTxId), (stepId @ _, step)) =>
executeScenarioStep(ledgerEntries, scenarioRef, acs, time, mbOldTxId, stepId, step)
executeScenarioStep(ledgerEntries, acs, time, mbOldTxId, stepId, step)
}
// now decorate the entries with what the next increment is
@tailrec
@ -87,7 +85,7 @@ object ScenarioLoader {
toProcess match {
case ImmArray() => processed.toImmArray
// we have to bump the offsets when the first one is not zero (passTimes),
case ImmArrayCons((entryTxId, entry), entries @ ImmArrayCons((nextTxId, next), _))
case ImmArrayCons((entryTxId, entry), entries @ ImmArrayCons((nextTxId, _), _))
if (processed.isEmpty && entryTxId.index > 0) =>
val newProcessed = (processed :++ ImmArray(
LedgerEntryOrBump.Bump(entryTxId.index),
@ -99,7 +97,7 @@ object ScenarioLoader {
case ImmArrayCons((_, entry), ImmArray()) =>
(processed :+ LedgerEntryOrBump.Entry(entry)).toImmArray
case ImmArrayCons((entryTxId, entry), entries @ ImmArrayCons((nextTxId, next), _)) =>
case ImmArrayCons((entryTxId, entry), entries @ ImmArrayCons((nextTxId, _), _)) =>
val newProcessed = processed :+ LedgerEntryOrBump.Entry(entry) :++ bumps(
entryTxId,
nextTxId)
@ -182,7 +180,6 @@ object ScenarioLoader {
private def executeScenarioStep(
ledger: ArrayBuffer[(ScenarioLedger.TransactionId, LedgerEntry)],
scenarioRef: Ref.DefinitionRef,
acs: InMemoryActiveLedgerState,
time: Time.Timestamp,
mbOldTxId: Option[ScenarioLedger.TransactionId],

4
ledger/sandbox-classic/src/main/scala/platform/sandbox/stores/ledger/inmemory/InMemoryLedger.scala
View File

@ -299,9 +299,7 @@ class InMemoryLedger(
)
// Validates the given ledger time according to the ledger time model
private def checkTimeModel(ledgerTime: Instant, recordTime: Instant)(
implicit loggingContext: LoggingContext,
): Either[String, Unit] = {
private def checkTimeModel(ledgerTime: Instant, recordTime: Instant): Either[String, Unit] = {
ledgerConfiguration
.fold[Either[String, Unit]](
Left("No ledger configuration available, cannot validate ledger time")

11
ledger/sandbox-classic/src/main/scala/platform/sandbox/stores/ledger/sql/SqlLedger.scala
View File

@ -29,7 +29,6 @@ import com.daml.platform.configuration.ServerRole
import com.daml.platform.packages.InMemoryPackageStore
import com.daml.platform.sandbox.LedgerIdGenerator
import com.daml.platform.sandbox.config.LedgerName
import com.daml.platform.sandbox.stores.InMemoryActiveLedgerState
import com.daml.platform.sandbox.stores.ledger.ScenarioLoader.LedgerEntryOrBump
import com.daml.platform.sandbox.stores.ledger.sql.SqlLedger._
import com.daml.platform.sandbox.stores.ledger.{Ledger, SandboxOffset}
@ -57,7 +56,6 @@ object SqlLedger {
initialLedgerId: LedgerIdMode,
participantId: ParticipantId,
timeProvider: TimeProvider,
acs: InMemoryActiveLedgerState,
packages: InMemoryPackageStore,
initialLedgerEntries: ImmArray[LedgerEntryOrBump],
queueDepth: Int,
@ -132,9 +130,7 @@ object SqlLedger {
initialLedgerEntries,
timeProvider,
packages,
acs,
ledgerDao,
participantId,
)
} yield ()
} else {
@ -164,9 +160,7 @@ object SqlLedger {
initialLedgerEntries: ImmArray[LedgerEntryOrBump],
timeProvider: TimeProvider,
packages: InMemoryPackageStore,
acs: InMemoryActiveLedgerState,
ledgerDao: LedgerDao,
participantId: ParticipantId,
)(implicit executionContext: ExecutionContext): Future[Unit] = {
if (initialLedgerEntries.nonEmpty) {
logger.info(s"Initializing ledger with ${initialLedgerEntries.length} ledger entries.")
@ -250,7 +244,6 @@ object SqlLedger {
ledgerDao,
dispatcher,
timeProvider,
packages,
persistenceQueue,
transactionCommitter,
))
@ -315,11 +308,9 @@ private final class SqlLedger(
ledgerDao: LedgerDao,
dispatcher: Dispatcher[Offset],
timeProvider: TimeProvider,
packages: InMemoryPackageStore,
persistenceQueue: PersistenceQueue,
transactionCommitter: TransactionCommitter,
)(implicit mat: Materializer, loggingContext: LoggingContext)
extends BaseLedger(ledgerId, ledgerDao, dispatcher)
) extends BaseLedger(ledgerId, ledgerDao, dispatcher)
with Ledger {
private val logger = ContextualizedLogger.get(this.getClass)

1
ledger/sandbox-classic/src/test/lib/scala/platform/sandbox/LedgerResource.scala
View File

@ -72,7 +72,6 @@ object LedgerResource {
initialLedgerId = LedgerIdMode.Static(ledgerId),
participantId = participantId,
timeProvider = timeProvider,
acs = InMemoryActiveLedgerState.empty,
packages = packages,
initialLedgerEntries = ImmArray.empty,
queueDepth = 128,

5
ledger/sandbox-classic/src/test/lib/scala/platform/sandbox/services/reset/ResetServiceDatabaseIT.scala
View File

@ -108,14 +108,13 @@ object ResetServiceDatabaseIT {
.as(str("table_name").*)(connection)
}
private def countRows(tableName: String)(_noDialectDifference: DbType)(
connection: Connection): Int =
private def countRows(tableName: String)(connection: Connection): Int =
SQL(s"select count(*) as no_rows from $tableName").as(int("no_rows").single)(connection)
private def countRowsOfAllTables(ignored: Set[String])(dbType: DbType)(
connection: Connection): Map[String, Int] =
listTables(dbType)(connection).collect {
case table if !ignored(table) => table.toLowerCase -> countRows(table)(dbType)(connection)
case table if !ignored(table) => table.toLowerCase -> countRows(table)(connection)
}.toMap
def countRowsOfAllTables(ignored: Set[String], dbInfoOwner: ResourceOwner[DbInfo])(

4
ledger/sandbox-classic/src/test/suite/scala/platform/sandbox/TlsIT.scala
View File

@ -18,8 +18,6 @@ import com.daml.platform.sandbox.config.SandboxConfig
import com.daml.platform.sandbox.services.SandboxFixture
import org.scalatest.AsyncWordSpec
import scala.language.implicitConversions
class TlsIT extends AsyncWordSpec with SandboxFixture with SuiteResourceManagementAroundAll {
private val List(
@ -33,8 +31,6 @@ class TlsIT extends AsyncWordSpec with SandboxFixture with SuiteResourceManageme
}
}
private implicit def str2File(str: String): File = new File(str)
private lazy val tlsEnabledConfig = LedgerClientConfiguration(
"appId",
LedgerIdRequirement.none,

2
ledger/sandbox-classic/src/test/suite/scala/platform/sandbox/services/command/CommandStaticTimeIT.scala
View File

@ -50,7 +50,7 @@ final class CommandStaticTimeIT
StaticTime
.updatedVia(TimeServiceGrpc.stub(channel), unwrappedLedgerId)
.recover { case NonFatal(_) => TimeProvider.UTC }(DirectExecutionContext)
.map(tp =>
.map(_ =>
new CommandClient(
CommandSubmissionServiceGrpc.stub(channel),
CommandCompletionServiceGrpc.stub(channel),

5
ledger/sandbox-classic/src/test/suite/scala/platform/sandbox/services/completion/CompletionServiceIT.scala
View File

@ -14,7 +14,6 @@ import com.daml.ledger.api.v1.command_completion_service.{
}
import com.daml.ledger.api.v1.command_service.CommandServiceGrpc
import com.daml.ledger.api.v1.commands.CreateCommand
import com.daml.ledger.api.v1.completion.Completion
import com.daml.ledger.api.v1.ledger_offset.LedgerOffset
import com.daml.ledger.api.v1.value.{Record, RecordField, Value}
import com.daml.platform.participant.util.ValueConversions._
@ -22,7 +21,6 @@ import com.daml.platform.sandbox.SandboxBackend
import com.daml.platform.sandbox.config.SandboxConfig
import com.daml.platform.sandbox.services.{SandboxFixture, TestCommands}
import com.daml.platform.testing.StreamConsumer
import com.google.rpc.status.Status
import org.scalatest.{AsyncWordSpec, Inspectors, Matchers}
import scalaz.syntax.tag._
@ -104,9 +102,6 @@ class CompletionServiceIT
).within(completionTimeout)
.map(_.flatMap(_.completions).map(_.commandId))
private[this] def ok(commandId: String) =
Completion(commandId, Some(Status(0)))
"CommandCompletionService" should {
"return correct completions" in {
val partyA = "partyA"

6
ledger/sandbox-classic/src/test/suite/scala/platform/sandbox/stores/ledger/TransactionTimeModelComplianceIT.scala
View File

@ -35,7 +35,6 @@ import org.scalatest.{Assertion, AsyncWordSpec, Matchers, OptionValues}
import scala.concurrent.ExecutionContext
import scala.concurrent.duration._
import scala.language.implicitConversions
class TransactionTimeModelComplianceIT
extends AsyncWordSpec
@ -208,11 +207,6 @@ object TransactionTimeModelComplianceIT {
private val participantId: ParticipantId = Ref.ParticipantId.assertFromString("participantId")
private val timeProvider = TimeProvider.Constant(recordTime)
private implicit def toParty(s: String): Ref.Party = Ref.Party.assertFromString(s)
private implicit def toLedgerString(s: String): Ref.LedgerString =
Ref.LedgerString.assertFromString(s)
sealed abstract class BackendType
object BackendType {

2
ledger/sandbox-classic/src/test/suite/scala/platform/sandbox/stores/ledger/sql/SqlLedgerSpec.scala
View File

@ -23,7 +23,6 @@ import com.daml.platform.configuration.ServerRole
import com.daml.platform.packages.InMemoryPackageStore
import com.daml.platform.sandbox.MetricsAround
import com.daml.platform.sandbox.config.LedgerName
import com.daml.platform.sandbox.stores.InMemoryActiveLedgerState
import com.daml.platform.sandbox.stores.ledger.Ledger
import com.daml.platform.sandbox.stores.ledger.sql.SqlLedgerSpec._
import com.daml.platform.store.dao.events.LfValueTranslation
@ -185,7 +184,6 @@ class SqlLedgerSpec
initialLedgerId = ledgerId.fold[LedgerIdMode](LedgerIdMode.Dynamic)(LedgerIdMode.Static),
participantId = participantId,
timeProvider = TimeProvider.UTC,
acs = InMemoryActiveLedgerState.empty,
packages = InMemoryPackageStore.empty
.withPackages(Instant.EPOCH, None, packages)
.fold(sys.error, identity),

4
ledger/sandbox-classic/src/test/suite/scala/platform/sandbox/stores/ledger/sql/TransactionStreamTerminationIT.scala
View File

@ -55,7 +55,7 @@ class TransactionStreamTerminationIT
private def newTransactionClient(ledgerId: domain.LedgerId) =
new TransactionClient(ledgerId, TransactionServiceGrpc.stub(channel))
private def newPartyManagement(ledgerId: domain.LedgerId) =
private def newPartyManagement() =
new PartyManagementClient(PartyManagementServiceGrpc.stub(channel))
private def newCommandSubmissionClient(ledgerId: domain.LedgerId) =
@ -92,7 +92,7 @@ class TransactionStreamTerminationIT
val commandClient = newCommandSubmissionClient(actualLedgerId)
val txClient = newTransactionClient(actualLedgerId)
val partyManagementClient = newPartyManagement(actualLedgerId)
val partyManagementClient = newPartyManagement()
def getLedgerEnd = txClient.getLedgerEnd().map(_.getOffset.value.absolute.get.toLong)
for {

1
ledger/sandbox-common/BUILD.bazel
View File

@ -72,6 +72,7 @@ da_scala_library(
":sandbox-common",
"//bazel_tools/runfiles:scala_runfiles",
"//daml-lf/archive:daml_lf_archive_reader",
"//daml-lf/archive:daml_lf_dev_archive_java_proto",
"//daml-lf/data",
"//language-support/scala/bindings",
"//ledger-api/rs-grpc-bridge",

10
ledger/sandbox-common/src/test/lib/scala/platform/sandbox/services/TestCommands.scala
View File

@ -23,6 +23,8 @@ import scalaz.syntax.tag._
trait TestCommands {
import TestCommands.SubmitRequestEnhancer
protected def darFile: File
protected def packageId: PackageId = DarReader().readArchiveFromFile(darFile).get.main._1
@ -129,7 +131,13 @@ trait TestCommands {
): Command =
Command(Exercise(ExerciseCommand(Some(templateId), contractId, choice, args)))
implicit class SubmitRequestEnhancer(request: SubmitRequest) {
import language.implicitConversions
implicit def SubmitRequestEnhancer(request: SubmitRequest): SubmitRequestEnhancer =
new SubmitRequestEnhancer(request)
}
object TestCommands {
implicit final class SubmitRequestEnhancer(private val request: SubmitRequest) extends AnyVal {
def toSync: SubmitAndWaitRequest = SubmitAndWaitRequest(request.commands)
}
}