[Code/Racer: Installing Socket.io]

So far we've been able to get node up and running,

creating a just basic web app that's able to serve different pages.

We have some of our views over here, like our index.eco,

and they are serving some just very basic files right now.

If we go to our browser, we can see if we just visit the root here,

we have a page with some dynamic content in it.

The next thing I want to do make sure that this game is going to work

is figure out a way for the players to communicate with each other.

Because we have a game and there's a lot of stuff going on,

We need to make sure that every time a player takes an action

that that action is sent up to the server so the server can process that move

or the change or the update in the game state as well as notify all the other players

who are playing in that game so everybody can stay in sync as to what's going on.

As people are typing, we want to be able to send updates about what they've typed,

so other people can see what they've typed.

If we win a round, we need to send a notification from that player to the server,

and that server needs to be able to push down information to all the other clients,

saying that the round is over or this player has one or a weapon has been used

or some other action.

Now, in typical web applications, we worry about just request and response,

meaning that the only way communication can really happen

is when the browser makes a request on the server and the server responds.

If the server has information it wants to push out to one of the actual clients or browsers,

it can't really do that.

It doesn't have a way in a normal HTP environment to push information down.

It just has to wait for one of the clients to make a request.

Then it can give us an update.

But we need something more real time.

We need a way for our server to send out information.

That's where web sockets come in handy.

We're going to be using a tool called "Socket.IO" to handle this.

You can find out more information at Socket.IO,

and there are some good examples here.

It's pretty simple to set up. There are two parts of it.

There's a server component, which will actually handle all of the clients who are

connecting over this socket, and then on the browser there's a piece of JavaScript

where each of the clients has the actual way to communicate to the server.

The way it works is when the client loads a page

they'll open up a socket, and our server is going to receive that call from a socket,

and it's going to hold that line open.

As long as the server has that socket connection and the client is still listening to it,

the server can send information down to the browser that the browser can then handle.

Now we have pretty much what's like a phone call.

Both the client and server are able to communicate with each other whenever they want

as long as that Socket connection or phone call is open.

Let's see how easy it is to get Socket running in our application.

Right now we have our server running, which we started up with supervisor server.coffee.

Now I'm going to stop our server, because we're going to be updating our package.jsan file,

which defines the dependencies of our application.

I'm going to flip back here and open up our package.jsan.

We can see the dependencies we're using right now, coffee-script for our coffee script compiler.

"Express" is our server, "eco" is our template,

and we're using a middleware called "connect-less" to handle the lessCSS that we use.

To add another dependency, what I'm going to do is I'm just going to add "socket.io."

That's the name of the package.

Notice I added a comma on the line before because we need to have commas

between each of our dependencies.

As the value of this, again, I'm going to use star.

I don't know what the current version of socket.io is,

but right now I'm just going to use the latest.

Before long we'll go ahead and actually add the real version numbers,

so we can have a slightly better definition of what our dependencies are,

and we don't have to worry as much about it break if one of these libraries updates

and makes some sort of change.

But for now the star will work, because we're going to just work with whatever the latest version is,

and then we'll lock it down later.

I'm going to save the package.jsan, and then to add this dependency into our project

from our Code Racer directory, I'm going to run, once again, npm install.

Now node has installed socket.io and all of its dependencies,

so we're able to require socket.io from our application.

I'm going to just start up our app again by typing in supervisor server.coffee.

Remember, supervisor is the application we're using to restart our application

every time we either save a file or whenever the application crashes

because of an error.

Supervisor will keep our app up and running so we don't have to keep coming

back to the terminal to stop and restart it for new code changes.

We start it up, and we get our console.log message saying our server is listening.

We should be able to flip back to our page and refresh,

and we still get our special title.

Now, the way we set up our socket.io server is we need to initialize a socket.io server,

and there are two different ways we could do this.

We could create special socket.io server and have it listen on its own port,

but socket.io is also compatible with Express, which is our web server.

We can actually have socket.io hook into our existing Express app,

which we have in our app variable here.

It will attach all the functionality to our server that we already have up and running.

What I'm going to do is I'm going to store our socket.io instance into a variable called "io."

The way we get that is we will require socket.io,

and this imports the socket.io object.

What we can do is call the dot-listen method that socket.io provides.

If we were starting up our own server, we could just do something like port 4000,

and it would server the server on port 4000.

But since we want to hook it into an existing Express application,

instead of passing in a port number, we'll pass our actual application.

Now socket will know that we have an express application

and we'll be able to listen for socket connections that come

over our normal connection here on port 3000

as well as it serves a couple extra pages, including the client JavaScript file that we need.

If I save it out, we should see our server has restarted, because I saved the file,

and if we go back to a browser and refresh we don't see any changes.

The one way we can test is to see if it's serving the socket.io client file

that we're going to need to include in our page to actually communicate with our server.

We can check this out, and the place that it will serve this file is from /socket.io/socket.io.js,

and if we pull that up, we can see the socket.io now is hooked into that URL.

When we request it, it'll return the JavaScript file that defines the client of our application.

So what we need to do next is to include this into our page.

I'm going to keep working on our demo page that we have in our index.eco.

We will go back over here, and remember index.eco right now is just the inside of our page.

What we actually want to modify is layout.eco,

and this is where our head tag is where we have our style sheets

and where we can put our script files.

What I'm going to is I'm going to create a script tag,

and the source of it will be that URL that we were talking about before--

/socket.io/socket.io.js.

Close the script tag, and we got it .

If we go back to our browser and we go back to our home page, not much has changed,

but I'm going to open up my JavaScript inspector here,

and we can actually see that one of the scripts is loaded up as socket.io.js.

We can test it out by typing "io," which is where it stores all of the information.

We can do io.connect, and this is the call that will actually connect from our client to our server.

This is like making the phone call or the connection from our browser to our server.

If we do that, we can see in our debug here

we see our server is listening. This is the last time we restarted our server.

We can see that it's also telling us how it serves /socket.io.js,

so it's giving us some information there.

All this information is coming from socket.io.

Since it's hooked into our server, it's able to handle requests that it's going to handle,

mostly things as /socket.io, and we can see what's going on with our socket.

We see that we got our client authorized, which means we did a connect call,

and it got authorized, and there is even a handshake to make sure the server and client

are all synced up and ready to talk to each other.

Now, we can see some more information about how it's actually

handling the information back and forth.

We can see that there's a heartbeat interval, which is being sent by the server

or being checked by the server to make sure that our clients are still connected.

A lot of this we can ignore as we develop, but it's a good log of what's going on with connections.

Basically, just by doing that one connect call we had a handshake,

we're getting some heartbeats here just to make sure that we're up and running,

The next step that we're going to do is actually work on communicating

back and forth from the client and the server.