Split upload into separate encoding and uploading operations

Still provide a helper that does it all, though - `store`

app/Main.hs

@@ -45,7 +45,7 @@ import Upload
   , filesystemUploadableRandomConvergence
   , filesystemUploadableWithConvergence
   , filesystemStorageServer
-  , upload
+  , store
   , prettyFormatSharemap
   )
 
@@ -99,10 +99,12 @@ main = do
         Right bytesSecret ->
           filesystemUploadableWithConvergence bytesSecret path params
 
-  servers >>= upload uploadable >>= report_upload
+  servers <- getServers
+  result <- store servers uploadable
+  report_upload result
 
   where
-    servers = mapM filesystemStorageServer
+    getServers = mapM filesystemStorageServer
       [ "storage001"
       , "storage002"
       , "storage003"

src/Upload.hs

@@ -9,6 +9,7 @@ module Upload
   , filesystemStorageServer
   , getConvergentKey
   , upload
+  , store
 
   , prettyFormatSharemap
   , adjustSegmentSize
@@ -204,23 +205,48 @@ uploadImmutableShares storageIndex uploads = do
     uploadOneChunk offset storageIndex (shareNum, server, shareData) =
       storageServerWrite server storageIndex shareNum offset shareData
 
--- Given some cleartext, some encoding parameters, and some servers: encrypt,
--- encode, and upload some shares that can later be used to reconstruct the
--- cleartext.
+
+-- | Encrypt and encode some application data to some ZFEC shares and upload
+-- them to some servers.
+store ::
+  -- | The servers to consider using.
+  [StorageServer] ->
+  -- | The application data to operate on.
+  Uploadable ->
+  -- | The result of the attempt.
+  IO UploadResult
+store servers uploadable@(Uploadable key _ params _) =
+  encryptAndEncode uploadable >>= upload servers key params
+
+-- | Given some cleartext and some encoding parameters: encrypt and encode some
+-- shares that can later be used to reconstruct the cleartext.
+encryptAndEncode ::
+  -- | The application data to encrypt and encode.
+  Uploadable ->
+  -- | An action to get an action that can be repeatedly evaluated to get
+  -- share data.  As long as there is more share data, it evaluates to Left.
+  -- When shares are done, it evaluates to Right.
+  IO (IO (Either [B.ByteString] (AESKey128 -> Capability)))
+encryptAndEncode (Uploadable key size params read) =
+  chkEncrypt key read >>= makeChkEncoder params size
+
+-- | Given some cleartext, some encoding parameters, and some servers:
+-- encrypt, encode, and upload some shares that can later be used to
+-- reconstruct the cleartext.
 --
 -- This replaces allmydata.immutable.upload.Uploader.upload.
-upload :: Uploadable -> [StorageServer] -> IO UploadResult
-upload Uploadable
-  { uploadableKey = key
-  , uploadableSize = size
-  , uploadableParameters = params
-  , uploadableReadCleartext = readCleartext
-  } servers = do
-
-  -- Prepare the share data
-  readCiphertext <- chkEncrypt key readCleartext
-  streams <- makeChkEncoder params size readCiphertext
-
+upload ::
+  -- | The servers to consider uploading shares to.
+  [StorageServer] ->
+  -- | The encryption key (to derive the storage index).
+  AESKey128 ->
+  -- | The encoding parameters (XXX only for happy, right?)
+  Parameters ->
+  -- | An action to repeatedly evaluate to get share data or the cap.
+  (IO (Either [B.ByteString] (AESKey128 -> Capability))) ->
+  -- | Describe the outcome of the upload.
+  IO UploadResult
+upload servers key params streams = do
   -- Decide where to put it
   existingShares <- locateAllShareholders storageIndex servers
   let targets = targetServers params existingShares