From 509d5ffce0120df41701303ff185152be58c697f Mon Sep 17 00:00:00 2001 From: James Agnew Date: Wed, 12 Feb 2025 10:54:38 -0500 Subject: [PATCH] Add support for Database Partition Mode --- pom.xml | 2 +- .../uhn/fhir/jpa/starter/AppProperties.java | 38 ++++++++- .../ModuleConfigurationPrefetchSvc.java | 6 +- .../common/FhirServerConfigCommon.java | 23 ++++- .../common/PartitionModeConfigurer.java | 53 ++++++++++++ .../jpa/starter/common/StarterJpaConfig.java | 52 +++++++----- .../jpa/starter/ExampleServerDbpmR5IT.java | 84 +++++++++++++++++++ src/test/resources/application.yaml | 19 ++++- 8 files changed, 248 insertions(+), 29 deletions(-) create mode 100644 src/main/java/ca/uhn/fhir/jpa/starter/common/PartitionModeConfigurer.java create mode 100644 src/test/java/ca/uhn/fhir/jpa/starter/ExampleServerDbpmR5IT.java diff --git a/pom.xml b/pom.xml index 0cd2dab..f22ce9b 100644 --- a/pom.xml +++ b/pom.xml @@ -14,7 +14,7 @@ ca.uhn.hapi.fhir hapi-fhir - 7.7.16-SNAPSHOT + 7.7.18-SNAPSHOT hapi-fhir-jpaserver-starter diff --git a/src/main/java/ca/uhn/fhir/jpa/starter/AppProperties.java b/src/main/java/ca/uhn/fhir/jpa/starter/AppProperties.java index 67d751c..dc9ab23 100644 --- a/src/main/java/ca/uhn/fhir/jpa/starter/AppProperties.java +++ b/src/main/java/ca/uhn/fhir/jpa/starter/AppProperties.java @@ -175,11 +175,11 @@ public class AppProperties { this.cr_enabled = cr_enabled; } - public Boolean getIps_enabled() { + public Boolean getIps_enabled() { return ips_enabled; } - public void setIps_enabled(Boolean ips_enabled) { + public void setIps_enabled(Boolean ips_enabled) { this.ips_enabled = ips_enabled; } @@ -810,8 +810,36 @@ public Cors getCors() { private Boolean partitioning_include_in_search_hashes = false; private Boolean allow_references_across_partitions = false; private Boolean conditional_create_duplicate_identifiers_enabled = false; + private Boolean database_partition_mode_enabled = false; + private Boolean patient_id_partitioning_mode = false; + private Integer default_partition_id = 0; + private boolean request_tenant_partitioning_mode; - public Boolean getPartitioning_include_in_search_hashes() { + public Integer getDefault_partition_id() { + return default_partition_id; + } + + public void setDefault_partition_id(Integer theDefault_partition_id) { + default_partition_id = theDefault_partition_id; + } + + public Boolean getDatabase_partition_mode_enabled() { + return database_partition_mode_enabled; + } + + public void setDatabase_partition_mode_enabled(Boolean theDatabase_partition_mode_enabled) { + database_partition_mode_enabled = theDatabase_partition_mode_enabled; + } + + public Boolean getPatient_id_partitioning_mode() { + return patient_id_partitioning_mode; + } + + public void setPatient_id_partitioning_mode(Boolean thePatient_id_partitioning_mode) { + patient_id_partitioning_mode = thePatient_id_partitioning_mode; + } + + public Boolean getPartitioning_include_in_search_hashes() { return partitioning_include_in_search_hashes; } @@ -833,6 +861,10 @@ public Cors getCors() { public void setConditional_create_duplicate_identifiers_enabled(Boolean conditional_create_duplicate_identifiers_enabled) { this.conditional_create_duplicate_identifiers_enabled = conditional_create_duplicate_identifiers_enabled; } + + public boolean getRequest_tenant_partitioning_mode() { + return request_tenant_partitioning_mode; + } } public static class Subscription { diff --git a/src/main/java/ca/uhn/fhir/jpa/starter/cdshooks/ModuleConfigurationPrefetchSvc.java b/src/main/java/ca/uhn/fhir/jpa/starter/cdshooks/ModuleConfigurationPrefetchSvc.java index 0ffaaa7..bd927dd 100644 --- a/src/main/java/ca/uhn/fhir/jpa/starter/cdshooks/ModuleConfigurationPrefetchSvc.java +++ b/src/main/java/ca/uhn/fhir/jpa/starter/cdshooks/ModuleConfigurationPrefetchSvc.java @@ -2,6 +2,7 @@ package ca.uhn.fhir.jpa.starter.cdshooks; import ca.uhn.fhir.context.FhirContext; import ca.uhn.fhir.i18n.Msg; +import ca.uhn.fhir.interceptor.api.IInterceptorBroadcaster; import ca.uhn.fhir.rest.client.api.IClientInterceptor; import ca.uhn.fhir.rest.client.api.IGenericClient; import ca.uhn.fhir.rest.client.interceptor.BearerTokenAuthInterceptor; @@ -53,8 +54,9 @@ public class ModuleConfigurationPrefetchSvc extends CdsPrefetchSvc { public ModuleConfigurationPrefetchSvc(CdsResolutionStrategySvc theCdsResolutionStrategySvc, CdsPrefetchDaoSvc theResourcePrefetchDao, CdsPrefetchFhirClientSvc theResourcePrefetchFhirClient, - ICdsHooksDaoAuthorizationSvc theCdsHooksDaoAuthorizationSvc) { - super(theCdsResolutionStrategySvc, theResourcePrefetchDao, theResourcePrefetchFhirClient, theCdsHooksDaoAuthorizationSvc); + ICdsHooksDaoAuthorizationSvc theCdsHooksDaoAuthorizationSvc, + IInterceptorBroadcaster theInterceptorBroadcaster) { + super(theCdsResolutionStrategySvc, theResourcePrefetchDao, theResourcePrefetchFhirClient, theCdsHooksDaoAuthorizationSvc, theInterceptorBroadcaster); myResourcePrefetchFhirClient = theResourcePrefetchFhirClient; fhirContext = theResourcePrefetchDao.getFhirContext(); } diff --git a/src/main/java/ca/uhn/fhir/jpa/starter/common/FhirServerConfigCommon.java b/src/main/java/ca/uhn/fhir/jpa/starter/common/FhirServerConfigCommon.java index 3c3941b..ed53b9e 100644 --- a/src/main/java/ca/uhn/fhir/jpa/starter/common/FhirServerConfigCommon.java +++ b/src/main/java/ca/uhn/fhir/jpa/starter/common/FhirServerConfigCommon.java @@ -1,13 +1,17 @@ package ca.uhn.fhir.jpa.starter.common; +import ca.uhn.fhir.context.FhirContext; +import ca.uhn.fhir.interceptor.api.IInterceptorService; import ca.uhn.fhir.jpa.api.config.JpaStorageSettings; import ca.uhn.fhir.jpa.binary.api.IBinaryStorageSvc; import ca.uhn.fhir.jpa.binstore.DatabaseBinaryContentStorageSvcImpl; import ca.uhn.fhir.jpa.config.HibernatePropertiesProvider; +import ca.uhn.fhir.jpa.interceptor.PatientIdPartitionInterceptor; import ca.uhn.fhir.jpa.model.config.PartitionSettings; import ca.uhn.fhir.jpa.model.config.PartitionSettings.CrossPartitionReferenceMode; import ca.uhn.fhir.jpa.model.config.SubscriptionSettings; import ca.uhn.fhir.jpa.model.entity.StorageSettings; +import ca.uhn.fhir.jpa.searchparam.extractor.ISearchParamExtractor; import ca.uhn.fhir.jpa.starter.AppProperties; import ca.uhn.fhir.jpa.starter.util.JpaHibernatePropertiesProvider; import ca.uhn.fhir.jpa.subscription.match.deliver.email.EmailSenderImpl; @@ -27,6 +31,8 @@ import org.springframework.transaction.annotation.EnableTransactionManagement; import java.util.HashSet; import java.util.stream.Collectors; +import static org.apache.commons.lang3.ObjectUtils.defaultIfNull; + /** * This is the primary configuration file for the example server */ @@ -171,7 +177,7 @@ public class FhirServerConfigCommon { jpaStorageSettings.setFilterParameterEnabled(appProperties.getFilter_search_enabled()); - jpaStorageSettings.setAdvancedHSearchIndexing(appProperties.getAdvanced_lucene_indexing()); + jpaStorageSettings.setHibernateSearchIndexSearchParams(appProperties.getAdvanced_lucene_indexing()); jpaStorageSettings.setTreatBaseUrlsAsLocal(new HashSet<>(appProperties.getLocal_base_urls())); jpaStorageSettings.setTreatReferencesAsLogical(new HashSet<>(appProperties.getLogical_urls())); @@ -233,6 +239,7 @@ public class FhirServerConfigCommon { return new YamlPropertySourceLoader(); } + @Bean public PartitionSettings partitionSettings(AppProperties appProperties) { PartitionSettings retVal = new PartitionSettings(); @@ -240,6 +247,13 @@ public class FhirServerConfigCommon { // Partitioning if (appProperties.getPartitioning() != null) { retVal.setPartitioningEnabled(true); + boolean databasePartitionModeEnabled = defaultIfNull(appProperties.getPartitioning().getDatabase_partition_mode_enabled(), Boolean.FALSE); + Integer defaultPartitionId = appProperties.getPartitioning().getDefault_partition_id(); + if (databasePartitionModeEnabled) { + retVal.setDatabasePartitionMode(true); + defaultPartitionId = defaultIfNull(defaultPartitionId, 0); + } + retVal.setDefaultPartitionId(defaultPartitionId); retVal.setIncludePartitionInSearchHashes( appProperties.getPartitioning().getPartitioning_include_in_search_hashes()); if (appProperties.getPartitioning().getAllow_references_across_partitions()) { @@ -251,9 +265,16 @@ public class FhirServerConfigCommon { appProperties.getPartitioning().getConditional_create_duplicate_identifiers_enabled()); } + return retVal; } + @Bean + public PartitionModeConfigurer partitionModeConfigurer() { + return new PartitionModeConfigurer(); + } + + @Primary @Bean public HibernatePropertiesProvider jpaStarterDialectProvider( diff --git a/src/main/java/ca/uhn/fhir/jpa/starter/common/PartitionModeConfigurer.java b/src/main/java/ca/uhn/fhir/jpa/starter/common/PartitionModeConfigurer.java new file mode 100644 index 0000000..3073b94 --- /dev/null +++ b/src/main/java/ca/uhn/fhir/jpa/starter/common/PartitionModeConfigurer.java @@ -0,0 +1,53 @@ +package ca.uhn.fhir.jpa.starter.common; + +import ca.uhn.fhir.context.FhirContext; +import ca.uhn.fhir.interceptor.api.IInterceptorService; +import ca.uhn.fhir.jpa.interceptor.PatientIdPartitionInterceptor; +import ca.uhn.fhir.jpa.model.config.PartitionSettings; +import ca.uhn.fhir.jpa.partition.PartitionManagementProvider; +import ca.uhn.fhir.jpa.searchparam.extractor.ISearchParamExtractor; +import ca.uhn.fhir.jpa.starter.AppProperties; +import ca.uhn.fhir.rest.server.RestfulServer; +import ca.uhn.fhir.rest.server.interceptor.partition.RequestTenantPartitionInterceptor; +import ca.uhn.fhir.rest.server.tenant.UrlBaseTenantIdentificationStrategy; +import jakarta.annotation.PostConstruct; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; + +public class PartitionModeConfigurer { + private static final Logger ourLog = LoggerFactory.getLogger(PartitionModeConfigurer.class); + + @Autowired + private AppProperties myAppProperties; + @Autowired + private FhirContext myFhirContext; + @Autowired + private ISearchParamExtractor mySearchParamExtractor; + @Autowired + private PartitionSettings myPartitionSettings; + @Autowired + private RestfulServer myRestfulServer; + @Autowired + private PartitionManagementProvider myPartitionManagementProvider; + + + @PostConstruct + public void start() { + if (myAppProperties.getPartitioning() != null) { + if (myAppProperties.getPartitioning().getPatient_id_partitioning_mode() == Boolean.TRUE) { + ourLog.info("Partitioning mode enabled in: Patient ID partitioning mode"); + PatientIdPartitionInterceptor patientIdInterceptor = new PatientIdPartitionInterceptor(myFhirContext, mySearchParamExtractor, myPartitionSettings); + myRestfulServer.registerInterceptor(patientIdInterceptor); + myPartitionSettings.setUnnamedPartitionMode(true); + } else if (myAppProperties.getPartitioning().getRequest_tenant_partitioning_mode() == Boolean.TRUE) { + ourLog.info("Partitioning mode enabled in: Request tenant partitioning mode"); + myRestfulServer.registerInterceptor(new RequestTenantPartitionInterceptor()); + myRestfulServer.setTenantIdentificationStrategy(new UrlBaseTenantIdentificationStrategy()); + } + + myRestfulServer.registerProviders(myPartitionManagementProvider); + } + } + +} diff --git a/src/main/java/ca/uhn/fhir/jpa/starter/common/StarterJpaConfig.java b/src/main/java/ca/uhn/fhir/jpa/starter/common/StarterJpaConfig.java index 5dc88f9..a03d608 100644 --- a/src/main/java/ca/uhn/fhir/jpa/starter/common/StarterJpaConfig.java +++ b/src/main/java/ca/uhn/fhir/jpa/starter/common/StarterJpaConfig.java @@ -1,12 +1,9 @@ package ca.uhn.fhir.jpa.starter.common; import ca.uhn.fhir.batch2.config.Batch2JobRegisterer; -import ca.uhn.fhir.batch2.coordinator.JobDefinitionRegistry; import ca.uhn.fhir.batch2.jobs.export.BulkDataExportProvider; import ca.uhn.fhir.batch2.jobs.imprt.BulkDataImportProvider; -import ca.uhn.fhir.batch2.jobs.reindex.ReindexJobParameters; import ca.uhn.fhir.batch2.jobs.reindex.ReindexProvider; -import ca.uhn.fhir.batch2.model.JobDefinition; import ca.uhn.fhir.context.ConfigurationException; import ca.uhn.fhir.context.FhirContext; import ca.uhn.fhir.context.FhirVersionEnum; @@ -21,7 +18,6 @@ import ca.uhn.fhir.jpa.binary.interceptor.BinaryStorageInterceptor; import ca.uhn.fhir.jpa.binary.provider.BinaryAccessProvider; import ca.uhn.fhir.jpa.config.util.HapiEntityManagerFactoryUtil; import ca.uhn.fhir.jpa.config.util.ResourceCountCacheUtil; - import ca.uhn.fhir.jpa.dao.FulltextSearchSvcImpl; import ca.uhn.fhir.jpa.dao.IFulltextSearchSvc; import ca.uhn.fhir.jpa.dao.search.HSearchSortHelperImpl; @@ -35,9 +31,14 @@ import ca.uhn.fhir.jpa.ips.provider.IpsOperationProvider; import ca.uhn.fhir.jpa.model.config.SubscriptionSettings; import ca.uhn.fhir.jpa.packages.IPackageInstallerSvc; import ca.uhn.fhir.jpa.packages.PackageInstallationSpec; -import ca.uhn.fhir.jpa.partition.PartitionManagementProvider; +import ca.uhn.fhir.jpa.provider.DaoRegistryResourceSupportedSvc; +import ca.uhn.fhir.jpa.provider.IJpaSystemProvider; +import ca.uhn.fhir.jpa.provider.JpaCapabilityStatementProvider; +import ca.uhn.fhir.jpa.provider.JpaConformanceProviderDstu2; +import ca.uhn.fhir.jpa.provider.SubscriptionTriggeringProvider; +import ca.uhn.fhir.jpa.provider.TerminologyUploaderProvider; +import ca.uhn.fhir.jpa.provider.ValueSetOperationProvider; import ca.uhn.fhir.jpa.provider.dstu3.JpaConformanceProviderDstu3; -import ca.uhn.fhir.jpa.provider.*; import ca.uhn.fhir.jpa.search.DatabaseBackedPagingProvider; import ca.uhn.fhir.jpa.search.IStaleSearchDeletingSvc; import ca.uhn.fhir.jpa.search.StaleSearchDeletingSvcImpl; @@ -49,23 +50,29 @@ import ca.uhn.fhir.jpa.starter.ig.IImplementationGuideOperationProvider; import ca.uhn.fhir.jpa.starter.util.EnvironmentHelper; import ca.uhn.fhir.jpa.subscription.util.SubscriptionDebugLogInterceptor; import ca.uhn.fhir.jpa.util.ResourceCountCache; -import ca.uhn.fhir.jpa.validation.JpaValidationSupportChain; import ca.uhn.fhir.mdm.provider.MdmProviderLoader; import ca.uhn.fhir.narrative.DefaultThymeleafNarrativeGenerator; import ca.uhn.fhir.narrative2.NullNarrativeGenerator; import ca.uhn.fhir.rest.api.IResourceSupportedSvc; import ca.uhn.fhir.rest.openapi.OpenApiInterceptor; -import ca.uhn.fhir.rest.server.interceptor.partition.RequestTenantPartitionInterceptor; -import ca.uhn.fhir.rest.server.*; -import ca.uhn.fhir.rest.server.interceptor.*; +import ca.uhn.fhir.rest.server.ApacheProxyAddressStrategy; +import ca.uhn.fhir.rest.server.ETagSupportEnum; +import ca.uhn.fhir.rest.server.HardcodedServerAddressStrategy; +import ca.uhn.fhir.rest.server.IServerConformanceProvider; +import ca.uhn.fhir.rest.server.IncomingRequestAddressStrategy; +import ca.uhn.fhir.rest.server.RestfulServer; +import ca.uhn.fhir.rest.server.interceptor.CorsInterceptor; +import ca.uhn.fhir.rest.server.interceptor.FhirPathFilterInterceptor; +import ca.uhn.fhir.rest.server.interceptor.LoggingInterceptor; +import ca.uhn.fhir.rest.server.interceptor.RequestValidatingInterceptor; +import ca.uhn.fhir.rest.server.interceptor.ResponseHighlighterInterceptor; +import ca.uhn.fhir.rest.server.interceptor.ResponseValidatingInterceptor; import ca.uhn.fhir.rest.server.provider.ResourceProviderFactory; -import ca.uhn.fhir.rest.server.tenant.UrlBaseTenantIdentificationStrategy; import ca.uhn.fhir.rest.server.util.ISearchParamRegistry; import ca.uhn.fhir.validation.IValidatorModule; import ca.uhn.fhir.validation.ResultSeverityEnum; import com.google.common.base.Strings; import jakarta.persistence.EntityManagerFactory; -import org.hl7.fhir.common.hapi.validation.support.CachingValidationSupport; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.NoSuchBeanDefinitionException; @@ -73,15 +80,24 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.context.ApplicationContext; -import org.springframework.context.annotation.*; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.Conditional; +import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Import; +import org.springframework.context.annotation.Primary; import org.springframework.core.env.ConfigurableEnvironment; import org.springframework.http.HttpHeaders; import org.springframework.orm.jpa.JpaTransactionManager; import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean; import org.springframework.web.cors.CorsConfiguration; -import java.util.*; import javax.sql.DataSource; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Optional; import static ca.uhn.fhir.jpa.starter.common.validation.IRepositoryValidationInterceptorFactory.ENABLE_REPOSITORY_VALIDATING_INTERCEPTOR; @@ -267,7 +283,6 @@ public class StarterJpaConfig { BulkDataImportProvider bulkDataImportProvider, ValueSetOperationProvider theValueSetOperationProvider, ReindexProvider reindexProvider, - PartitionManagementProvider partitionManagementProvider, Optional repositoryValidatingInterceptor, IPackageInstallerSvc packageInstallerSvc, ThreadSafeResourceDeleterSvc theThreadSafeResourceDeleterSvc, @@ -438,12 +453,7 @@ public class StarterJpaConfig { // reindex Provider $reindex fhirServer.registerProvider(reindexProvider); - // Partitioning - if (appProperties.getPartitioning() != null) { - fhirServer.registerInterceptor(new RequestTenantPartitionInterceptor()); - fhirServer.setTenantIdentificationStrategy(new UrlBaseTenantIdentificationStrategy()); - fhirServer.registerProviders(partitionManagementProvider); - } + // Validation repositoryValidatingInterceptor.ifPresent(fhirServer::registerInterceptor); // register custom interceptors diff --git a/src/test/java/ca/uhn/fhir/jpa/starter/ExampleServerDbpmR5IT.java b/src/test/java/ca/uhn/fhir/jpa/starter/ExampleServerDbpmR5IT.java new file mode 100644 index 0000000..2f6afa2 --- /dev/null +++ b/src/test/java/ca/uhn/fhir/jpa/starter/ExampleServerDbpmR5IT.java @@ -0,0 +1,84 @@ +package ca.uhn.fhir.jpa.starter; + +import ca.uhn.fhir.context.FhirContext; +import ca.uhn.fhir.jpa.migrate.DriverTypeEnum; +import ca.uhn.fhir.jpa.migrate.JdbcUtils; +import ca.uhn.fhir.rest.client.api.IGenericClient; +import ca.uhn.fhir.rest.client.api.ServerValidationModeEnum; +import ca.uhn.fhir.rest.client.interceptor.LoggingInterceptor; +import org.hl7.fhir.instance.model.api.IIdType; +import org.hl7.fhir.r5.model.Patient; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.web.server.LocalServerPort; +import org.springframework.test.context.junit.jupiter.SpringExtension; +import org.springframework.transaction.PlatformTransactionManager; +import org.springframework.transaction.support.TransactionTemplate; + +import javax.sql.DataSource; +import java.sql.SQLException; +import java.util.Set; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertTrue; + +@ExtendWith(SpringExtension.class) +@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, classes = {Application.class}, properties = + { + "spring.datasource.url=jdbc:h2:mem:dbr5_dbpm", + "hapi.fhir.fhir_version=r5", + "hapi.fhir.partitioning.database_partition_mode_enabled=true", + "hapi.fhir.partitioning.patient_id_partitioning_mode=true" + }) +public class ExampleServerDbpmR5IT { + + private static final org.slf4j.Logger ourLog = org.slf4j.LoggerFactory.getLogger(ExampleServerDstu2IT.class); + private IGenericClient ourClient; + private FhirContext ourCtx; + + + @LocalServerPort + private int port; + + @Autowired + private DataSource myDataSource; + + @Autowired + private PlatformTransactionManager myTxManager; + + + @Test + void testCreateAndRead() { + Patient pt = new Patient(); + pt.setId("A"); + pt.setActive(true); + IIdType id = ourClient.update().resource(pt).execute().getId(); + + Patient pt2 = ourClient.read().resource(Patient.class).withId("Patient/A").execute(); + assertTrue(pt2.getActive()); + } + + + @Test + public void testValidateSchema() throws SQLException { + TransactionTemplate tt = new TransactionTemplate(myTxManager); + DriverTypeEnum.ConnectionProperties cp = new DriverTypeEnum.ConnectionProperties(myDataSource, tt, DriverTypeEnum.H2_EMBEDDED); + Set columns = JdbcUtils.getPrimaryKeyColumns(cp, "HFJ_RESOURCE"); + assertThat(columns).containsExactlyInAnyOrder("RES_ID", "PARTITION_ID"); + } + + + @BeforeEach + void beforeEach() { + + ourCtx = FhirContext.forR5(); + ourCtx.getRestfulClientFactory().setServerValidationMode(ServerValidationModeEnum.NEVER); + ourCtx.getRestfulClientFactory().setSocketTimeout(1200 * 1000); + String ourServerBase = "http://localhost:" + port + "/fhir/"; + ourClient = ourCtx.newRestfulGenericClient(ourServerBase); + ourClient.registerInterceptor(new LoggingInterceptor(true)); + } +} diff --git a/src/test/resources/application.yaml b/src/test/resources/application.yaml index a494359..f57c1e2 100644 --- a/src/test/resources/application.yaml +++ b/src/test/resources/application.yaml @@ -145,10 +145,27 @@ hapi: # local_base_urls: # - https://hapi.fhir.org/baseR4 mdm_enabled: false + + ### Uncomment the following section, and any sub-properties you need in order to enable + ### partitioning support on this server. # partitioning: # allow_references_across_partitions: false # partitioning_include_in_search_hashes: false - # partitioning_include_in_search_hashes + # default_partition_id: 0 + # ### Enable the following setting to enable Database Partitioning Mode + # ### See: https://hapifhir.io/hapi-fhir/docs/server_jpa_partitioning/db_partition_mode.html + # database_partition_mode_enabled: false + # ### Partition Style: Partitioning requires a partition interceptor which helps the server + # ### select which partition(s) should be accessed for a given request. You can supply your + # ### own interceptor (see https://hapifhir.io/hapi-fhir/docs/server_jpa_partitioning/partitioning.html#partition-interceptors ) + # ### but the following setting can also be used to use a built-in form. + # ### Patient ID Partitioning Mode uses the patient/subject ID to determine the partition + # patient_id_partitioning_mode: false + # ### Request tenant mode can be used for a multi-tenancy setup where the request path is + # ### expected to have an additional path element, e.g. GET http://example.com/fhir/TENANT-ID/Patient/A + # request_tenant_partitioning_mode: false + + #cors: # allow_Credentials: true # These are allowed_origin patterns, see: https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/cors/CorsConfiguration.html#setAllowedOriginPatterns-java.util.List-