-module(client).
-export([register/2, register/3, login/3, list/0, handle/2, getVotes/0, vote/2, devote/2, mass_register/1]).
checkLogin(Value) ->
%% check if user meets the requirements to be logged in or not by
%% logging in to the registered processes and checking if the cli
%% process is registered
LoggedIn = lists:member(cli, registered()),
if LoggedIn == Value ->
true;
true -> throw({error, login_state})
end.
buildNode(Server) ->
%% build the node string of the server by using the hostname
list_to_atom("distributed_music_system_main_node@" ++ Server).
rpc(Server, Params) ->
%% shortcut for sending something to the dispatcher on the server
{dis, buildNode(Server)} ! {self(), Params}.
register(Server, Name, Password) ->
%% check if client is not logged in (if client is logged in,
%% register/2 should be used)
try checkLogin(false) of
_ ->
%% register a new user account on the server
rpc(Server, {register, {Name, Password}})
catch
{error, login_state} ->
{error, logged_in}
end,
%% wait for response
receive
{_, Msg} ->
Msg;
Why -> Why
after 3000 ->
%% protect from waiting endless for server response (maybe
%% if used wrong hostname or something like that)
{error, timeout}
end.
login(Server, Name, Password) ->
%% load common/server (used by server and client)
code:purge(server),
code:load_abs("../common/server"),
%% check if client is not logged in (if client is logged in, it
%% would make no sense to login again)
try checkLogin(false) of
_ ->
%% login to the server
rpc(Server, {login, {node(), Name, Password}}),
receive
%% the server returns the Pid of the process on the
%% client, that should handle the communication
%% between server and client, the process is started
%% by the server on the client node and registered
%% here as cli process
{ok, {ok, {logged_in, Pid}}} ->
erlang:register(cli, Pid),
{ok, logged_in};
{_, Msg} ->
Msg;
Msg ->
Msg
after 3000 ->
%% protect from waiting endless for server
%% response (maybe if used wrong hostname or
%% something like that)
{error, timeout}
end
catch
{error, login_state} ->
{error, logged_in}
end.
send_to_server(Cmd, Server) ->
%% generic helper function for sending a message to the given
%% server and wait for a response from the server (the function
%% returns a tupel of the reponse and the server)
Server ! Cmd,
receive
{ok, Msg} ->
{Msg, Server};
Msg ->
{Msg, Server}
end.
%% the handle functions are called from the process started by the
%% process started by the server on login and registered as cli
handle(list, Server) ->
send_to_server(list, Server);
handle(get_votes, Server) ->
send_to_server(get_votes, Server);
handle({vote, Artist, Title}, Server) ->
send_to_server({vote, Artist, Title}, Server);
handle({devote, Artist, Title}, Server) ->
send_to_server({devote, Artist, Title}, Server);
handle({register, Name, Password}, Server) ->
send_to_server({register, Name, Password}, Server);
handle({change_state, NewState}, _) ->
%% change the state of the server (used from the client process on
%% the server to set the process id, so that the client could send
%% messages directly to the server
{{ok}, NewState};
handle(Cmd, Server) ->
%% fallback to return a error message for not existing commands
{{error, {unknown_command, Cmd}}, Server}.
try_logged_in_rpc(Rpc) ->
%% helper function that tries to execute an rpc for logged in user
%% and returns error message if user is not logged in
try checkLogin(true) of
_ ->
server:rpc(cli, Rpc)
catch
{error, login_state} ->
{error, not_logged_in}
end.
list() ->
%% request the playlist from the server
try_logged_in_rpc(list).
getVotes() ->
%% queries the server for the current votes this client possesses
try_logged_in_rpc(get_votes).
vote(Artist, Title) ->
%% positive vote, increments the votes for {Artist, Title} by one
try_logged_in_rpc({vote, Artist, Title}).
devote(Artist, Title) ->
%% negative vote, decrements the votes for {Artist, Title} by one
try_logged_in_rpc({devote, Artist, Title}).
register(Name, Password) ->
%% register a new user (used by the admin)
try_logged_in_rpc({register, Name, Password}).
mass_register(Count) when Count > 0 ->
%% mass register some user with some simple password
case try_logged_in_rpc({register, "User" ++ integer_to_list(Count), "User" ++ integer_to_list(Count)}) of
{ok, _} ->
%% if creation was successfull, create next user
mass_register(Count - 1);
Why -> Why
end;
mass_register(_) ->
{ok}.
