major compactions

Author: kjnilsson

src/ra_log.erl

@@ -227,7 +227,7 @@ init(#{uid := UId,
     MtRange = ra_mt:range(Mt0),
     SegRefs = my_segrefs(UId, SegWriter),
     Reader = ra_log_segments:init(UId, Dir, MaxOpen, AccessPattern, SegRefs,
-                                Names, Counter),
+                                  Counter, LogId),
     SegmentRange = ra_log_segments:range(Reader),
     %% TODO: check ra_range:add/2 actually performas the correct logic we expect
     Range = ra_range:add(MtRange, SegmentRange),
@@ -1288,21 +1288,20 @@ delete_everything(#?MODULE{cfg = #cfg{uid = UId,
 
 -spec release_resources(non_neg_integer(),
                         sequential | random, state()) -> state().
-release_resources(MaxOpenSegments,
-                  AccessPattern,
+release_resources(MaxOpenSegments, AccessPattern,
                   #?MODULE{cfg = #cfg{uid = UId,
+                                      log_id = LogId,
                                       directory = Dir,
-                                      counter = Counter,
-                                      names = Names},
+                                      counter = Counter},
                            reader = Reader} = State) ->
     ActiveSegs = ra_log_segments:segment_refs(Reader),
     % close all open segments
     % deliberately ignoring return value
     _ = ra_log_segments:close(Reader),
     %% open a new segment with the new max open segment value
     State#?MODULE{reader = ra_log_segments:init(UId, Dir, MaxOpenSegments,
-                                              AccessPattern,
-                                              ActiveSegs, Names, Counter)}.
+                                                AccessPattern, ActiveSegs,
+                                                Counter, LogId)}.
 
 
 %%% Local functions

src/ra_log_segment.erl

@@ -22,6 +22,7 @@
          max_count/1,
          filename/1,
          segref/1,
+         info/1,
          is_same_as/2,
          copy/3]).
 
@@ -56,7 +57,7 @@
               fd :: option(file:io_device()),
               index_size :: pos_integer(),
               access_pattern :: sequential | random,
-              file_advise = normal ::  posix_file_advise(),
+              file_advise = normal :: posix_file_advise(),
               mode = append :: read | append,
               compute_checksums = true :: boolean()}).
 
@@ -453,6 +454,41 @@ segref(Filename) ->
     close(Seg),
     SegRef.
 
+-spec info(file:filename_all()) ->
+    #{size => non_neg_integer(),
+      max_count => non_neg_integer(),
+      file_type => regular | symlink,
+      ctime => integer(),
+      links => non_neg_integer(),
+      % max_size => non_neg_integer(),
+      num_entries => non_neg_integer(),
+      range => ra:range(),
+      indexes => ra_seq:state(),
+      name => file:filename_all()}.
+info(Filename)
+  when not is_tuple(Filename) ->
+    %% TODO: this can be much optimised by a specialised index parsing
+    %% function
+    {ok, Seg} = open(Filename, #{mode => read}),
+    Index = Seg#state.index,
+    {ok, #file_info{type = T,
+                    links = Links,
+                    ctime = CTime}} = file:read_link_info(Filename,
+                                                          [raw, {time, posix}]),
+
+    Info = #{size => Seg#state.data_write_offset,
+             file_type => T,
+             links => Links,
+             ctime => CTime,
+             max_count => max_count(Seg),
+             num_entries => maps:size(Index),
+             range => range(Seg),
+             indexes => ra_seq:from_list(maps:keys(Index)),
+             name => filename:basename(Filename)
+            },
+    close(Seg),
+    Info.
+
 -spec is_same_as(state(), file:filename_all()) -> boolean().
 is_same_as(#state{cfg = #cfg{filename = Fn0}}, Fn) ->
     is_same_filename_all(Fn0, Fn).