Merge branch 'master' into GH-88

# Conflicts:
#	apps/aecore/lib/aecore/chain/worker.ex

Author: thepiwo

apps/aecore/lib/aecore/chain/worker.ex

@@ -9,6 +9,7 @@ defmodule Aecore.Chain.Worker do
   alias Aecore.Chain.ChainState
   alias Aecore.Txs.Pool.Worker, as: Pool
   alias Aecore.Utils.Blockchain.BlockValidation
+  alias Aecore.Peers.Worker, as: Peers
 
   use GenServer
 
@@ -127,15 +128,14 @@ defmodule Aecore.Chain.Worker do
 
       total_tokens = ChainState.calculate_total_tokens(new_chain_state)
 
-      Logger.info(
-        fn ->
-          "Added block ##{block.header.height} with hash #{
-            block.header
-            |> BlockValidation.block_header_hash()
-            |> Base.encode16()
-          }, total tokens: #{total_tokens}"
-        end
-      )
+      Logger.info(fn ->
+        "Added block ##{block.header.height} with hash #{block.header
+        |> BlockValidation.block_header_hash()
+        |> Base.encode16()}, total tokens: #{total_tokens}"
+      end)
+
+      ## Block was validated, now we can send it to other peers
+      Peers.broadcast_to_all({:new_block, block})
 
       {:reply, :ok, {updated_block_map, updated_latest_block_chainstate}}
     catch

apps/aecore/lib/aecore/peers/worker.ex

@@ -8,17 +8,17 @@ defmodule Aecore.Peers.Worker do
   alias Aehttpclient.Client
   alias Aecore.Structures.Block
   alias Aecore.Utils.Blockchain.BlockValidation
+  alias Aehttpclient.Client, as: HttpClient
   alias Aecore.Utils.Serialization
 
+
   require Logger
 
   def start_link do
     GenServer.start_link(__MODULE__, %{}, name: __MODULE__)
   end
 
-  def init(initial_peers) do
-    {:ok, initial_peers}
-  end
+  ## Client side
 
   @spec add_peer(term) :: :ok | {:error, term()} | :error
   def add_peer(uri) do
@@ -40,18 +40,29 @@ defmodule Aecore.Peers.Worker do
     GenServer.call(__MODULE__, :all_peers)
   end
 
-  @spec broadcast_tx(tx :: map()) :: term()
-  def broadcast_tx(tx) do
-    GenServer.cast(__MODULE__, {:broadcast_tx, tx})
-  end
-
   @spec genesis_block_header_hash() :: term()
   def genesis_block_header_hash() do
     Block.genesis_block().header
     |> BlockValidation.block_header_hash()
     |> Base.encode16()
   end
 
+  @doc """
+  Making async post requests to the users
+  `type` is related to the uri e.g. /new_block
+  """
+  @spec broadcast_to_all({type :: atom(), data :: term()}) :: :ok | :error
+  def broadcast_to_all({type, data}) do
+    data = prep_data(type,data)
+    GenServer.cast(__MODULE__, {:broadcast_to_all, {type, data}})
+  end
+
+  ## Server side
+
+  def init(initial_peers) do
+    {:ok, initial_peers}
+  end
+
   def handle_call({:add_peer,uri}, _from, peers) do
     case(Client.get_info(uri)) do
       {:ok, info} ->
@@ -88,8 +99,10 @@ defmodule Aecore.Peers.Worker do
   """
   def handle_call(:check_peers, _from, peers) do
     filtered_peers = :maps.filter(fn(peer, _) ->
-        {status, info} = Client.get_info(peer)
-        :ok == status && info.genesis_block_hash == genesis_block_header_hash()
+        case Client.get_info(peer) do
+          {:ok, info} -> info.genesis_block_hash == genesis_block_header_hash()
+          _ -> false
+        end
       end, peers)
     updated_peers =
       for {peer, current_block_hash} <- filtered_peers, into: %{} do
@@ -109,17 +122,25 @@ defmodule Aecore.Peers.Worker do
     {:reply, peers, peers}
   end
 
-  def handle_cast({:broadcast_tx, tx}, peers) do
-    serialized_tx = 
-    Serialization.tx(tx, :serialize)
-    |> Poison.encode!()
-    for peer <- peers do
-      Client.send_tx(peer, serialized_tx)
-    end
+  ## Async operations
 
+  def handle_cast({:broadcast_to_all, {type, data}}, peers) do
+    send_to_peers(type, data, Map.keys(peers))
     {:noreply, peers}
   end
+
   def handle_cast(_any, peers) do
-    {:noreply, peers}
+    Logger.info("[Peers] Unhandled cast message:  #{inspect(peers)}")
   end
+
+  ## Internal functions
+  defp send_to_peers(uri, data, peers) do
+    for peer <- peers do
+      HttpClient.post(peer, data, uri)
+    end
+  end
+
+  defp prep_data(:new_tx, %{}=data), do: Serialization.tx(data, :serialize)
+  defp prep_data(:new_block, %{}=data), do: Serialization.block(data, :serialize)
+
 end

apps/aecore/lib/aecore/txs/pool/worker.ex

@@ -9,6 +9,7 @@ defmodule Aecore.Txs.Pool.Worker do
   alias Aecore.Keys.Worker, as: Keys
   alias Aecore.Structures.SignedTx
   alias Aecore.Peers.Worker, as: Peers
+
   require Logger
 
   def start_link do
@@ -44,8 +45,8 @@ defmodule Aecore.Txs.Pool.Worker do
     if is_tx_valid do
       updated_pool = Map.put_new(tx_pool, :crypto.hash(:sha256, :erlang.term_to_binary(tx)), tx)
       case tx_pool == updated_pool do
-        true -> Logger.info(" This transaction has already been added")
-        false -> Peers.broadcast_tx(tx)
+        true -> Logger.info(" This transaction already has been added")
+        false -> Peers.broadcast_to_all({:new_tx, tx})
       end
       {:reply, :ok, updated_pool}
     else

apps/aecore/lib/aecore/utils/serialization.ex

@@ -4,6 +4,8 @@ defmodule Aecore.Utils.Serialization do
   """
 
   alias Aecore.Structures.Block
+  alias Aecore.Structures.Header
+  alias Aecore.Structures.TxData
   alias Aecore.Structures.SignedTx
 
   @spec block(%Block{}, :serialize | :deserialize) :: %Block{}
@@ -13,16 +15,16 @@ defmodule Aecore.Utils.Serialization do
       prev_hash: hex_binary(block.header.prev_hash, direction),
       txs_hash: hex_binary(block.header.txs_hash, direction)}
     new_txs = Enum.map(block.txs, fn(tx) -> tx(tx,direction) end)
-    %{block | header: new_header, txs: new_txs}
+    Block.new(%{block | header: Header.new(new_header), txs: new_txs})
   end
 
   @spec tx(map(), :serialize | :deserialize) :: map() | {:error, term()}
   def tx(tx, direction) do
     new_data = %{tx.data |
-      from_acc: hex_binary(tx.data.from_acc, direction),
-      to_acc: hex_binary(tx.data.to_acc, direction)}
+                 from_acc: hex_binary(tx.data.from_acc, direction),
+                 to_acc: hex_binary(tx.data.to_acc, direction)}
     new_signature = hex_binary(tx.signature, direction)
-    %SignedTx{data: new_data, signature: new_signature}
+    %SignedTx{data: TxData.new(new_data), signature: new_signature}
   end
 
   def hex_binary(data, direction) do

apps/aecore/test/aecore_pow_cuckoo_test.exs

@@ -5,8 +5,6 @@ defmodule AecoreCuckooTest do
   alias Aecore.Pow.Cuckoo
   alias Aecore.Structures.Block
 
-  @doctest Cuckoo
-
   @moduledoc """
   Unit tests for the cuckoo module
   """

apps/aehttpclient/lib/client.ex

@@ -18,6 +18,10 @@ defmodule Aehttpclient.Client do
     get(uri <> "/block/#{hash}", :block)
   end
 
+  def post(peer, data, uri) do
+    send_to_peer(data, "#{peer}/#{uri}")
+  end
+
   @spec get_peers(term()) :: {:ok, list()}
   def get_peers(uri) do
     get(uri <> "/peers", :peers)
@@ -29,7 +33,6 @@ defmodule Aehttpclient.Client do
     Enum.each(peers, fn{peer, _} -> Peers.add_peer(peer) end)
   end
 
-  @spec get_account_balance({term(), term()}) :: {:ok, map()} | :error
   def get_account_balance({uri,acc}) do
     get(uri <> "/balance/#{acc}", :balance)
   end
@@ -63,17 +66,13 @@ defmodule Aehttpclient.Client do
     end
   end
 
-  @doc """
-  Send newest transactions to a peer
-  """
-  @spec send_tx(tuple(), map()) :: {:ok, map()} | {:error, term()}
-  def send_tx({uri,_}, tx) do
-    HTTPoison.post uri <> "/new_tx", Poison.encode!(tx),
-        [{"Content-Type", "application/json"}]
-  end
-
   def json_response(body) do
     response = Poison.decode!(body)
     {:ok,response}
   end
+
+  defp send_to_peer(data, uri) do
+    HTTPoison.post uri, Poison.encode!(data),
+      [{"Content-Type", "application/json"}]
+  end
 end

apps/aehttpclient/test/aehttpclient_test.exs

@@ -11,9 +11,9 @@ defmodule AehttpclientTest do
   test "Client functions" do
     account = Keys.pubkey() |> elem(1) |> Base.encode16()
     add_txs_to_pool()
-    genesis_block = Block.genesis_block()
+    _genesis_block = Block.genesis_block()
     assert {:ok, _} = Client.get_info("localhost:4000")
-    assert {:ok, genesis_block} = Client.get_block({"localhost:4000",
+    assert {:ok, _genesis_block} = Client.get_block({"localhost:4000",
       "C061E48A6F7FB2634E0C012B168D41F4773A38BD9E5EA28E5BE7D04186127BA0"})
     assert {:ok, _} = Client.get_peers("localhost:4000")
     assert Enum.count(Client.get_account_txs({"localhost:4000", account})

apps/aehttpserver/config/prod.exs

@@ -12,9 +12,11 @@ use Mix.Config
 # manifest is generated by the mix phoenix.digest task
 # which you typically run after static files are built.
 config :aehttpserver, Aehttpserver.Endpoint,
-  http: [:inet6, port: {:system, "PORT"}],
-  url: [host: "example.com", port: 80],
-  cache_static_manifest: "priv/static/cache_manifest.json"
+  http: [port: 4000],
+  debug_errors: true,
+  code_reloader: true,
+  check_origin: false,
+  watchers: []
 
 # Do not print debug messages in production
 config :logger, level: :info

apps/aehttpserver/web/controllers/block_controller.ex

@@ -15,4 +15,15 @@ defmodule Aehttpserver.BlockController do
         json conn, %{error: message}
     end
   end
+
+  def new_block(conn, params) do
+    ## Becouse we 'conn.body_params' contains decoded json as map with
+    ## keys as strings instead of atoms we are doing this workaround
+    map = Poison.decode!(Poison.encode!(conn.body_params), [keys: :atoms])
+
+    block = Aecore.Utils.Serialization.block(map, :deserialize)
+
+    Aecore.Chain.Worker.add_block(block)
+    json conn, %{ok: "new block received"}
+  end
 end

apps/aehttpserver/web/controllers/new_tx_controller.ex

@@ -4,8 +4,11 @@ defmodule Aehttpserver.NewTxController do
   alias Aecore.Utils.Serialization
   alias Aecore.Txs.Pool.Worker, as: Pool
 
+
   def new_tx(conn, _params) do
-    conn.body_params["_json"]
+    ## Simplest way to convert all keys in map to atoms is to
+    ## encode and decode it again.
+    Poison.encode!(conn.body_params)
     |> Poison.decode!([keys: :atoms])
     |> Serialization.tx(:deserialize)
     |> Pool.add_transaction()