Initial commit

src/main/java/ca/uhn/fhir/jpa/demo/FhirServerConfig.java

@@ -0,0 +1,124 @@
+package ca.uhn.fhir.jpa.demo;
+
+import java.util.Properties;
+
+import javax.persistence.EntityManagerFactory;
+import javax.sql.DataSource;
+
+import ca.uhn.fhir.jpa.search.LuceneSearchMappingFactory;
+import ca.uhn.fhir.jpa.util.DerbyTenSevenHapiFhirDialect;
+import org.apache.commons.dbcp2.BasicDataSource;
+import org.apache.commons.lang3.time.DateUtils;
+import org.hibernate.jpa.HibernatePersistenceProvider;
+import org.springframework.beans.factory.annotation.Autowire;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+import ca.uhn.fhir.jpa.config.BaseJavaConfigDstu3;
+import ca.uhn.fhir.jpa.dao.DaoConfig;
+import ca.uhn.fhir.jpa.util.SubscriptionsRequireManualActivationInterceptorDstu3;
+import ca.uhn.fhir.rest.server.interceptor.IServerInterceptor;
+import ca.uhn.fhir.rest.server.interceptor.LoggingInterceptor;
+import ca.uhn.fhir.rest.server.interceptor.ResponseHighlighterInterceptor;
+
+/**
+ * This is the primary configuration file for the example server
+ */
+@Configuration
+@EnableTransactionManagement()
+public class FhirServerConfig extends BaseJavaConfigDstu3 {
+
+	/**
+	 * Configure FHIR properties around the the JPA server via this bean
+	 */
+	@Bean()
+	public DaoConfig daoConfig() {
+		DaoConfig retVal = new DaoConfig();
+		retVal.setAllowMultipleDelete(true);
+		return retVal;
+	}
+
+	/**
+	 * The following bean configures the database connection. The 'url' property value of "jdbc:derby:directory:jpaserver_derby_files;create=true" indicates that the server should save resources in a
+	 * directory called "jpaserver_derby_files".
+	 * 
+	 * A URL to a remote database could also be placed here, along with login credentials and other properties supported by BasicDataSource.
+	 */
+	@Bean(destroyMethod = "close")
+	public DataSource dataSource() {
+		BasicDataSource retVal = new BasicDataSource();
+		retVal.setDriver(new org.apache.derby.jdbc.EmbeddedDriver());
+		retVal.setUrl("jdbc:derby:directory:target/jpaserver_derby_files;create=true");
+		retVal.setUsername("");
+		retVal.setPassword("");
+		return retVal;
+	}
+
+	@Override
+	@Bean()
+	public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
+		LocalContainerEntityManagerFactoryBean retVal = super.entityManagerFactory();
+		retVal.setPersistenceUnitName("HAPI_PU");
+		retVal.setDataSource(dataSource());
+		retVal.setJpaProperties(jpaProperties());
+		return retVal;
+	}
+
+	private Properties jpaProperties() {
+		Properties extraProperties = new Properties();
+		extraProperties.put("hibernate.dialect", DerbyTenSevenHapiFhirDialect.class.getName());
+		extraProperties.put("hibernate.format_sql", "true");
+		extraProperties.put("hibernate.show_sql", "false");
+		extraProperties.put("hibernate.hbm2ddl.auto", "update");
+		extraProperties.put("hibernate.jdbc.batch_size", "20");
+		extraProperties.put("hibernate.cache.use_query_cache", "false");
+		extraProperties.put("hibernate.cache.use_second_level_cache", "false");
+		extraProperties.put("hibernate.cache.use_structured_entries", "false");
+		extraProperties.put("hibernate.cache.use_minimal_puts", "false");
+		extraProperties.put("hibernate.search.model_mapping", LuceneSearchMappingFactory.class.getName());
+		extraProperties.put("hibernate.search.default.directory_provider", "filesystem");
+		extraProperties.put("hibernate.search.default.indexBase", "target/lucenefiles");
+		extraProperties.put("hibernate.search.lucene_version", "LUCENE_CURRENT");
+//		extraProperties.put("hibernate.search.default.worker.execution", "async");
+		return extraProperties;
+	}
+
+	/**
+	 * Do some fancy logging to create a nice access log that has details about each incoming request.
+	 */
+	public IServerInterceptor loggingInterceptor() {
+		LoggingInterceptor retVal = new LoggingInterceptor();
+		retVal.setLoggerName("fhirtest.access");
+		retVal.setMessageFormat(
+				"Path[${servletPath}] Source[${requestHeader.x-forwarded-for}] Operation[${operationType} ${operationName} ${idOrResourceName}] UA[${requestHeader.user-agent}] Params[${requestParameters}] ResponseEncoding[${responseEncodingNoDefault}]");
+		retVal.setLogExceptions(true);
+		retVal.setErrorMessageFormat("ERROR - ${requestVerb} ${requestUrl}");
+		return retVal;
+	}
+
+	/**
+	 * This interceptor adds some pretty syntax highlighting in responses when a browser is detected
+	 */
+	@Bean(autowire = Autowire.BY_TYPE)
+	public IServerInterceptor responseHighlighterInterceptor() {
+		ResponseHighlighterInterceptor retVal = new ResponseHighlighterInterceptor();
+		return retVal;
+	}
+
+	@Bean(autowire = Autowire.BY_TYPE)
+	public IServerInterceptor subscriptionSecurityInterceptor() {
+		SubscriptionsRequireManualActivationInterceptorDstu3 retVal = new SubscriptionsRequireManualActivationInterceptorDstu3();
+		return retVal;
+	}
+
+	@Bean()
+	public JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
+		JpaTransactionManager retVal = new JpaTransactionManager();
+		retVal.setEntityManagerFactory(entityManagerFactory);
+		return retVal;
+	}
+
+}

src/main/java/ca/uhn/fhir/jpa/demo/FhirTesterConfig.java

@@ -0,0 +1,51 @@
+package ca.uhn.fhir.jpa.demo;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+
+import ca.uhn.fhir.context.FhirVersionEnum;
+import ca.uhn.fhir.to.FhirTesterMvcConfig;
+import ca.uhn.fhir.to.TesterConfig;
+
+//@formatter:off
+/**
+ * This spring config file configures the web testing module. It serves two
+ * purposes:
+ * 1. It imports FhirTesterMvcConfig, which is the spring config for the
+ *    tester itself
+ * 2. It tells the tester which server(s) to talk to, via the testerConfig()
+ *    method below
+ */
+@Configuration
+@Import(FhirTesterMvcConfig.class)
+public class FhirTesterConfig {
+
+	/**
+	 * This bean tells the testing webpage which servers it should configure itself
+	 * to communicate with. In this example we configure it to talk to the local
+	 * server, as well as one public server. If you are creating a project to
+	 * deploy somewhere else, you might choose to only put your own server's
+	 * address here.
+	 *
+	 * Note the use of the ${serverBase} variable below. This will be replaced with
+	 * the base URL as reported by the server itself. Often for a simple Tomcat
+	 * (or other container) installation, this will end up being something
+	 * like "http://localhost:8080/hapi-fhir-jpaserver-starter". If you are
+	 * deploying your server to a place with a fully qualified domain name,
+	 * you might want to use that instead of using the variable.
+	 */
+	@Bean
+	public TesterConfig testerConfig() {
+		TesterConfig retVal = new TesterConfig();
+		retVal
+			.addServer()
+				.withId("home")
+				.withFhirVersion(FhirVersionEnum.DSTU3)
+				.withBaseUrl("${serverBase}/baseDstu3")
+				.withName("Local Tester");
+		return retVal;
+	}
+
+}
+//@formatter:on

src/main/java/ca/uhn/fhir/jpa/demo/JpaServerDemo.java

@@ -0,0 +1,159 @@
+
+package ca.uhn.fhir.jpa.demo;
+
+import java.util.Collection;
+import java.util.List;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.servlet.ServletException;
+
+import org.hl7.fhir.dstu3.model.Bundle;
+import org.hl7.fhir.dstu3.model.Meta;
+import org.springframework.web.context.ContextLoaderListener;
+import org.springframework.web.context.WebApplicationContext;
+
+import ca.uhn.fhir.context.FhirContext;
+import ca.uhn.fhir.context.FhirVersionEnum;
+import ca.uhn.fhir.jpa.dao.DaoConfig;
+import ca.uhn.fhir.jpa.dao.IFhirSystemDao;
+import ca.uhn.fhir.jpa.provider.JpaConformanceProviderDstu2;
+import ca.uhn.fhir.jpa.provider.JpaSystemProviderDstu2;
+import ca.uhn.fhir.jpa.provider.dstu3.JpaConformanceProviderDstu3;
+import ca.uhn.fhir.jpa.provider.dstu3.JpaSystemProviderDstu3;
+import ca.uhn.fhir.jpa.search.DatabaseBackedPagingProvider;
+import ca.uhn.fhir.model.dstu2.composite.MetaDt;
+import ca.uhn.fhir.narrative.DefaultThymeleafNarrativeGenerator;
+import ca.uhn.fhir.rest.api.EncodingEnum;
+import ca.uhn.fhir.rest.server.*;
+import ca.uhn.fhir.rest.server.interceptor.IServerInterceptor;
+
+public class JpaServerDemo extends RestfulServer {
+
+	private static final long serialVersionUID = 1L;
+
+	private WebApplicationContext myAppCtx;
+
+	@SuppressWarnings("unchecked")
+	@Override
+	protected void initialize() throws ServletException {
+		super.initialize();
+
+		/* 
+		 * We want to support FHIR DSTU2 format. This means that the server
+		 * will use the DSTU2 bundle format and other DSTU2 encoding changes.
+		 *
+		 * If you want to use DSTU1 instead, change the following line, and change the 2 occurrences of dstu2 in web.xml to dstu1
+		 */
+		FhirVersionEnum fhirVersion = FhirVersionEnum.DSTU3;
+		setFhirContext(new FhirContext(fhirVersion));
+
+		// Get the spring context from the web container (it's declared in web.xml)
+		myAppCtx = ContextLoaderListener.getCurrentWebApplicationContext();
+
+		/* 
+		 * The BaseJavaConfigDstu2.java class is a spring configuration
+		 * file which is automatically generated as a part of hapi-fhir-jpaserver-base and
+		 * contains bean definitions for a resource provider for each resource type
+		 */
+		String resourceProviderBeanName;
+		if (fhirVersion == FhirVersionEnum.DSTU2) {
+			resourceProviderBeanName = "myResourceProvidersDstu2";
+		} else if (fhirVersion == FhirVersionEnum.DSTU3) {
+			resourceProviderBeanName = "myResourceProvidersDstu3";
+		} else {
+			throw new IllegalStateException();
+		}
+		List<IResourceProvider> beans = myAppCtx.getBean(resourceProviderBeanName, List.class);
+		setResourceProviders(beans);
+		
+		/* 
+		 * The system provider implements non-resource-type methods, such as
+		 * transaction, and global history.
+		 */
+		Object systemProvider;
+		if (fhirVersion == FhirVersionEnum.DSTU2) {
+			systemProvider = myAppCtx.getBean("mySystemProviderDstu2", JpaSystemProviderDstu2.class);
+		} else if (fhirVersion == FhirVersionEnum.DSTU3) {
+			systemProvider = myAppCtx.getBean("mySystemProviderDstu3", JpaSystemProviderDstu3.class);
+		} else {
+			throw new IllegalStateException();
+		}
+		setPlainProviders(systemProvider);
+
+		/*
+		 * The conformance provider exports the supported resources, search parameters, etc for
+		 * this server. The JPA version adds resource counts to the exported statement, so it
+		 * is a nice addition.
+		 */
+		if (fhirVersion == FhirVersionEnum.DSTU2) {
+			IFhirSystemDao<ca.uhn.fhir.model.dstu2.resource.Bundle, MetaDt> systemDao = myAppCtx.getBean("mySystemDaoDstu2", IFhirSystemDao.class);
+			JpaConformanceProviderDstu2 confProvider = new JpaConformanceProviderDstu2(this, systemDao,
+					myAppCtx.getBean(DaoConfig.class));
+			confProvider.setImplementationDescription("Example Server");
+			setServerConformanceProvider(confProvider);
+		} else if (fhirVersion == FhirVersionEnum.DSTU3) {
+			IFhirSystemDao<Bundle, Meta> systemDao = myAppCtx.getBean("mySystemDaoDstu3", IFhirSystemDao.class);
+			JpaConformanceProviderDstu3 confProvider = new JpaConformanceProviderDstu3(this, systemDao,
+			myAppCtx.getBean(DaoConfig.class));
+			confProvider.setImplementationDescription("Example Server");
+			setServerConformanceProvider(confProvider);
+		} else {
+			throw new IllegalStateException();
+		}
+
+		/*
+		 * Enable ETag Support (this is already the default)
+		 */
+		setETagSupport(ETagSupportEnum.ENABLED);
+
+		/*
+		 * This server tries to dynamically generate narratives
+		 */
+		FhirContext ctx = getFhirContext();
+		ctx.setNarrativeGenerator(new DefaultThymeleafNarrativeGenerator());
+
+		/*
+		 * Default to JSON and pretty printing
+		 */
+		setDefaultPrettyPrint(true);
+		setDefaultResponseEncoding(EncodingEnum.JSON);
+
+		/*
+		 * -- New in HAPI FHIR 1.5 --
+		 * This configures the server to page search results to and from
+		 * the database, instead of only paging them to memory. This may mean
+		 * a performance hit when performing searches that return lots of results,
+		 * but makes the server much more scalable.
+		 */
+		setPagingProvider(myAppCtx.getBean(DatabaseBackedPagingProvider.class));
+
+		/*
+		 * Load interceptors for the server from Spring (these are defined in FhirServerConfig.java)
+		 */
+		Collection<IServerInterceptor> interceptorBeans = myAppCtx.getBeansOfType(IServerInterceptor.class).values();
+		for (IServerInterceptor interceptor : interceptorBeans) {
+			this.registerInterceptor(interceptor);
+		}
+
+		/*
+		 * If you are hosting this server at a specific DNS name, the server will try to 
+		 * figure out the FHIR base URL based on what the web container tells it, but
+		 * this doesn't always work. If you are setting links in your search bundles that
+		 * just refer to "localhost", you might want to use a server address strategy:
+		 */
+		//setServerAddressStrategy(new HardcodedServerAddressStrategy("http://mydomain.com/fhir/baseDstu2"));
+		
+		/*
+		 * If you are using DSTU3+, you may want to add a terminology uploader, which allows 
+		 * uploading of external terminologies such as Snomed CT. Note that this uploader
+		 * does not have any security attached (any anonymous user may use it by default)
+		 * so it is a potential security vulnerability. Consider using an AuthorizationInterceptor
+		 * with this feature.
+		 */
+		//if (fhirVersion == FhirVersionEnum.DSTU3) {
+		//	 registerProvider(myAppCtx.getBean(TerminologyUploaderProviderDstu3.class));
+		//}
+	}
+
+}