Implement a simple NpmManager

buildSrc/src/main/kotlin/Dependencies.kt

@@ -175,6 +175,9 @@ object Dependencies {
     "$androidFhirGroup:$androidFhirEngineModule:${Versions.androidFhirEngine}"
   const val androidFhirKnowledge = "$androidFhirGroup:knowledge:${Versions.androidFhirKnowledge}"
 
+  const val apacheCommonsCompress =
+    "org.apache.commons:commons-compress:${Versions.apacheCommonsCompress}"
+
   const val desugarJdkLibs = "com.android.tools:desugar_jdk_libs:${Versions.desugarJdkLibs}"
   const val fhirUcum = "org.fhir:ucum:${Versions.fhirUcum}"
   const val gson = "com.google.code.gson:gson:${Versions.gson}"
@@ -259,6 +262,7 @@ object Dependencies {
     const val androidFhirCommon = "0.1.0-alpha04"
     const val androidFhirEngine = "0.1.0-beta03"
     const val androidFhirKnowledge = "0.1.0-alpha01"
+    const val apacheCommonsCompress = "1.21"
     const val desugarJdkLibs = "2.0.3"
     const val caffeine = "2.9.1"
     const val fhirUcum = "1.0.3"
@@ -269,7 +273,6 @@ object Dependencies {
     // Newer versions of HapiFhir don't work on Android due to the use of Caffeine 3+
     // Wait for this to release (6.3): https://github.com/hapifhir/hapi-fhir/pull/4196
     const val hapiFhir = "6.0.1"
-
     // Newer versions don't work on Android due to Apache Commons Codec:
     // Wait for this fix: https://github.com/hapifhir/org.hl7.fhir.core/issues/1046
     const val hapiFhirCore = "5.6.36"

knowledge/build.gradle.kts

@@ -90,11 +90,14 @@ dependencies {
   coreLibraryDesugaring(Dependencies.desugarJdkLibs)
 
   implementation(Dependencies.Kotlin.stdlib)
+  implementation(Dependencies.Kotlin.kotlinCoroutinesCore)
   implementation(Dependencies.Lifecycle.liveDataKtx)
   implementation(Dependencies.Room.ktx)
   implementation(Dependencies.Room.runtime)
   implementation(Dependencies.timber)
-  implementation(Dependencies.Kotlin.kotlinCoroutinesCore)
+  implementation(Dependencies.http)
+  implementation(Dependencies.HapiFhir.fhirCoreConvertors)
+  implementation(Dependencies.apacheCommonsCompress)
 
   kapt(Dependencies.Room.compiler)
 
@@ -104,6 +107,7 @@ dependencies {
   testImplementation(Dependencies.Kotlin.kotlinCoroutinesTest)
   testImplementation(Dependencies.mockitoInline)
   testImplementation(Dependencies.mockitoKotlin)
+  testImplementation(Dependencies.mockWebServer)
   testImplementation(Dependencies.robolectric)
   testImplementation(Dependencies.truth)
 }

knowledge/src/main/java/com/google/android/fhir/knowledge/ImplementationGuide.kt → knowledge/src/main/java/com/google/android/fhir/knowledge/Dependency.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 Google LLC
+ * Copyright 2023 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,4 +20,4 @@ package com.google.android.fhir.knowledge
  * Holds Implementation Guide attributes. Used to define dependencies, load dependencies from
  * Package Manager
  */
-data class ImplementationGuide(val packageId: String, val version: String, val uri: String)
+data class Dependency(val packageId: String, val version: String, val uri: String? = null)

knowledge/src/main/java/com/google/android/fhir/knowledge/KnowledgeManager.kt

@@ -23,6 +23,9 @@ import ca.uhn.fhir.parser.IParser
 import com.google.android.fhir.knowledge.db.impl.KnowledgeDatabase
 import com.google.android.fhir.knowledge.db.impl.entities.ResourceMetadataEntity
 import com.google.android.fhir.knowledge.db.impl.entities.toEntity
+import com.google.android.fhir.knowledge.npm.NpmFileManager
+import com.google.android.fhir.knowledge.npm.OkHttpPackageDownloader
+import com.google.android.fhir.knowledge.npm.PackageDownloader
 import java.io.File
 import java.io.FileInputStream
 import kotlinx.coroutines.Dispatchers
@@ -37,27 +40,42 @@ import timber.log.Timber
 class KnowledgeManager
 internal constructor(
   private val knowledgeDatabase: KnowledgeDatabase,
+  dataFolder: File,
   private val jsonParser: IParser = FhirContext.forR4().newJsonParser(),
+  private val npmFileManager: NpmFileManager =
+    NpmFileManager(File(dataFolder, ".fhir_package_cache")),
+  private val packageDownloader: PackageDownloader = OkHttpPackageDownloader(npmFileManager),
 ) {
-
   private val knowledgeDao = knowledgeDatabase.knowledgeDao()
 
   /**
-   * * Checks if the [implementationGuides] are present in DB. If necessary, downloads the
-   * dependencies from NPM and imports data from the package manager (populates the metadata of the
-   * FHIR Resources)
+   * * Checks if the [dependencies] are present in DB. If necessary, downloads the dependencies from
+   * NPM and imports data from the package manager (populates the metadata of the FHIR Resources)
    */
-  suspend fun install(vararg implementationGuides: ImplementationGuide) {
-    TODO("[1937]Not implemented yet ")
+  suspend fun install(vararg dependencies: Dependency) {
+    for (dependency in dependencies) {
+      if (knowledgeDao.getImplementationGuide(dependency.packageId, dependency.version) != null)
+        continue
+      println(dependency)
+      val containsPackage = npmFileManager.containsPackage(dependency.packageId, dependency.version)
+      val npmPackage =
+        if (containsPackage) {
+          npmFileManager.getPackage(dependency.packageId, dependency.version)
+        } else {
+          packageDownloader.downloadPackage(dependency, PACKAGE_SERVER)
+        }
+      install(dependency, npmPackage.rootDirectory)
+      install(*npmPackage.dependencies.toTypedArray())
+    }
   }
 
   /**
-   * Checks if the [implementationGuide] is present in DB. If necessary, populates the database with
-   * the metadata of FHIR Resource from the provided [rootDirectory].
+   * Checks if the [dependency] is present in DB. If necessary, populates the database with the
+   * metadata of FHIR Resource from the provided [rootDirectory].
    */
-  suspend fun install(implementationGuide: ImplementationGuide, rootDirectory: File) {
+  suspend fun install(dependency: Dependency, rootDirectory: File) {
     // TODO(ktarasenko) copy files to the safe space?
-    val igId = knowledgeDao.insert(implementationGuide.toEntity(rootDirectory))
+    val igId = knowledgeDao.insert(dependency.toEntity(rootDirectory))
     rootDirectory.listFiles()?.forEach { file ->
       try {
         val resource = jsonParser.parseResource(FileInputStream(file))
@@ -101,7 +119,7 @@ internal constructor(
   }
 
   /** Deletes Implementation Guide, cleans up files. */
-  suspend fun delete(vararg igDependencies: ImplementationGuide) {
+  suspend fun delete(vararg igDependencies: Dependency) {
     igDependencies.forEach { igDependency ->
       val igEntity =
         knowledgeDao.getImplementationGuide(igDependency.packageId, igDependency.version)
@@ -150,15 +168,20 @@ internal constructor(
 
   companion object {
     private const val DB_NAME = "knowledge.db"
+    private const val PACKAGE_SERVER = "https://packages.fhir.org/packages/"
 
     /** Creates an [KnowledgeManager] backed by the Room DB. */
     fun create(context: Context) =
       KnowledgeManager(
-        Room.databaseBuilder(context, KnowledgeDatabase::class.java, DB_NAME).build()
+        Room.databaseBuilder(context, KnowledgeDatabase::class.java, DB_NAME).build(),
+        context.dataDir
       )
 
     /** Creates an [KnowledgeManager] backed by the in-memory DB. */
     fun createInMemory(context: Context) =
-      KnowledgeManager(Room.inMemoryDatabaseBuilder(context, KnowledgeDatabase::class.java).build())
+      KnowledgeManager(
+        Room.inMemoryDatabaseBuilder(context, KnowledgeDatabase::class.java).build(),
+        context.dataDir
+      )
   }
 }

knowledge/src/main/java/com/google/android/fhir/knowledge/db/impl/entities/ImplementationGuideEntity.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 Google LLC
+ * Copyright 2023 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,7 +19,7 @@ package com.google.android.fhir.knowledge.db.impl.entities
 import androidx.room.Entity
 import androidx.room.Index
 import androidx.room.PrimaryKey
-import com.google.android.fhir.knowledge.ImplementationGuide
+import com.google.android.fhir.knowledge.Dependency
 import java.io.File
 
 /**
@@ -46,6 +46,6 @@ internal data class ImplementationGuideEntity(
   val rootDirectory: File,
 )
 
-internal fun ImplementationGuide.toEntity(rootFolder: File): ImplementationGuideEntity {
-  return ImplementationGuideEntity(0L, uri, packageId, version, rootFolder)
+internal fun Dependency.toEntity(rootFolder: File): ImplementationGuideEntity {
+  return ImplementationGuideEntity(0L, uri ?: "", packageId, version, rootFolder)
 }

knowledge/src/main/java/com/google/android/fhir/knowledge/npm/NpmFileManager.kt

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.fhir.knowledge.npm
+
+import com.google.android.fhir.knowledge.Dependency
+import java.io.File
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONObject
+
+/** Manages stored NPM packages. */
+internal class NpmFileManager(private val cacheRoot: File) {
+
+  /**
+   * Returns the NpmPackage for the given [packageId] and [version] from cache or `null` if the
+   * package is not cached.
+   */
+  suspend fun getPackage(packageId: String, version: String): NpmPackage {
+    return withContext(Dispatchers.IO) {
+      val packageFolder = File(getPackageFolder(packageId, version), "package")
+      readNpmPackage(packageFolder)
+    }
+  }
+
+  /**
+   * Returns the NpmPackage for the given [packageId] and [version] from cache or `null` if the
+   * package is not cached.
+   */
+  suspend fun containsPackage(packageId: String, version: String): Boolean {
+    return withContext(Dispatchers.IO) {
+      val packageFolder = File(getPackageFolder(packageId, version), "package")
+      val packageJson = File(packageFolder, "package.json")
+      packageJson.exists()
+    }
+  }
+
+  /** Returns the package folder for the given [packageId] and [version]. */
+  fun getPackageFolder(packageId: String, version: String) = File(cacheRoot, "$packageId#$version")
+
+  /** Creates an [NpmPackage] parsing the package manifest file. */
+  private fun readNpmPackage(packageFolder: File): NpmPackage {
+    val packageJson = File(packageFolder, "package.json")
+    val json = JSONObject(packageJson.readText())
+    with(json) {
+      val dependenciesList = optJSONObject("dependencies")
+      val dependencies =
+        dependenciesList?.keys()?.asSequence()?.map { key ->
+          Dependency(key, dependenciesList.getString(key))
+        }
+
+      return NpmPackage(
+        getString("name"),
+        getString("version"),
+        optString("canonical"),
+        dependencies?.toList() ?: emptyList(),
+        packageFolder
+      )
+    }
+  }
+}

knowledge/src/main/java/com/google/android/fhir/knowledge/npm/NpmPackage.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.fhir.knowledge.npm
+
+import com.google.android.fhir.knowledge.Dependency
+import java.io.File
+
+/** Downloaded Npm Package metadata. */
+data class NpmPackage(
+  val packageId: String,
+  val version: String,
+  val canonical: String?,
+  val dependencies: List<Dependency>,
+  val rootDirectory: File,
+)

knowledge/src/main/java/com/google/android/fhir/knowledge/npm/OkHttpPackageDownloader.kt

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.fhir.knowledge.npm
+
+import com.google.android.fhir.knowledge.Dependency
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.io.IOException
+import java.util.zip.GZIPInputStream
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.ResponseBody
+import org.apache.commons.compress.archivers.tar.TarArchiveEntry
+import org.apache.commons.compress.archivers.tar.TarArchiveInputStream
+
+/** Downloads Npm package from the provided package server using OkHttp library. */
+internal class OkHttpPackageDownloader(
+  private val npmFileManager: NpmFileManager,
+) : PackageDownloader {
+
+  val client = OkHttpClient()
+
+  @Throws(IOException::class)
+  override suspend fun downloadPackage(
+    dependency: Dependency,
+    packageServerUrl: String,
+  ): NpmPackage {
+    return withContext(Dispatchers.IO) {
+      val packageName = dependency.packageId
+      val version = dependency.version
+      val url = "$packageServerUrl$packageName/$version"
+
+      val request = Request.Builder().url(url).get().build()
+
+      val response = client.newCall(request).execute()
+
+      if (!response.isSuccessful) {
+        throw IOException("Unexpected code $response")
+      }
+      val packageFolder = npmFileManager.getPackageFolder(dependency.packageId, dependency.version)
+
+      response.body?.use { responseBody ->
+        packageFolder.mkdirs()
+        val tgzFile = File(packageFolder, "$packageName-$version.tgz")
+        saveResponseToFile(responseBody, tgzFile)
+
+        extractTgzFile(tgzFile, packageFolder)
+
+        tgzFile.delete()
+      }
+      npmFileManager.getPackage(dependency.packageId, dependency.version)
+    }
+  }
+
+  private fun saveResponseToFile(responseBody: ResponseBody, file: File) {
+    FileOutputStream(file).use { fileOutputStream ->
+      val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+      var bytesRead: Int
+      while (responseBody.byteStream().read(buffer).also { bytesRead = it } != -1) {
+        fileOutputStream.write(buffer, 0, bytesRead)
+      }
+    }
+  }
+
+  private fun extractTgzFile(tgzFile: File, outputFolder: File) {
+    FileInputStream(tgzFile).use { fileInputStream ->
+      outputFolder.mkdirs()
+      GZIPInputStream(fileInputStream).use { gzipInputStream ->
+        TarArchiveInputStream(gzipInputStream).use { tarInputStream ->
+          var entry: TarArchiveEntry? = tarInputStream.nextTarEntry
+          while (entry != null) {
+            val outputFile = File(outputFolder, entry.name)
+
+            if (entry.isDirectory) {
+              outputFile.mkdirs()
+            } else {
+              outputFile.parentFile?.mkdirs()
+
+              val outputFileStream = FileOutputStream(outputFile)
+              val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+              var bytesRead: Int
+              while (tarInputStream.read(buffer).also { bytesRead = it } != -1) {
+                outputFileStream.write(buffer, 0, bytesRead)
+              }
+              outputFileStream.close()
+            }
+
+            entry = tarInputStream.nextTarEntry
+          }
+        }
+      }
+    }
+  }
+}