-122

lib/utils.ex

reviewed

··· 244 244 end 245 245 end 246 246 247 247 - @spec buddy_tlog_id([non_neg_integer], non_neg_integer) :: non_neg_integer 248 248 - def buddy_tlog_id(tlog_ids, server_id) when is_list(tlog_ids) and is_integer(server_id) do 249 249 - index = rem(server_id, length(tlog_ids)) 250 250 - Enum.at(tlog_ids, index) 251 251 - end 252 252 - 253 247 @spec tlog_generation_for_version([TLogGeneration.t], non_neg_integer) :: TLogGeneration.t 254 248 def tlog_generation_for_version(generations, version) when is_list(generations) and is_integer(version) do 255 249 case Enum.find(generations, fn %TLogGeneration{} = tlg -> tlg.start_version <= version end) do ··· 258 252 259 253 nil -> raise "Could not find a generation for version #{inspect(version)} in #{inspect(generations)}" 260 254 end 261 261 - end 262 262 - 263 263 - @doc """ 264 264 - Merges two sorted lists of key/value pairs. 265 265 - 266 266 - If both lists contain the same key, the value from the 267 267 - second list is used. 268 268 - 269 269 - **Warning: The lists MUST be sorted by key in advance.** 270 270 - 271 271 - ## Examples 272 272 - 273 273 - iex> l1 = [{"foo", "bar"}, {"foo2", "bar2"}, {"zoo", "baz"}] 274 274 - iex> l2 = [{"aoo", "aar"}, {"foo2", "different_bar2"}] 275 275 - iex> merge_pairs(l1, l2) 276 276 - [ 277 277 - {"aoo", "aar"}, 278 278 - {"foo", "bar"}, 279 279 - {"foo2", "different_bar2"}, 280 280 - {"zoo", "baz"}, 281 281 - ] 282 282 - 283 283 - """ 284 284 - def merge_pairs(list1, list2), do: do_merge(list1, list2, []) |> Enum.reverse() 285 285 - 286 286 - defp do_merge([], [], acc), do: acc 287 287 - defp do_merge([p1 | rest1], [], acc), do: do_merge(rest1, [], [p1 | acc]) 288 288 - defp do_merge([], [p2 | rest2], acc), do: do_merge([], rest2, [p2 | acc]) 289 289 - 290 290 - defp do_merge([{k1, _} = p1 | rest1] = list1, [{k2, _} = p2 | rest2] = list2, acc) do 291 291 - cond do 292 292 - k1 < k2 -> 293 293 - do_merge(rest1, list2, [p1 | acc]) 294 294 - k1 > k2 -> 295 295 - do_merge(list1, rest2, [p2 | acc]) 296 296 - k1 == k2 -> 297 297 - do_merge(rest1, rest2, [p2 | acc]) 298 298 - end 299 299 - end 300 300 - 301 301 - @doc """ 302 302 - Interleaves two sorted lists of batches, combining batches with the same version number. 303 303 - 304 304 - **Warning: The lists MUST be sorted by version in advance.** 305 305 - 306 306 - 307 307 - ## Examples 308 308 - 309 309 - iex> b1 = [{1, [:a], {2, [:b]}] 310 310 - iex> b2 = [{2, [:c]}, {4, [:d]}] 311 311 - iex> interleave_batches(b1, b2) 312 312 - [ 313 313 - {1, [:a], []}, 314 314 - {2, [:b], [:c]}, 315 315 - {4, [], [:d]}, 316 316 - ] 317 317 - 318 318 - """ 319 319 - @spec interleave_batches([{integer, list}], [{integer, list}]) :: [{integer, list}] 320 320 - def interleave_batches(batches1, batches2) do 321 321 - interleave(batches1, batches2, []) 322 322 - |> Enum.reverse() 323 323 - end 324 324 - 325 325 - defp interleave([{ver1, _} = batch1 | rest1] = batches1, [{ver2, _} = batch2 | rest2] = batches2, acc) do 326 326 - cond do 327 327 - ver1 < ver2 -> 328 328 - {ver1, l1} = batch1 329 329 - interleave(rest1, batches2, [{ver1, l1, []} | acc]) 330 330 - ver1 > ver2 -> 331 331 - {ver2, l2} = batch2 332 332 - interleave(batches1, rest2, [{ver2, [], l2} | acc]) 333 333 - ver1 == ver2 -> 334 334 - {_, l1} = batch1 335 335 - {_, l2} = batch2 336 336 - interleave(rest1, rest2, [{ver1, l1, l2} | acc]) 337 337 - end 338 338 - end 339 339 - defp interleave([{ver1, l1} | rest1], [], acc), do: interleave(rest1, [], [{ver1, l1, []} | acc]) 340 340 - defp interleave([], [{ver2, l2} | rest2], acc), do: interleave([], rest2, [{ver2, [], l2} | acc]) 341 341 - defp interleave([], [], acc), do: acc 342 342 - 343 343 - @doc """ 344 344 - Merges a list of lists of versioned batches of numbered mutations (e.g. TLog peek replies). 345 345 - 346 346 - ## Examples 347 347 - 348 348 - iex> tlog_pids |> Enum.map(&TLog.peek(&1, tag, sv, ev)) |> merge_batches() 349 349 - [ 350 350 - { 351 351 - 100, 352 352 - [ 353 353 - {0, {:write, "foo", "bar"}}, 354 354 - {1, {:clear, "foo"}}, 355 355 - ] 356 356 - }, 357 357 - {101, ...}, 358 358 - {102, ...}, 359 359 - ] 360 360 - """ 361 361 - @spec merge_batches([[{non_neg_integer, [Utils.numbered_mutation]}]]) :: [{non_neg_integer, [Utils.numbered_mutation]}] 362 362 - def merge_batches(batches) do 363 363 - batches 364 364 - |> Enum.concat() 365 365 - |> Enum.group_by(fn {version, _mutations} -> version end, fn {_version, mutations} -> mutations end) 366 366 - |> Enum.map(fn {version, mut_batches} -> 367 367 - # TODO: this could be done more efficiently with a K-way merge since all batches are sorted 368 368 - # But, for now, this function is not really on the hot path (only needed after TLog failure) 369 369 - mutations = 370 370 - mut_batches 371 371 - |> Enum.concat() 372 372 - |> Enum.uniq_by(fn {i, _mut} -> i end) 373 373 - |> Enum.sort() 374 374 - {version, mutations} 375 375 - end) 376 376 - |> Enum.sort() 377 255 end 378 256 379 257 @doc """

-37

test/utils_test.exs

reviewed

··· 30 30 ] 31 31 end 32 32 end 33 33 - 34 34 - describe "merge_pairs/2" do 35 35 - test "merges" do 36 36 - l1 = [ 37 37 - {"foo", "bar"}, 38 38 - {"foo2", "bar2"}, 39 39 - {"zoo", "baz"}, 40 40 - ] 41 41 - l2 = [ 42 42 - {"aoo", "aar"}, 43 43 - {"foo2", "different_bar2"}, 44 44 - ] 45 45 - 46 46 - assert Utils.merge_pairs(l1, l2) == [ 47 47 - {"aoo", "aar"}, 48 48 - {"foo", "bar"}, 49 49 - {"foo2", "different_bar2"}, 50 50 - {"zoo", "baz"}, 51 51 - ] 52 52 - end 53 53 - end 54 54 - 55 55 - describe "interleave_batches/2" do 56 56 - test "interleaves" do 57 57 - batches1 = [{1, [:a, :b, :c]}, {3, [:d, :e, :f]}, {4, [:g, :h, :i]}, {9, [:j, :k, :l]}] 58 58 - batches2 = [{0, [:m, :n, :o]}, {1, [:p, :q, :r]}, {2, [:s, :t, :u]}, {4, [:v, :w, :x]}] 59 59 - 60 60 - assert Utils.interleave_batches(batches1, batches2) == [ 61 61 - {0, [], [:m, :n, :o]}, 62 62 - {1, [:a, :b, :c], [:p, :q, :r]}, 63 63 - {2, [], [:s, :t, :u]}, 64 64 - {3, [:d, :e, :f], []}, 65 65 - {4, [:g, :h, :i], [:v, :w, :x]}, 66 66 - {9, [:j, :k, :l], []}, 67 67 - ] 68 68 - end 69 69 - end 70 33 end