WIP : begin working on gridfs implementation

build.sbt

@@ -120,6 +120,15 @@ lazy val vfs = project.in(file("vfs")).
       "commons-io" % "commons-io" % "2.4" % Test)
   ).dependsOn(core % "test->test;compile->compile")
 
+lazy val gridfs = project.in(file("gridfs")).
+  settings(Common.settings: _*).settings(
+    name := "benji-gridfs",
+    libraryDependencies ++= Seq(
+      Dependencies.slf4jApi,
+      "org.reactivemongo" %% "reactivemongo" % "0.17.0"
+    )
+  ).dependsOn(core % "test->test;compile->compile")
+
 lazy val play = project.in(file("play")).
   settings(Common.settings ++ Seq(
     name := "benji-play",
@@ -178,7 +187,7 @@ lazy val benji = (project in file(".")).
       }
     ) ++ Publish.settings).
   dependsOn(s3, google, vfs, play).
-  aggregate(core, s3, google, vfs, play)
+  aggregate(core, s3, google, vfs, play, gridfs)
 
 publishTo in ThisBuild := Some {
   import Resolver.mavenStylePatterns

gridfs/.gitignore

@@ -0,0 +1,4 @@
+project/project
+project/target
+src/test/resources/local.conf
+target

gridfs/src/main/resources/META-INF/services/com.zengularity.benji.spi.StorageScheme

@@ -0,0 +1 @@
+com.zengularity.benji.gridfs.GridFSScheme

gridfs/src/main/scala/GridFSBucketRef.scala

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2018-2019 Zengularity SA (FaberNovel Technologies) <https://www.zengularity.com>
+ */
+package com.zengularity.benji.gridfs
+
+import scala.concurrent.{ ExecutionContext, Future }
+
+import com.zengularity.benji.{ BucketRef, BucketVersioning }
+import com.zengularity.benji.exception.BucketAlreadyExistsException
+
+final class GridFSBucketRef private[gridfs] (
+  storage: GridFSStorage,
+  val name: String) extends BucketRef with BucketVersioning {
+
+  def exists(implicit ec: ExecutionContext): Future[Boolean] = {
+    val filesAndChunksStats = for {
+      gridfs <- storage.transport.gridfs(name)
+      filesStats <- gridfs.files.stats
+      chunksStats <- gridfs.chunks.stats
+    } yield (filesStats, chunksStats)
+
+    filesAndChunksStats.transform {
+      case Success(_) => Success(true)
+      case Failure(_) => Success(false)
+    }
+  }
+
+  def create(failsIfExists: Boolean = false)(implicit ec: ExecutionContext): Future[Unit] = {
+    val isCreated = for {
+      gridfs <- storage.transport.gridfs(name)
+      isCreated <- gridfs.ensureIndex()
+    } yield isCreated
+
+    isCreated.transform {
+      case Success(false) if failsIfExists => Failure[Unit](BucketAlreadyExistsException("toto"))
+      case Success(_) => Success({})
+      case failed => failed
+    }
+  }
+}

gridfs/src/main/scala/GridFSFactory.scala

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2018-2019 Zengularity SA (FaberNovel Technologies) <https://www.zengularity.com>
+ */
+
+package com.zengularity.benji.gridfs
+
+import java.net.URI
+
+import play.api.libs.ws.ahc.StandaloneAhcWSClient
+
+import com.zengularity.benji.ObjectStorage
+
+import com.zengularity.benji.spi.{ Injector, StorageFactory, StorageScheme }
+
+/**
+ * This factory is using `javax.inject`
+ * to resolve `play.api.libs.ws.ahc.StandaloneAhcWSClient`.
+ */
+final class GridFSFactory extends StorageFactory {
+  @SuppressWarnings(Array("org.wartremover.warts.TryPartial"))
+  def apply(injector: Injector, uri: URI): ObjectStorage = {
+    @inline implicit def ws: StandaloneAhcWSClient =
+      injector.instanceOf(classOf[StandaloneAhcWSClient])
+
+    GridFS[URI](uri).get
+  }
+}
+
+/** Storage scheme for GridFS */
+final class GridFSScheme extends StorageScheme {
+  val scheme = "gridfs"
+
+  @inline
+  def factoryClass: Class[_ <: StorageFactory] = classOf[GridFSFactory]
+}

gridfs/src/main/scala/GridFSTransport.scala

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2018-2019 Zengularity SA (FaberNovel Technologies) <https://www.zengularity.com>
+ */
+package com.zengularity.benji.gridfs
+
+import scala.concurrent.{ ExecutionContext, Future }
+import scala.util.{ Failure, Try }
+
+import reactivemongo.api.gridfs.GridFS
+import reactivemongo.api.{ BSONSerializationPack, MongoConnection }
+
+import com.zengularity.benji.exception.BenjiUnknownError
+
+final class GridFSTransport(driver: reactivemongo.api.MongoDriver, connection: MongoConnection, mongoUri: MongoConnection.ParsedURI) {
+  def close(): Unit = {
+    driver.close()
+  }
+
+  def gridfs(prefix: String)(implicit ec: ExecutionContext): Future[GridFS[BSONSerializationPack.type]] = {
+    mongoUri.db match {
+      case Some(name) =>
+        connection.database(name).map(db => GridFS[BSONSerializationPack.type](db, prefix))
+
+      case None =>
+        Future.failed(new BenjiUnknownError(s"Fails to get the db from $mongoUri"))
+    }
+  }
+}
+
+object GridFSTransport {
+  def apply(uri: String): Try[GridFSTransport] = {
+    val driver = new reactivemongo.api.MongoDriver
+
+    val res = for {
+      mongoUri <- MongoConnection.parseURI(uri)
+      con <- driver.connection(mongoUri, strictUri = true)
+    } yield new GridFSTransport(driver, con, mongoUri)
+
+    res.recoverWith {
+      case error => Failure[GridFSTransport](new BenjiUnknownError(s"Fails to create the connection to $uri", Some(error)))
+    }
+  }
+}
+

gridfs/src/main/scala/GridsFSStorage.scala

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2018-2019 Zengularity SA (FaberNovel Technologies) <https://www.zengularity.com>
+ */
+
+package com.zengularity.benji.gridfs
+
+import com.zengularity.benji.{ Bucket, ObjectStorage }
+
+class GridFSStorage(val transport: GridFSTransport, val requestTimeout: Option[Long]) extends ObjectStorage { self =>
+
+  def withRequestTimeout(timeout: Long) =
+    new GridFSStorage(transport, Some(timeout))
+
+  def bucket(name: String) = new GridFSBucketRef(this, name)
+
+  object buckets extends self.BucketsRequest {
+    def apply()(implicit m: Materializer): Source[Bucket, NotUsed] = {
+      implicit def ec: ExecutionContext = m.executionContext
+      val gridfs = transport.gridfsdb
+    }
+  }
+}
+
+object GridFSStorage {
+  /**
+   * Returns a client for GridsFS Object Storage.
+   *
+   * @param transport the GridFS transport
+   * @param requestTimeout the optional timeout for the prepared requests (none by default)
+   */
+  def apply(transport: GridFSTransport, requestTimeout: Option[Long] = None): GridFSStorage = new GridFSStorage(transport, requestTimeout)
+}

gridfs/src/main/scala/package.scala

@@ -0,0 +1,11 @@
+/*
+ * Copyright (C) 2018-2019 Zengularity SA (FaberNovel Technologies) <https://www.zengularity.com>
+ */
+
+package com.zengularity.benji
+
+/**
+ * Requires to add the appropriate dependencies in your build
+ * (see documentation).
+ */
+package object gridfs {}