Welcome to the tutorial, the Headless Client plugin. For Server University, this is Scott Butler. In this tutorial, we're going to go through how to use the Headless Client plugin. If we check out our plugins list down in the bottom left, we can see Headless Client is one of the plugins available. The Headless Client allows you to open up a Headless Client on the server, so a Headless Client is essentially a virtualized client running in memory server side. Using the Headless Client plugin, you can communicate back and forth with the Headless Client. Essentially, this allows you to execute code server side. I've built a little sample here with a couple of functions that we're going to walk through. The first step that we have here is the Headless Client call. What we're doing is creating a new Headless Client object. You can see I'm setting JS Client equal to plugins.headlessclient.createclient. I need to tell that what solution I wanted to open. Then there's some additional arguments for the username, password, and startup arguments. My example, it's pretty simple. No username or password, and no arguments needed. Also notice, I've declared this as a JavaScript variable because I haven't used the keyword BAR in front of it. I'm going to be able to access this client later in my code. Then we check to make sure the client exists and it's valid. Then we call it to QA method. When you call Q method, that means we wanted to essentially execute a method. It's called Q because it's possible that the Headless Client can already be executing a method. It's going to go ahead and add it onto the end of the stack. If we actually take a look at that call here underneath of Q method, we can see what the arguments are. There's context. If we're going to use a global method within the use null, otherwise we could pass in the form context. There's the method name. Notice that you're just passing in the method name as a string. This would execute the Headless receiver global method. There's arguments that you want to pass and then finally the callback function. Notice that the callback is actually a function object. We're passing in the function itself without the extra parentheses. What's going to happen is it's going to tell my Headless Client that I want it to run the Headless receiver method and then I want the callback to be the Headless callback. Headless receiver, all we're doing is adding two numbers together and then we're returning that result. My Headless callback were checking the event information. The event from the Headless Client gets passed in and we're going to check and see if it's just a normal callback event or if it's an error. Puts a normal callback event. We're going to get the result of that using event.data and then we're going to display it. The result of what gets returned from the Headless Client gets passed back in. What you have here is Headless Call runs Client side which then has Headless receiver running server side via the Headless Client plugin which then once it's finished calls back to Headless callback which again is running Client side. So let's test this out. So I'm going to go under my Methods list and we're going to choose Headless Call and I've got some break points so we can walk through this in the bugger. So we create our Headless Client, we check to see if it's valid and then we queue our method. And since I'm in Developer and I've got a break point on there, you can see it's stopping at Headless receiver. So this would actually be running server side because we're in Developer, it's sort of hard to tell but you'll have to trust me that this is actually running server side. So we're going to return that result back and then that result gets returned into our Headless Call back here and we can check and see that it was actually a callback event and we get the result and then we display it and I can see it's added those two numbers that we passed in so it added one and two together and then we're going to shut it down. Now if there were any kind of error that happened in the solution or in that Headless Call, it would call back into this function. So for example let's say I purposely mistyped this parameter. So I forget that I needed an underscore in front of it. So let's go ahead and run that again. So we're going to step through that, going to run our call here but now you can see it skips past the callback event because now it's actually an exception event and so I can display here what the exception was and then I'm shutting down the client. Notice that again I'm able to shut down this client because JS client is a JavaScript global. So as you can see in this example you're able to put in whatever kind of code you want to run here server side. That was also additional options with this JS client node. So instead of just queuing methods you can also do things like set a data provider value and get a data provider value. You can also get the client ID. This is useful because back if we take a look under the Headless client node, instead of creating a new client we also have the option of getting a client. So if we know what the client ID is then we can get it. So let's show an example of how to use that. So let me take off these break points here. And in our example we're going to take a look at how to do a round robin set of headless clients. So instead of just starting up a headless client every single session and shutting it down when it's done we're going to set up a pool of headless clients. So let's go ahead and create some global variables that we need to get this started. So the first variable is going to be our pool size. And I'm going to set that equal to 3. So I'm going to allow for up to 3 clients running server side in the pool. The next thing I'm going to do is to create another variable and this is going to be of type media because this is going to actually hold my sessions. So this will be the we'll call it the pulled clients. And instead of letting that be null we're just going to set it to a new object. So that we initialize it right away. Next we need to create another variable that's going to hold where we are in our pool. I'm just going to call that pool I so that will be the first one. Be the first one and we'll start it off at zero. So now let's come in here to our headless client call and let's modify this code a little bit. So first we need to figure out where we are in our pool. So we're going to do that using the module operator. So we'll do the current headless client index is going to be equal to wherever we are in our pool. So we'll do global's dot pool I module O global's dot pool. So essentially that will get us the remainder. So if you think about a round robin so it will go zero one two and then it will come back up zero one two because that's our pool size there. So then we're going to check and we want to check to see if we've already got a headless client in this index. And so we'll say if and that's reference our pooled clients and we use the current index here. So we're going to check and see is there a headless client already in our array of pooled clients and of course we need to actually check and see if that headless client is valid. And we're actually going to check and see if it's not valid. So what we're saying here is if we don't have a client there or it's not valid then we want to run this specific code. So what we're actually going to do is create a new headless client here. And we're going to set it inside of our array. So we've got this global media object that we're using as an array. And if there's not a headless client already in that index then we're going to go ahead and actually create a new headless client for us to use later. And just for easier coding care I'm going to set a little variable equal to my headless client. So at this point I know I have a headless client object because if I didn't have one already then it went ahead and made one for me. So now we can use that other line of code and we're going to go ahead and queue the method. And since we want this to run as a pool we're going to take off the shutdown. And of course we want this to be round robin. So we need to go ahead and increment our global variable. So let's go ahead and test this and see how it works. So we'll launch our debug client. And we'll go up to methods and we'll run our headless call. So we'll start stepping through this. We'll get our headless client index first. So let's see what the value of that is. Of course it's zero since it's our first time pure. And we don't have a headless client in there. So we're going to create a new one. And then we're going to get that handle back from our pool. And we're going to queue the method and increment our object. And we can see that it did the addition and return back three. Let's actually run it again now. You can see that we're at position one. And as we start stepping through that, of course we need to make a new headless client. And it returns it again. Let's run it a third time. So we have a pool of size three. So you can see what this is going to do is check to see if we have a headless client object in that pool. And that array index, if we do, it's going to go ahead and just grab it and queue the method. Otherwise we're actually going to have it start up a new method. So this allows our client to have three headless clients sitting there on the server so they can have each of them run their own methods. So if you have a bunch of methods that are really long time to run, now you can utilize multiple headless clients on the server.