To retrieve a web page, you must first call Erlang’s :inets.start/0; you will want to do this in your init/1 code. Then, simply call :httpc.request(url), where url is a string containing the URL you want. In this case, you will use the server provided by National Oceanic and Atmospheric Administration. This server accepts four-letter weather station codes and returns an XML file summarizing the current weather at that station. You request this data with a URL in the form

http://w1.weather.gov/xml/current_obs/NNNN.xml

where NNNN is the station code.Since this is an Erlang function, you must use a character list enclosed in single quotes instead of an Elixir binary string in double quotes.

If the call to :httpc.request/1 fails, you will get a tuple of the form {:error,information}.

If it succeeds, you will get a tuple in the form:

{ok,{{HTTP/1.1,code,code message},
     [{HTTP header attribute,value},
      {Another attribute,another value}],
     page contents}}

where code is the return code (200 means the page was found, 404 means it’s missing, anything else is some sort of error).

So, let’s say you have successfully retrieved a station’s data. You will then get page content that contains something like this.

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet href="latest_ob.xsl" type="text/xsl"?>
<current_observation version="1.0"
   xmlns:xsd="http://www.w3.org/2001/XMLSchema"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:noNamespaceSchemaLocation="http://www.weather.gov/view/current_observation.xsd">
  <credit>NOAA's National Weather Service</credit>
  <credit_URL>http://weather.gov/</credit_URL>
  <image>
    <url>http://weather.gov/images/xml_logo.gif</url>
    <title>NOAA's National Weather Service</title>
    <link>http://weather.gov</link>
  </image>
  <suggested_pickup>15 minutes after the hour</suggested_pickup>
  <suggested_pickup_period>60</suggested_pickup_period>
  <location>San Jose International Airport, CA</location>
  <station_id>KSJC</station_id>
  <latitude>37.37</latitude>
  <longitude>-121.93</longitude>
  <observation_time>Last Updated on Feb 18 2013, 11:53 am PST</observation_time>
  <observation_time_rfc822>Mon, 18 Feb 2013 11:53:00 -0800</observation_time_rfc822>
  <weather>Overcast</weather>
  <temperature_string>50.0 F (10.0 C)</temperature_string>
  <temp_f>50.0</temp_f>
  <temp_c>10.0</temp_c>
  <relative_humidity>77</relative_humidity>
  <wind_string>Calm</wind_string>
  <wind_dir>North</wind_dir>
  <wind_degrees>0</wind_degrees>
  <wind_mph>0.0</wind_mph>
  <wind_kt>0</wind_kt>
  <pressure_string>1017.7 mb</pressure_string>
  <pressure_mb>1017.7</pressure_mb>
  <pressure_in>30.05</pressure_in>
  <dewpoint_string>43.0 F (6.1 C)</dewpoint_string>
  <dewpoint_f>43.0</dewpoint_f>
  <dewpoint_c>6.1</dewpoint_c>
  <visibility_mi>10.00</visibility_mi>
   <icon_url_base>http://forecast.weather.gov/images/wtf/small/</icon_url_base>
  <two_day_history_url>http://www.weather.gov/data/obhistory/KSJC.html</two_day_history_url>
  <icon_url_name>ovc.png</icon_url_name>
  <ob_url>http://www.weather.gov/data/METAR/KSJC.1.txt</ob_url>
  <disclaimer_url>http://weather.gov/disclaimer.html</disclaimer_url>
  <copyright_url>http://weather.gov/disclaimer.html</copyright_url>
  <privacy_policy_url>http://weather.gov/notice.html</privacy_policy_url>
</current_observation>

This result will be an Erlang character list, so you should use list_to_binary to convert it to an Elixir string.

While it is possible to use Erlang’s xmerl_scan module or the erlsom module (http://erlsom.sourceforge.net/erlsom.htm) to parse arbitrary XML data, the XML returned from the server is sufficiently simple (and sanely formatted) that you can use regular expressions to parse the data. The following code will give you the content of an XML element with the specified name, or nil if there is no such element. It works by dynamically constructing a pattern that looks for the opening and closing tags of the element name. The part of the pattern in parentheses means “one or more of any character that is not a less than sign”; because it is in parentheses, Regex.run will return the matched portion as the second item in a list. (The first item is the part of the XML string matched by the entire pattern.)

defp get_content(element_name, xml) do
  {_, pattern} = Regex.compile(
    "<#{element_name}>([^<]+)</#{atom_to_binary(element_name)}>")
  result = Regex.run(pattern, xml)
  case result do
    [_all, match] -> {element_name, match}
    nil -> {element_name, nil}
  end
end

The way I constructed the URL (using <> instead of interpolation) allows you to easily crash the server by handing it a number instead of a string for the station code. Set up a supervisor to restart the server when it crashes. In the following output, the Process.unlink call ensures that the shell, which is also a supervisor, does not kill any errant processes.

iex(1)> c("weather_sup.ex")
[WeatherSup]
iex(2)> {:ok, pid} = WeatherSup.start_link
{:ok,#PID<0.43.0>}
iex(3)> Process.unlink(pid)
true
iex(4)> GenServer.call(Weather, "KGAI")
{:ok,
 [location: "Montgomery County Airpark, MD",
  observation_time_rfc822: "Sun, 06 Jul 2014 13:55:00 -0400",
  weather: "Mostly Cloudy", temperature_string: "84.0 F (29.0 C)"]}
iex(5)> GenServer.call(Weather, 1234)


=ERROR REPORT==== 6-Jul-2014::11:22:52 ===
** Generic server 'Elixir.Weather' terminating
** Last message in was 1234
** When Server state == [<<"KGAI">>]
** Reason for termination ==
** {badarg,[{erlang,byte_size,[1234],[]},
            {'Elixir.Weather',get_weather,2,[{file,"weather.ex"},{line,46}]},
            {'Elixir.Weather',handle_call,3,[{file,"weather.ex"},{line,16}]},
            {gen_server,handle_msg,5,[{file,"gen_server.erl"},{line,580}]},
            {proc_lib,init_p_do_apply,3,[{file,"proc_lib.erl"},{line,239}]}]}
** (exit) exited in: :gen_server.call(Weather, 1234, 5000)
    ** (EXIT) an exception was raised:
        ** (ArgumentError) argument error
            :erlang.byte_size(1234)
            weather.ex:46: Weather.get_weather/2
            weather.ex:16: Weather.handle_call/3
            (stdlib) gen_server.erl:580: :gen_server.handle_msg/5
            (stdlib) proc_lib.erl:239: :proc_lib.init_p_do_apply/3
    (stdlib) gen_server.erl:190: :gen_server.call/3

iex(5)> GenServer.call(Weather, "KCMI")
{:ok,
 [location: "Champaign / Urbana, University of Illinois-Willard, IL",
  observation_time_rfc822: "Sun, 06 Jul 2014 12:53:00 -0500",
  weather: "A Few Clouds", temperature_string: "83.0 F (28.3 C)"]}

See a suggested solution in Appendix A.

The first module, Chatroom, will keep as its state a list of tuples, one tuple for each person in the chat. Each tuple has the format {{userName, userServer}, pid}. The pid is the one that GenServer.call receives in the from parameter; it’s guaranteed to be unique for each person in chat.

The handle_call/3 function will accept the following requests.

The other module, Person, has a start_link/1 function; the argument is the node name of the chat room server. This will be passed on to the init/1 function. This is stored in the server’s state. I did this because many other calls need to know the chat room server’s name, and keeping it in the person’s state seemed a reasonable choice.

For extra credit, the state will also include the person’s profile, which is a list of {key, value} tuples.

The :handle_call/3 manages these requests:

Because the chat room server uses GenServer.cast/2 to send messages to the people in the room, your handle_cast/3 function will receive messages sent from other users in this form:

{:message, {from_user, from_server}, text}

Here is what the chat room server looks like. Most of the output you will see is debugging output. I have gotten rid of the startup lines from the iex command.

iex --sname lobby

iex(lobby@localhost)1> c("chatroom.ex")
[Chatroom]
iex(lobby@localhost)2> c("person.ex")
[Person,Person.State]
iex(lobby@localhost)3> Chatroom.start_link
{:ok,#PID<0.56.0>}
Steve sales@localhost logging in from #PID<10982.46.0>
David engineering@localhost logging in from #PID<10983.46.0>
Michele marketing@localhost logging in from #PID<10984.46.0>
iex(lobby@localhost)4>

And here are three other servers talking to one another and setting profile information.

iex --sname sales

iex(sales@localhost)1> Person.start_link(:lobby@localhost)
{:ok,#PID<0.46.0>}
iex(sales@localhost)2> Person.login("Steve")
"Sent login request"
iex(sales@localhost)3> Person.set_profile(:city, "Chicago")
{:ok,"Added city/Chicago to profile"}
David (engineering@localhost) says: Hi, everyone.
iex(sales@localhost)4> Person.say("How's things in Toronto, David?")
"Message sent."
Michele (marketing@localhost) says: Product launch is next week.
iex(sales@localhost)5> Person.say("Have to leave. Bye, everyone.")
"Message sent."
iex(sales@localhost)6> Person.logout
{:ok,"Steve@sales@localhost logged out."}

iex -sname engineering

iex(engineering@localhost)1> Person.start_link(:lobby@localhost)
{:ok,#PID<0.46.0>}
iex(engineering@localhost)2> Person.login("David")
"Sent login request"
iex(engineering@localhost)3> Person.set_profile(:city, "Toronto")
{:ok,"Added city/Toronto to profile"}
iex(engineering@localhost)4> Person.say("Hi, everyone.")
"Message sent."
Steve (sales@localhost) says: How's things in Toronto, David?
Michele (marketing@localhost) says: Product launch is next week.
Steve (sales@localhost) says: Have to leave. Bye, everyone.
iex(engineering@localhost)5> Person.users
[{"Michele",:"marketing@localhost"},{"David",:"engineering@localhost"}]

iex --sname marketing

iex(marketing@localhost)1> Person.start_link(:lobby@localhost)
{:ok,#PID<0.46.0>}
iex(marketing@localhost)2> Person.login("Michele")
"Sent login request"
iex(marketing@localhost)3> Person.set_profile(:city, "San Jose")
{:ok,"Added city/San Jose to profile"}
David (engineering@localhost) says: Hi, everyone.
Steve (sales@localhost) says: How's things in Toronto, David?
iex(marketing@localhost)4> Person.say("Product launch is next week.")
"Message sent."
iex(marketing@localhost)5> Person.users
[{"Michele",:"marketing@localhost"},{"David",:"engineering@localhost"},
{"Steve",:"sales@localhost"}]
iex(marketing@localhost)6> Person.who("Steve", :sales@localhost)
#HashDict<[city: "Chicago"]>
Steve (sales@localhost) says: Have to leave. Bye, everyone.

See a suggested solution in Appendix A.