remove re-export of RunFsPaths

There is no need for a module re-export and we don't do it anywhere else.
Also, wanting to know the file paths to where a run stores its data
breaks the abstraction boundary and is only needed for tests or
benchmarks. As such, it's good to be more explicit about importing them.

bench/micro/Bench/Database/LSMTree/Internal/Lookup.hs

@@ -33,6 +33,7 @@ import           Database.LSMTree.Internal.Lookup (BatchSize (..),
                      prepLookups)
 import           Database.LSMTree.Internal.Run (Run)
 import qualified Database.LSMTree.Internal.Run as Run
+import           Database.LSMTree.Internal.RunFsPaths (RunFsPaths (..))
 import           Database.LSMTree.Internal.Serialise
 import qualified Database.LSMTree.Internal.WriteBuffer as WB
 import           Prelude hiding (getContents)
@@ -128,7 +129,7 @@ lookupsInBatchesEnv Config {..} = do
     let hasFS = FS.ioHasFS (FS.MountPoint benchTmpDir)
     hasBlockIO <- FS.ioHasBlockIO hasFS ioctxps
     let wb = WB.WB storedKeys
-        fsps = Run.RunFsPaths 0
+        fsps = RunFsPaths 0
     r <- Run.fromWriteBuffer hasFS fsps wb
     let nentriesReal = unNumEntries $ Run.runNumEntries r
     assert (nentriesReal == nentries) $ pure ()

bench/micro/Bench/Database/LSMTree/Internal/WriteBuffer.hs

@@ -17,6 +17,8 @@ import           Database.LSMTree.Extras.UTxO
 import           Database.LSMTree.Internal.Entry
 import           Database.LSMTree.Internal.Run (Run)
 import qualified Database.LSMTree.Internal.Run as Run
+import           Database.LSMTree.Internal.RunFsPaths (RunFsPaths (..),
+                     activeRunsDir)
 import           Database.LSMTree.Internal.Serialise
 import           Database.LSMTree.Internal.WriteBuffer (WriteBuffer)
 import qualified Database.LSMTree.Internal.WriteBuffer as WB
@@ -133,20 +135,20 @@ benchWriteBuffer conf@Config{name} =
           writeBufferEnvCleanup
 
     -- We'll remove the files on every run, so we can re-use the same run number.
-    getPaths :: IO Run.RunFsPaths
-    getPaths = pure (Run.RunFsPaths 0)
+    getPaths :: IO RunFsPaths
+    getPaths = pure (RunFsPaths 0)
 
     -- Simply remove the whole active directory.
     cleanupPaths :: FS.HasFS IO FS.HandleIO -> IO ()
-    cleanupPaths hasFS = FS.removeDirectoryRecursive hasFS Run.activeRunsDir
+    cleanupPaths hasFS = FS.removeDirectoryRecursive hasFS activeRunsDir
 
 insert :: InputKOps -> WriteBuffer
 insert (NormalInputs kops) =
     List.foldl' (\wb (k, e) -> WB.addEntryNormal k e wb) WB.empty kops
 insert (MonoidalInputs kops mappendVal) =
     List.foldl' (\wb (k, e) -> WB.addEntryMonoidal mappendVal k e wb) WB.empty kops
 
-flush :: FS.HasFS IO FS.HandleIO -> Run.RunFsPaths -> WriteBuffer -> IO (Run (FS.Handle (FS.HandleIO)))
+flush :: FS.HasFS IO FS.HandleIO -> RunFsPaths -> WriteBuffer -> IO (Run (FS.Handle (FS.HandleIO)))
 flush = Run.fromWriteBuffer
 
 data InputKOps

src/Database/LSMTree/Internal/Run.hs

@@ -35,10 +35,9 @@
 -- not exhaustive.
 --
 module Database.LSMTree.Internal.Run (
-    -- * Paths
-    module FsPaths
     -- * Run
-  , Run (..)
+    Run (..)
+  , RunFsPaths
   , sizeInPages
   , addReference
   , removeReference
@@ -73,7 +72,7 @@ import qualified Database.LSMTree.Internal.IndexCompact as Index
 import qualified Database.LSMTree.Internal.RawBytes as RB
 import           Database.LSMTree.Internal.RunBuilder (RunBuilder)
 import qualified Database.LSMTree.Internal.RunBuilder as Builder
-import           Database.LSMTree.Internal.RunFsPaths as FsPaths
+import           Database.LSMTree.Internal.RunFsPaths
 import           Database.LSMTree.Internal.Serialise
 import           Database.LSMTree.Internal.WriteBuffer (WriteBuffer)
 import qualified Database.LSMTree.Internal.WriteBuffer as WB
@@ -206,7 +205,7 @@ openFromDisk fs runRunFsPaths = do
          =<< CRC.readChecksumsFile fs (runChecksumsPath runRunFsPaths)
 
     -- verify checksums of files we don't read yet
-    let paths = runFsPaths runRunFsPaths
+    let paths = pathsForRunFiles runRunFsPaths
     checkCRC (forRunKOps expectedChecksums) (forRunKOps paths)
     checkCRC (forRunBlob expectedChecksums) (forRunBlob paths)
 

src/Database/LSMTree/Internal/RunBuilder.hs

@@ -82,7 +82,7 @@ new fs runBuilderFsPaths numEntries estimatedNumPages = do
     runBuilderBlobOffset <- newIORef 0
 
     FS.createDirectoryIfMissing fs False activeRunsDir
-    runBuilderHandles <- traverse (makeHandle fs) (runFsPaths runBuilderFsPaths)
+    runBuilderHandles <- traverse (makeHandle fs) (pathsForRunFiles runBuilderFsPaths)
 
     let builder = RunBuilder {..}
     writeIndexHeader fs builder
@@ -169,7 +169,7 @@ unsafeFinalise fs builder@RunBuilder {..} = do
 close :: HasFS IO h -> RunBuilder (FS.Handle h) -> IO ()
 close fs RunBuilder {..} = do
     traverse_ (closeHandle fs) runBuilderHandles
-    traverse_ (FS.removeFile fs) (runFsPaths runBuilderFsPaths)
+    traverse_ (FS.removeFile fs) (pathsForRunFiles runBuilderFsPaths)
 
 {-------------------------------------------------------------------------------
   Helpers

src/Database/LSMTree/Internal/RunFsPaths.hs

@@ -1,14 +1,14 @@
 module Database.LSMTree.Internal.RunFsPaths (
     RunFsPaths (..)
-  , runFsPaths
+  , pathsForRunFiles
   , runKOpsPath
   , runBlobPath
   , runFilterPath
   , runIndexPath
   , runChecksumsPath
   , activeRunsDir
     -- * Checksums
-  , runChecksumFileNames
+  , checksumFileNamesForRunFiles
   , toChecksumsFile
   , fromChecksumsFile
     -- * ForRunFiles abstraction
@@ -44,20 +44,21 @@ import qualified Database.LSMTree.Internal.CRC32C as CRC
 newtype RunFsPaths = RunFsPaths { runNumber :: Int }
   deriving (Show, NFData)
 
-runFsPaths :: RunFsPaths -> ForRunFiles FsPath
-runFsPaths fsPaths = fmap (runFilePathWithExt fsPaths) runFileExts
+-- | Paths to all files associated with this run, except 'runChecksumsPath'.
+pathsForRunFiles :: RunFsPaths -> ForRunFiles FsPath
+pathsForRunFiles fsPaths = fmap (runFilePathWithExt fsPaths) runFileExts
 
 runKOpsPath :: RunFsPaths -> FsPath
-runKOpsPath = forRunKOps . runFsPaths
+runKOpsPath = forRunKOps . pathsForRunFiles
 
 runBlobPath :: RunFsPaths -> FsPath
-runBlobPath = forRunBlob . runFsPaths
+runBlobPath = forRunBlob . pathsForRunFiles
 
 runFilterPath :: RunFsPaths -> FsPath
-runFilterPath = forRunFilter . runFsPaths
+runFilterPath = forRunFilter . pathsForRunFiles
 
 runIndexPath :: RunFsPaths -> FsPath
-runIndexPath = forRunIndex . runFsPaths
+runIndexPath = forRunIndex . pathsForRunFiles
 
 runChecksumsPath :: RunFsPaths -> FsPath
 runChecksumsPath = flip runFilePathWithExt "checksums"
@@ -81,14 +82,14 @@ runFileExts = ForRunFiles {
   Checksums
 -------------------------------------------------------------------------------}
 
-runChecksumFileNames :: ForRunFiles CRC.ChecksumsFileName
-runChecksumFileNames = fmap (CRC.ChecksumsFileName . BS.pack) runFileExts
+checksumFileNamesForRunFiles :: ForRunFiles CRC.ChecksumsFileName
+checksumFileNamesForRunFiles = fmap (CRC.ChecksumsFileName . BS.pack) runFileExts
 
 toChecksumsFile :: ForRunFiles CRC.CRC32C -> CRC.ChecksumsFile
-toChecksumsFile = Map.fromList . toList . liftA2 (,) runChecksumFileNames
+toChecksumsFile = Map.fromList . toList . liftA2 (,) checksumFileNamesForRunFiles
 
 fromChecksumsFile :: CRC.ChecksumsFile -> Either String (ForRunFiles CRC.CRC32C)
-fromChecksumsFile file = for runChecksumFileNames $ \name ->
+fromChecksumsFile file = for checksumFileNamesForRunFiles $ \name ->
     case Map.lookup name file of
       Just crc -> Right crc
       Nothing  -> Left ("key not found: " <> show name)

test/Test/Database/LSMTree/Internal/Lookup.hs

@@ -44,6 +44,7 @@ import           Database.LSMTree.Internal.RawOverflowPage
 import           Database.LSMTree.Internal.RawPage
 import qualified Database.LSMTree.Internal.Run as Run
 import           Database.LSMTree.Internal.RunAcc as Run
+import           Database.LSMTree.Internal.RunFsPaths (RunFsPaths (..))
 import           Database.LSMTree.Internal.Serialise
 import           Database.LSMTree.Internal.Serialise.Class
 import qualified Database.LSMTree.Internal.WriteBuffer as WB
@@ -301,7 +302,7 @@ prop_roundtripFromWriteBufferLookupIO dats =
     pure $ opaqueifyBlobs (V.fromList model) === opaqueifyBlobs (V.zip (V.fromList lookupss) real)
   where
     mkRuns hasFS = first V.fromList . unzip <$> sequence [
-          (,wb) <$> Run.fromWriteBuffer hasFS (Run.RunFsPaths i) wb
+          (,wb) <$> Run.fromWriteBuffer hasFS (RunFsPaths i) wb
         | (i, dat) <- zip [0..] (getSmallList dats)
         , let wb = WB.WB (runData dat)
         ]

test/Test/Database/LSMTree/Internal/Merge.hs

@@ -13,6 +13,8 @@ import           Database.LSMTree.Extras.Generators (KeyForIndexCompact,
 import qualified Database.LSMTree.Internal.Entry as Entry
 import qualified Database.LSMTree.Internal.Merge as Merge
 import qualified Database.LSMTree.Internal.Run as Run
+import           Database.LSMTree.Internal.RunFsPaths (RunFsPaths (..),
+                     pathsForRunFiles)
 import           Database.LSMTree.Internal.Serialise
 import           Database.LSMTree.Internal.WriteBuffer (WriteBuffer)
 import qualified Database.LSMTree.Internal.WriteBuffer as WB
@@ -81,7 +83,7 @@ prop_MergeDistributes fs level stepSize (fmap unTypedWriteBuffer -> wbs) = do
       .&&. lhsKOpsFile === rhsKOpsFile
       .&&. lhsBlobFile === rhsBlobFile
   where
-    flush n = Run.fromWriteBuffer fs (Run.RunFsPaths n)
+    flush n = Run.fromWriteBuffer fs (RunFsPaths n)
 
     stats = tabulate "value size" (map (showPowersOf10 . sizeofValue) vals)
           . label (if any isLargeKOp kops then "has large k/op" else "no large k/op")
@@ -98,12 +100,12 @@ prop_CloseMerge ::
      [TypedWriteBuffer KeyForIndexCompact SerialisedValue SerialisedBlob] ->
      IO Property
 prop_CloseMerge fs level (Positive stepSize) (fmap unTypedWriteBuffer -> wbs) = do
-    let path0 = Run.RunFsPaths 0
+    let path0 = RunFsPaths 0
     runs <- sequenceA $ zipWith flush [10..] wbs
     mergeToClose <- makeInProgressMerge path0 runs
     traverse_ (Merge.close fs) mergeToClose
 
-    filesExist <- traverse (FS.doesFileExist fs) (Run.runFsPaths path0)
+    filesExist <- traverse (FS.doesFileExist fs) (pathsForRunFiles path0)
 
     -- cleanup
     traverse_ (Run.removeReference fs) runs
@@ -112,7 +114,7 @@ prop_CloseMerge fs level (Positive stepSize) (fmap unTypedWriteBuffer -> wbs) =
       counterexample ("run files exist: " <> show filesExist) $
         isJust mergeToClose ==> all not filesExist
   where
-    flush n = Run.fromWriteBuffer fs (Run.RunFsPaths n)
+    flush n = Run.fromWriteBuffer fs (RunFsPaths n)
 
     makeInProgressMerge path runs =
       Merge.new fs level mappendValues path runs >>= \case
@@ -140,8 +142,8 @@ mergeRuns ::
      StepSize ->
      IO (Run.Run (FS.Handle h))
 mergeRuns fs level n runs (Positive stepSize) = do
-    Merge.new fs level mappendValues (Run.RunFsPaths n) runs >>= \case
-      Nothing -> Run.fromWriteBuffer fs (Run.RunFsPaths n) WB.empty
+    Merge.new fs level mappendValues (RunFsPaths n) runs >>= \case
+      Nothing -> Run.fromWriteBuffer fs (RunFsPaths n) WB.empty
       Just m  -> go m
   where
     go m =

test/Test/Database/LSMTree/Internal/Run.hs

@@ -43,6 +43,7 @@ import           Database.LSMTree.Internal.RawOverflowPage
                      (rawOverflowPageRawBytes)
 import           Database.LSMTree.Internal.RawPage
 import           Database.LSMTree.Internal.Run
+import           Database.LSMTree.Internal.RunFsPaths (RunFsPaths (..))
 import qualified Database.LSMTree.Internal.RunReader as Reader
 import           Database.LSMTree.Internal.Serialise
 import qualified Database.LSMTree.Internal.WriteBuffer as WB