Erlang/OTP Forums

% ticker.erl:

-module(ticker).
-behaviour(gen_server).
-behaviour(supervisor).
-behaviour(application).

% needs to be removed in the future, presently only for debugging purposes.
-compile(export_all).

-export([init/1, code_change/3, handle_call/3, handle_cast/2, handle_info/2,
  terminate/2, start/0, start/2, stop/1]).

% start off here. We'll create a new method and register it to an atom.
start() ->
  start(ticker, [?MODULE]).

start(Name, Mod) ->
  register(Name, spawn(fun() ->
                           loop(Name, Mod, Mod:init())
                           end)).

init([]) ->
  % note we must set trap_exit = true if we want terminate/2 to be called when
  %   the application is stopped.
  process_flag(trap_exit, true),
  io:format("~p starting~n", [?MODULE]),
  {ok, {{one_for_one, 3, 10},
    [{tag1, {area_server, start_link, []}, permanent, 10000, worker, [area_server]}]}}.

% this is an in-between function. It's job is to create a custom tuple, to be
%   passed down to the rpc method, which will send a message to a process
%   asking it to hot-swap code.
swap_code(Name, Mod) ->
  rpc(Name, {swap_code, Mod}).

print_output(Stock, Price) ->
  io:format("Stock: ~s Current Price ~w ~n", [Stock, Price]).

% all this thing does is send a message to a process and waiting for a reply.
rpc(Name, Request) ->
  Name ! {self(), Request},
  receive
    {Name, Response} ->
      Response
    end.

% this is the function through which we will constantly iterate, it'll be the
%   heart of this process.
loop(Name, Mod, OldState) ->
  receive
    {From, {swap_code, NewCallBackMod}} ->
      % if received request to swap code, then simply send back a response
      %   saying that you did so and start using the new module.
      From ! {Name, ack},
      % What makes this especially cool is that we can continue to use all of
      %   the properties of the old module (dictionary, etc.), but we gain
      %   (lose) new functions without affecting the said properties. So the
      %   values in the dictionary stay the same.
      loop(Name, NewCallBackMod, OldState);
    {UnprocessedMessage} ->
      io:format("~n~n******* UNPROCESSED MESSAGE *******~n ~s ~n~n",
        [UnprocessedMessage]);
    % the only reason why this message is here is so that the stupid warning
    %   message about Mod will go away. It's necessary to have it for the
    %   moment, but there's just no work-around without making drastic code
    %   changes.
    {change_stock_price, Stock, Price} ->
      Mod:print_output(Stock, Price)
    end.

% putting _ in front of a variable, gets rid of an annoying warning about the
%   variable being unused.
code_change(_OldVsn, N, _Extra) ->
  {ok, N}.

handle_call(_SomeVal, _From, _N) ->
  null.

handle_cast(_Msg, N) ->
  {noreply, N}.

handle_info(_Info, N) ->
  {noreply, N}.

terminate(Reason, _N) ->
  io:format("~p terminating...~n", [?MODULE]),
  io:format("The reason for the hault is: ~p ~n", [Reason]).

stop(State) ->
  io:format("~p stopping...~n", [?MODULE]),
  io:format("The state of the application is: ~p ~n", [State]).

% net_int.erl: Reads the stock price from somewhere...

-module(net_int).

start() ->
  null.

20> c(ticker).
./ticker.erl:5: Warning: conflicting behaviours - callback init/1 required by both 'supervisor' and 'gen_server' (line 4)
{ok,ticker}

            +-----------+
            |Application|
      +-----|Supervisor |-----+
      |     +-----------+     |
      V                       V
+----------+             +-------+
|Gen Server| <---------> |net int|
+----------+             +-------+