1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.FlakeId do
7 Flake is a decentralized, k-ordered id generation service.
11 * [flaky](https://github.com/nirvana/flaky), released under the terms of the Truly Free License,
12 * [Flake](https://github.com/boundary/flake), Copyright 2012, Boundary, Apache License, Version 2.0
21 import Kernel, except: [to_string: 1]
23 defstruct node: nil, time: 0, sq: 0
25 @doc "Converts a binary Flake to a String"
26 def to_string(<<0::integer-size(64), id::integer-size(64)>>) do
30 def to_string(flake = <<_::integer-size(64), _::integer-size(48), _::integer-size(16)>>) do
34 def to_string(s), do: s
37 def from_string(unquote(i)), do: <<0::integer-size(128)>>
38 def from_string(unquote(Kernel.to_string(i))), do: <<0::integer-size(128)>>
41 def from_string(flake = <<_::integer-size(128)>>), do: flake
43 def from_string(string) when is_binary(string) and byte_size(string) < 18 do
44 case Integer.parse(string) do
45 {id, _} -> <<0::integer-size(64), id::integer-size(64)>>
50 def from_string(string) do
51 string |> decode_base62 |> from_integer
54 def to_integer(<<integer::integer-size(128)>>), do: integer
56 def from_integer(integer) do
57 <<_time::integer-size(64), _node::integer-size(48), _seq::integer-size(16)>> =
58 <<integer::integer-size(128)>>
61 @doc "Generates a Flake"
63 def get, do: to_string(:gen_server.call(:flake, :get))
71 {:ok, FlakeId.to_string(value)}
76 {:ok, FlakeId.to_string(value)}
81 {:ok, FlakeId.from_string(value)}
84 def autogenerate(), do: get()
88 :gen_server.start_link({:local, :flake}, __MODULE__, [], [])
93 {:ok, %FlakeId{node: mac(), time: time()}}
97 def handle_call(:get, _from, state) do
98 {flake, new_state} = get(time(), state)
99 {:reply, flake, new_state}
102 # Matches when the calling time is the same as the state time. Incr. sq
103 defp get(time, %FlakeId{time: time, node: node, sq: seq}) do
104 new_state = %FlakeId{time: time, node: node, sq: seq + 1}
105 {gen_flake(new_state), new_state}
108 # Matches when the times are different, reset sq
109 defp get(newtime, %FlakeId{time: time, node: node}) when newtime > time do
110 new_state = %FlakeId{time: newtime, node: node, sq: 0}
111 {gen_flake(new_state), new_state}
114 # Error when clock is running backwards
115 defp get(newtime, %FlakeId{time: time}) when newtime < time do
116 {:error, :clock_running_backwards}
119 defp gen_flake(%FlakeId{time: time, node: node, sq: seq}) do
120 <<time::integer-size(64), node::integer-size(48), seq::integer-size(16)>>
123 defp nthchar_base62(n) when n <= 9, do: ?0 + n
124 defp nthchar_base62(n) when n <= 35, do: ?A + n - 10
125 defp nthchar_base62(n), do: ?a + n - 36
127 defp encode_base62(<<integer::integer-size(128)>>) do
133 defp encode_base62(int, acc) when int < 0, do: encode_base62(-int, acc)
134 defp encode_base62(int, []) when int == 0, do: '0'
135 defp encode_base62(int, acc) when int == 0, do: acc
137 defp encode_base62(int, acc) do
140 acc = [nthchar_base62(r) | acc]
141 encode_base62(id, acc)
144 defp decode_base62(s) do
145 decode_base62(String.to_charlist(s), 0)
148 defp decode_base62([c | cs], acc) when c >= ?0 and c <= ?9,
149 do: decode_base62(cs, 62 * acc + (c - ?0))
151 defp decode_base62([c | cs], acc) when c >= ?A and c <= ?Z,
152 do: decode_base62(cs, 62 * acc + (c - ?A + 10))
154 defp decode_base62([c | cs], acc) when c >= ?a and c <= ?z,
155 do: decode_base62(cs, 62 * acc + (c - ?a + 36))
157 defp decode_base62([], acc), do: acc
160 {mega_seconds, seconds, micro_seconds} = :erlang.timestamp()
161 1_000_000_000 * mega_seconds + seconds * 1000 + :erlang.trunc(micro_seconds / 1000)
165 {:ok, addresses} = :inet.getifaddrs()
168 Enum.reduce(addresses, [], fn {iface, attrs}, acc ->
169 if attrs[:hwaddr], do: [iface | acc], else: acc
172 iface = Enum.at(ifaces_with_mac, :rand.uniform(length(ifaces_with_mac)) - 1)
177 {:ok, addresses} = :inet.getifaddrs()
178 proplist = :proplists.get_value(name, addresses)
179 hwaddr = Enum.take(:proplists.get_value(:hwaddr, proplist), 6)
180 <<worker::integer-size(48)>> = :binary.list_to_bin(hwaddr)