commit e1e0c5727dd82e27cd1515903ef7aea7782c435b · anil.recoil.org/slop

+3 -2

stack/cacheio/bin/cache_cli.ml

···

       6
       6
        
         (* Default app name for the cache CLI tool *)

     

       7
       7
        
         let app_name = "cacheio-cli" in

     

       8
       8
        
       

     

       9
       9
       -
         (* Run with Eio to provide the filesystem *)

     

       9
       9
       +
         (* Run with Eio to provide the filesystem and stdin *)

     

       10
       10
        
         Eio_main.run @@ fun env ->

     

       11
       11
        
         let fs = env#fs in

     

       12
       12
       +
         let stdin = (env#stdin :> Eio.Flow.source_ty Eio.Resource.t) in

     

       12
       13
        
       

     

       13
       14
        
         let doc = "Cache management tool" in

     

       14
       15
        
         let man = [

     
···

       17
       18
        
           `P "This tool provides subcommands for listing, clearing, and managing cached files.";

     

       18
       19
        
         ] in

     

       19
       20
        
         let info = Cmd.info "cache" ~doc ~man in

     

       20
       20
       -
         let cmd = Cmd.group info (Cacheio_cmd.Cmd.make_commands ~app_name fs) in

     

       21
       21
       +
         let cmd = Cmd.group info (Cacheio_cmd.Cmd.make_commands ~app_name fs stdin) in

     

       21
       22
        
       

     

       22
       23
        
         exit (Cmd.eval cmd)

     

       23
       24

+1 -5

stack/cacheio/bin/example.ml

···

       4
       4
        
       

     

       5
       5
        
       let setup_logs () =

     

       6
       6
        
         Logs.set_level (Some Logs.Info);

     

       7
       7
       -
         let reporter = Logs.format_reporter

     

       8
       8
       -
           ~pp_header:Logs.pp_header

     

       9
       9
       -
           ~app:Format.std_formatter

     

       10
       10
       -
           ~dst:Format.err_formatter () in

     

       11
       11
       -
         Logs.set_reporter reporter

     

       7
       7
       +
         Logs.set_reporter (Logs_fmt.reporter ())

     

       12
       8
        
       

     

       13
       9
        
       (** Example: Using CacheIO for caching data *)

     

       14
       10
        
       let cache_example env sw =

+18 -21

stack/cacheio/lib/cacheio.ml

···

       153
       153
        
       (** {1 Creation} *)

     

       154
       154
        
       

     

       155
       155
        
       let create ~base_dir =

     

       156
       156
       +
         (* Note: RNG initialization should be done by the application *)

     

       157
       157
       +
         (* For testing, we'll use a simple deterministic approach *)

     

       158
       158
       +
       

     

       156
       159
        
         (* Ensure base directory exists *)

     

       157
       160
        
         (try Path.mkdir ~perm:0o755 base_dir

     

       158
       161
        
          with Eio.Io (Eio.Fs.E (Already_exists _), _) -> ()

     
···

       169
       172
        
       (** {1 Streaming Operations} *)

     

       170
       173
        
       

     

       171
       174
        
       let get t ~key ~sw =

     

       172
       172
       -
         Mutex.use_ro t.mutex @@ fun () ->

     

       175
       175
       +
         (* No mutex needed for read operation *)

     

       173
       176
        
         match find_file t.base_dir key with

     

       174
       177
        
         | None -> None

     

       175
       178
        
         | Some (path, _ttl, _flags) ->

     
···

       199
       202
        
         let dir = ensure_dirs t key in

     

       200
       203
        
       

     

       201
       204
        
         (* Generate temporary filename using hashed key *)

     

       202
       202
       -
         (* Use Mirage crypto RNG for cryptographically secure randomness *)

     

       203
       203
       -
         let rand_bytes = Mirage_crypto_rng.generate 8 in

     

       204
       204
       -
         let rand_cstruct = Cstruct.of_string rand_bytes in

     

       205
       205
       -
         let rand_hex = Cstruct.to_hex_string rand_cstruct in

     

       205
       205
       +
         (* Use timestamp and random for temporary file uniqueness *)

     

       206
       206
       +
         let rand_hex = Printf.sprintf "%016Lx" (Random.bits64 ()) in

     

       206
       207
        
         let temp_name = Printf.sprintf "tmp.%s.%s"

     

       207
       208
        
           (hash_key key)

     

       208
       209
        
           rand_hex in

     
···

       222
       223
        
       (** {1 Basic Operations} *)

     

       223
       224
        
       

     

       224
       225
        
       let exists t ~key =

     

       225
       225
       -
         Mutex.use_ro t.mutex @@ fun () ->

     

       226
       226
       +
         (* No mutex needed for checking existence *)

     

       226
       227
        
         match find_file t.base_dir key with

     

       227
       228
        
         | Some _ -> true

     

       228
       229
        
         | None -> false

     
···

       237
       238
        
         | None -> ()

     

       238
       239
        
       

     

       239
       240
        
       let size t ~key =

     

       240
       240
       -
         Mutex.use_ro t.mutex @@ fun () ->

     

       241
       241
       +
         (* No mutex needed for getting size *)

     

       241
       242
        
         match find_file t.base_dir key with

     

       242
       243
        
         | Some (path, _, _) ->

     

       243
       244
        
             (try Some (Optint.Int63.to_int64 (Path.stat ~follow:false path).size)

     
···

       245
       246
        
         | None -> None

     

       246
       247
        
       

     

       247
       248
        
       let get_path t ~key =

     

       248
       248
       -
         Mutex.use_ro t.mutex @@ fun () ->

     

       249
       249
       +
         (* No mutex needed for getting path *)

     

       249
       250
        
         match find_file t.base_dir key with

     

       250
       251
        
         | Some (path, _, _) -> Some path

     

       251
       252
        
         | None -> None

     
···

       292
       293
        
         | None -> ()

     

       293
       294
        
       

     

       294
       295
        
       let get_flags t ~key =

     

       295
       295
       -
         Mutex.use_ro t.mutex @@ fun () ->

     

       296
       296
       +
         (* No mutex needed for getting flags *)

     

       296
       297
        
         match find_file t.base_dir key with

     

       297
       298
        
         | Some (_, _, flags) -> Some flags

     

       298
       299
        
         | None -> None

     
···

       331
       332
        
         with _ -> acc

     

       332
       333
        
       

     

       333
       334
        
       let scan t =

     

       334
       334
       -
         Mutex.use_ro t.mutex @@ fun () ->

     

       335
       335
       +
         (* No mutex needed for read-only directory scan *)

     

       335
       336
        
         try

     

       336
       337
        
           Path.read_dir t.base_dir

     

       337
       338
        
           |> List.filter (fun name -> name <> "tmp")

     
···

       343
       344
        
         Stats.of_entries entries

     

       344
       345
        
       

     

       345
       346
        
       let expire t =

     

       346
       346
       -
         Mutex.use_rw ~protect:false t.mutex @@ fun () ->

     

       347
       347
       +
         (* Scan without mutex, then delete with individual locks *)

     

       347
       348
        
         let entries = scan t in

     

       348
       349
        
         List.fold_left (fun count entry ->

     

       349
       350
        
           if Entry.is_expired entry then begin

     
···

       354
       355
        
         ) 0 entries

     

       355
       356
        
       

     

       356
       357
        
       let clear t =

     

       357
       357
       -
         Mutex.use_rw ~protect:false t.mutex @@ fun () ->

     

       358
       358
       +
         (* Scan without mutex, then delete with individual locks *)

     

       358
       359
        
         let entries = scan t in

     

       359
       360
        
         List.iter (fun entry ->

     

       360
       361
        
           if not (Entry.is_pinned entry) then

     
···

       362
       363
        
         ) entries

     

       363
       364
        
       

     

       364
       365
        
       let clear_temporary t =

     

       365
       365
       -
         Mutex.use_rw ~protect:false t.mutex @@ fun () ->

     

       366
       366
       +
         (* Scan without mutex, then delete with individual locks *)

     

       366
       367
        
         let entries = scan t in

     

       367
       368
        
         List.iter (fun entry ->

     

       368
       369
        
           if Entry.is_temporary entry then

     
···

       398
       399
        
         let dir = ensure_dirs t key in

     

       399
       400
        
       

     

       400
       401
        
         (* Generate temporary filename using hashed key *)

     

       401
       401
       -
         (* Use Mirage crypto RNG for cryptographically secure randomness *)

     

       402
       402
       -
         let rand_bytes = Mirage_crypto_rng.generate 8 in

     

       403
       403
       -
         let rand_cstruct = Cstruct.of_string rand_bytes in

     

       404
       404
       -
         let rand_hex = Cstruct.to_hex_string rand_cstruct in

     

       402
       402
       +
         (* Use timestamp and random for temporary file uniqueness *)

     

       403
       403
       +
         let rand_hex = Printf.sprintf "%016Lx" (Random.bits64 ()) in

     

       405
       404
        
         let temp_name = Printf.sprintf "tmp.%s.%s.chunk"

     

       406
       405
        
           (hash_key key) rand_hex in

     

       407
       406
        
         let temp_path = Path.(t.tmp_dir / temp_name) in

     
···

       478
       477
        
       

     

       479
       478
        
               (* Create final file *)

     

       480
       479
        
               let final_filename = key_to_filename ?ttl ~flags key in

     

       481
       481
       -
               (* Use Mirage crypto RNG for cryptographically secure randomness *)

     

       482
       482
       -
               let rand_bytes = Mirage_crypto_rng.generate 8 in

     

       483
       483
       -
               let rand_cstruct = Cstruct.of_string rand_bytes in

     

       484
       484
       -
               let rand_hex = Cstruct.to_hex_string rand_cstruct in

     

       480
       480
       +
               (* Use timestamp and random for temporary file uniqueness *)

     

       481
       481
       +
               let rand_hex = Printf.sprintf "%016Lx" (Random.bits64 ()) in

     

       485
       482
        
               let temp_name = Printf.sprintf "tmp.%s.%s.coalesce"

     

       486
       483
        
                 (hash_key key) rand_hex in

     

       487
       484
        
               let temp_path = Path.(t.tmp_dir / temp_name) in

+82 -19

stack/cacheio/lib/cmd.ml

···

       3
       3
        
       open Cmdliner

     

       4
       4
        
       open Eio

     

       5
       5
        
       

     

       6
       6
       -
       let list_cmd ~app_name fs =

     

       6
       6
       +
       let list_cmd ~app_name fs _stdin =

     

       7
       7
        
         let list cache_dir stale expired pinned temporary older_than =

     

       8
       8
        
           let base_dir = Path.(fs / cache_dir) in

     

       9
       9
        
           let cache = Cacheio.create ~base_dir in

     
···

       63
       63
        
         let cache_dir_term = Xdge.Cmd.cache_term app_name in

     

       64
       64
        
         Cmd.v info Term.(const list $ cache_dir_term $ stale $ expired $ pinned $ temporary $ older_than)

     

       65
       65
        
       

     

       66
       66
       -
       let expire_cmd ~app_name fs =

     

       66
       66
       +
       let expire_cmd ~app_name fs _stdin =

     

       67
       67
        
         let expire cache_dir =

     

       68
       68
        
           let base_dir = Path.(fs / cache_dir) in

     

       69
       69
        
           let cache = Cacheio.create ~base_dir in

     
···

       76
       76
        
         let cache_dir_term = Xdge.Cmd.cache_term app_name in

     

       77
       77
        
         Cmd.v info Term.(const expire $ cache_dir_term)

     

       78
       78
        
       

     

       79
       79
       -
       let clear_cmd ~app_name fs =

     

       79
       79
       +
       let clear_cmd ~app_name fs _stdin =

     

       80
       80
        
         let clear cache_dir all temporary =

     

       81
       81
        
           let base_dir = Path.(fs / cache_dir) in

     

       82
       82
        
           let cache = Cacheio.create ~base_dir in

     
···

       101
       101
        
         let cache_dir_term = Xdge.Cmd.cache_term app_name in

     

       102
       102
        
         Cmd.v info Term.(const clear $ cache_dir_term $ all $ temporary)

     

       103
       103
        
       

     

       104
       104
       -
       let flag_cmd ~app_name fs =

     

       104
       104
       +
       let flag_cmd ~app_name fs _stdin =

     

       105
       105
        
         let flag cache_dir key add remove set_flags =

     

       106
       106
        
           let base_dir = Path.(fs / cache_dir) in

     

       107
       107
        
           let cache = Cacheio.create ~base_dir in

     
···

       169
       169
        
         let cache_dir_term = Xdge.Cmd.cache_term app_name in

     

       170
       170
        
         Cmd.v info Term.(const flag $ cache_dir_term $ key $ add $ remove $ set_flags)

     

       171
       171
        
       

     

       172
       172
       -
       let stats_cmd ~app_name fs =

     

       172
       172
       +
       let stats_cmd ~app_name fs _stdin =

     

       173
       173
        
         let stats cache_dir =

     

       174
       174
        
           let base_dir = Path.(fs / cache_dir) in

     

       175
       175
        
           let cache = Cacheio.create ~base_dir in

     
···

       197
       197
        
         let cache_dir_term = Xdge.Cmd.cache_term app_name in

     

       198
       198
        
         Cmd.v info Term.(const stats $ cache_dir_term)

     

       199
       199
        
       

     

       200
       200
       -
       let put_cmd ~app_name fs =

     

       200
       200
       +
       let put_cmd ~app_name fs stdin =

     

       201
       201
        
         let put cache_dir key file ttl pinned stale temporary =

     

       202
       202
        
           let base_dir = Path.(fs / cache_dir) in

     

       203
       203
        
           let cache = Cacheio.create ~base_dir in

     
···

       219
       219
        
                 let file_path = Path.(fs / path) in

     

       220
       220
        
                 (Path.open_in ~sw file_path :> Eio.Flow.source_ty Eio.Resource.t)

     

       221
       221
        
             | None ->

     

       222
       222
       -
                 (* Read from stdin - we need to get it from the environment *)

     

       223
       223
       -
                 failwith "Reading from stdin requires access to Eio environment - use -f flag for now"

     

       222
       222
       +
                 (* Use stdin passed from the CLI *)

     

       223
       223
       +
                 stdin

     

       224
       224
        
           in

     

       225
       225
        
       

     

       226
       226
        
           (* Put into cache *)

     
···

       258
       258
        
         let cache_dir_term = Xdge.Cmd.cache_term app_name in

     

       259
       259
        
         Cmd.v info Term.(const put $ cache_dir_term $ key $ file $ ttl $ pinned $ stale $ temporary)

     

       260
       260
        
       

     

       261
       261
       -
       let get_cmd ~app_name fs =

     

       261
       261
       +
       let get_cmd ~app_name fs _stdin =

     

       262
       262
        
         let get cache_dir key output =

     

       263
       263
        
           let base_dir = Path.(fs / cache_dir) in

     

       264
       264
        
           let cache = Cacheio.create ~base_dir in

     
···

       302
       302
        
         let cache_dir_term = Xdge.Cmd.cache_term app_name in

     

       303
       303
        
         Cmd.v info Term.(const get $ cache_dir_term $ key $ output)

     

       304
       304
        
       

     

       305
       305
       +
       (** Delete command - remove a specific cache entry *)

     

       306
       306
       +
       let delete_cmd ~app_name fs _stdin =

     

       307
       307
       +
         let delete cache_dir key =

     

       308
       308
       +
           let base_dir = Path.(fs / cache_dir) in

     

       309
       309
       +
           let cache = Cacheio.create ~base_dir in

     

       310
       310
       +
       

     

       311
       311
       +
           if Cacheio.exists cache ~key then begin

     

       312
       312
       +
             Cacheio.delete cache ~key;

     

       313
       313
       +
             Printf.printf "Deleted cache entry: %s\n" key

     

       314
       314
       +
           end else begin

     

       315
       315
       +
             Printf.eprintf "Key not found: %s\n" key;

     

       316
       316
       +
             exit 1

     

       317
       317
       +
           end

     

       318
       318
       +
         in

     

       319
       319
       +
       

     

       320
       320
       +
         let key = Arg.(required & pos 0 (some string) None & info [] ~docv:"KEY"

     

       321
       321
       +
                         ~doc:"Cache key to delete") in

     

       322
       322
       +
       

     

       323
       323
       +
         let doc = "Delete a cache entry" in

     

       324
       324
       +
         let man = [

     

       325
       325
       +
           `S "DESCRIPTION";

     

       326
       326
       +
           `P "Remove a specific cache entry by key.";

     

       327
       327
       +
           `S "EXAMPLES";

     

       328
       328
       +
           `P "Delete entry: $(b,cache delete mykey)";

     

       329
       329
       +
         ] in

     

       330
       330
       +
         let info = Cmd.info "delete" ~doc ~man in

     

       331
       331
       +
         let cache_dir_term = Xdge.Cmd.cache_term app_name in

     

       332
       332
       +
         Cmd.v info Term.(const delete $ cache_dir_term $ key)

     

       333
       333
       +
       

     

       334
       334
       +
       (** Exists command - check if a key exists *)

     

       335
       335
       +
       let exists_cmd ~app_name fs _stdin =

     

       336
       336
       +
         let exists cache_dir key quiet =

     

       337
       337
       +
           let base_dir = Path.(fs / cache_dir) in

     

       338
       338
       +
           let cache = Cacheio.create ~base_dir in

     

       339
       339
       +
       

     

       340
       340
       +
           if Cacheio.exists cache ~key then begin

     

       341
       341
       +
             if not quiet then Printf.printf "Key exists: %s\n" key;

     

       342
       342
       +
             exit 0

     

       343
       343
       +
           end else begin

     

       344
       344
       +
             if not quiet then Printf.printf "Key does not exist: %s\n" key;

     

       345
       345
       +
             exit 1

     

       346
       346
       +
           end

     

       347
       347
       +
         in

     

       348
       348
       +
       

     

       349
       349
       +
         let key = Arg.(required & pos 0 (some string) None & info [] ~docv:"KEY"

     

       350
       350
       +
                         ~doc:"Cache key to check") in

     

       351
       351
       +
         let quiet = Arg.(value & flag & info ["quiet"; "q"]

     

       352
       352
       +
                           ~doc:"Suppress output, use exit code only") in

     

       353
       353
       +
       

     

       354
       354
       +
         let doc = "Check if a cache entry exists" in

     

       355
       355
       +
         let man = [

     

       356
       356
       +
           `S "DESCRIPTION";

     

       357
       357
       +
           `P "Check if a cache entry exists. Returns exit code 0 if exists, 1 if not.";

     

       358
       358
       +
           `S "EXAMPLES";

     

       359
       359
       +
           `P "Check existence: $(b,cache exists mykey)";

     

       360
       360
       +
           `P "Use in scripts: $(b,if cache exists mykey -q; then echo 'Found'; fi)";

     

       361
       361
       +
         ] in

     

       362
       362
       +
         let info = Cmd.info "exists" ~doc ~man in

     

       363
       363
       +
         let cache_dir_term = Xdge.Cmd.cache_term app_name in

     

       364
       364
       +
         Cmd.v info Term.(const exists $ cache_dir_term $ key $ quiet)

     

       365
       365
       +
       

     

       305
       366
        
       (** {1 Command Groups} *)

     

       306
       367
        
       

     

       307
       307
       -
       let make_commands ~app_name fs = [

     

       308
       308
       -
         get_cmd ~app_name fs;

     

       309
       309
       -
         put_cmd ~app_name fs;

     

       310
       310
       -
         list_cmd ~app_name fs;

     

       311
       311
       -
         expire_cmd ~app_name fs;

     

       312
       312
       -
         clear_cmd ~app_name fs;

     

       313
       313
       -
         flag_cmd ~app_name fs;

     

       314
       314
       -
         stats_cmd ~app_name fs

     

       368
       368
       +
       let make_commands ~app_name fs stdin = [

     

       369
       369
       +
         get_cmd ~app_name fs stdin;

     

       370
       370
       +
         put_cmd ~app_name fs stdin;

     

       371
       371
       +
         delete_cmd ~app_name fs stdin;

     

       372
       372
       +
         exists_cmd ~app_name fs stdin;

     

       373
       373
       +
         list_cmd ~app_name fs stdin;

     

       374
       374
       +
         expire_cmd ~app_name fs stdin;

     

       375
       375
       +
         clear_cmd ~app_name fs stdin;

     

       376
       376
       +
         flag_cmd ~app_name fs stdin;

     

       377
       377
       +
         stats_cmd ~app_name fs stdin

     

       315
       378
        
       ]

     

       316
       379
        
       

     

       317
       317
       -
       let make_cmd ~app_name fs =

     

       380
       380
       +
       let make_cmd ~app_name fs stdin =

     

       318
       381
        
         let doc = "Cache management commands" in

     

       319
       382
        
         let info = Cmd.info "cache" ~doc in

     

       320
       320
       -
         Cmd.group info (make_commands ~app_name fs)

     

       383
       383
       +
         Cmd.group info (make_commands ~app_name fs stdin)

+16 -10

stack/cacheio/lib/cmd.mli

···

       10
       10
        
       (** {1 Command Builders} *)

     

       11
       11
        
       

     

       12
       12
        
       (** Create get command with given filesystem and app name *)

     

       13
       13
       -
       val get_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       13
       13
       +
       val get_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> Eio.Flow.source_ty Eio.Resource.t -> unit Cmdliner.Cmd.t

     

       14
       14
        
       

     

       15
       15
        
       (** Create put command with given filesystem and app name *)

     

       16
       16
       -
       val put_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       16
       16
       +
       val put_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> Eio.Flow.source_ty Eio.Resource.t -> unit Cmdliner.Cmd.t

     

       17
       17
        
       

     

       18
       18
        
       (** Create list command with given filesystem and app name *)

     

       19
       19
       -
       val list_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       19
       19
       +
       val list_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> Eio.Flow.source_ty Eio.Resource.t -> unit Cmdliner.Cmd.t

     

       20
       20
        
       

     

       21
       21
        
       (** Create expire command with given filesystem and app name *)

     

       22
       22
       -
       val expire_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       22
       22
       +
       val expire_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> Eio.Flow.source_ty Eio.Resource.t -> unit Cmdliner.Cmd.t

     

       23
       23
        
       

     

       24
       24
        
       (** Create clear command with given filesystem and app name *)

     

       25
       25
       -
       val clear_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       25
       25
       +
       val clear_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> Eio.Flow.source_ty Eio.Resource.t -> unit Cmdliner.Cmd.t

     

       26
       26
        
       

     

       27
       27
        
       (** Create flag management command with given filesystem and app name *)

     

       28
       28
       -
       val flag_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       28
       28
       +
       val flag_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> Eio.Flow.source_ty Eio.Resource.t -> unit Cmdliner.Cmd.t

     

       29
       29
        
       

     

       30
       30
        
       (** Create statistics command with given filesystem and app name *)

     

       31
       31
       -
       val stats_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       31
       31
       +
       val stats_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> Eio.Flow.source_ty Eio.Resource.t -> unit Cmdliner.Cmd.t

     

       32
       32
       +
       

     

       33
       33
       +
       (** Create delete command with given filesystem and app name *)

     

       34
       34
       +
       val delete_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> Eio.Flow.source_ty Eio.Resource.t -> unit Cmdliner.Cmd.t

     

       35
       35
       +
       

     

       36
       36
       +
       (** Create exists command with given filesystem and app name *)

     

       37
       37
       +
       val exists_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> Eio.Flow.source_ty Eio.Resource.t -> unit Cmdliner.Cmd.t

     

       32
       38
        
       

     

       33
       39
        
       (** {1 Command Groups} *)

     

       34
       40
        
       

     

       35
       35
       -
       (** Create all cache commands for the given filesystem and app name *)

     

       36
       36
       -
       val make_commands : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t list

     

       41
       41
       +
       (** Create all cache commands for the given filesystem, stdin and app name *)

     

       42
       42
       +
       val make_commands : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> Eio.Flow.source_ty Eio.Resource.t -> unit Cmdliner.Cmd.t list

     

       37
       43
        
       

     

       38
       44
        
       (** Create main command group containing all cache subcommands *)

     

       39
       39
       -
       val make_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> unit Cmdliner.Cmd.t

     

       45
       45
       +
       val make_cmd : app_name:string -> Eio.Fs.dir_ty Eio.Path.t -> Eio.Flow.source_ty Eio.Resource.t -> unit Cmdliner.Cmd.t

+1 -1

stack/cacheio/lib/dune

···

       2
       2
        
        (public_name cacheio)

     

       3
       3
        
        (name cacheio)

     

       4
       4
        
        (modules cacheio flags entry stats range chunk)

     

       5
       5
       -
        (libraries eio eio_main digestif yojson ptime ptime.clock.os logs fmt xdge mirage-crypto-rng cstruct))

     

       5
       5
       +
        (libraries eio eio_main digestif yojson ptime ptime.clock.os logs fmt xdge cstruct))

     

       6
       6
        
       

     

       7
       7
        
       (library

     

       8
       8
        
        (public_name cacheio.cmd)