Building a Basic RPC Server and Client with Go

Key Takeaways

hey guys my name is tensor welcome to another go tutorial video today we're going to be looking at how we can create an RPC server our PC stands for a remote procedure call and essentially it's exactly what it sounds like basically we want to make it so that a external computer can call to our program interface and execute various pieces of our code before we actually build this server though let's create a basic crud application for this application let's first start out by creating an item struct this is just a nondescript data type that we're going to use in our crud application it has two fields a title and a body both of which are strings we can then use this item struct to create a makeshift database by just creating a slice of item type in memory so first let's start by creating the read function and we'll make it so that we can read through our database by getting the items by their names so the function will take in a string and then it will return the corresponding item we want to create a variable which will be our get item this would be the item that we're pulling out of the database and then we can use a for loop to iterate through the values in the database and as we're iterating through our database we'll just check to see if the value title is equivalent to the title string that we're passing in here and if it is then we just take that value and we assign it to our get item item and then finally at the end of the function we just return the get item variable now let's build our create function this will just take in an item and then it will pass back an item and the idea is that we pass in the item and then it gets put into the database and then we just return the item so that we know which item we've added to the database so all we have to really do here is append our database with the item and then return the item from the function now let's create a function called add item it just takes in an item and then it outputs an item and we essentially just penned that item to our database and then returned the item from the function that way we know which item we've just added to the database to create our edit item function we want to pass in the title of the item that we want to get from the database and then we also want to pass in a new item that we want to replace the old item with and of course like with our other functions we'll return an item from this function we can iterate through the database using range this time we'll grab the index and then the value and again we'll check to see if the values title is equal to our edit items title if it is we'll grab the item by its index and we'll set in the new edit item which will replace the original item and then we'll set that edit item into this changed variable so that we can return it from the function now let's create a delete function so this just takes in an item and then it will return the item that gets deleted without delete function will iterate through the database grabbing the index and the value and then we'll check to see if the title and the body are equal to the item that we're pulling out of the database and to remove the item from our slice we can just use the append spread operator and we can take the database all the way up to the index and then the database from after the item that we want to remove all the way to the end so this actually just creates a new database without the item that we want to remove then we can take the item that we're passing through this function put it into this elite variable and then return it from the function now inside of our main function let's do some test operations though first let's print out the initial database which will be empty then we can create three items and add them to the database and then print out the database yet again and we'll delete the middle item which is second a second item and then of course print out the database then we'll go ahead and edit an item which will be our third item and to edit the item we just pass in the title in the item that we want to edit followed by the item that we want to replace this item with and then we'll print out the database after that and then finally we'll use our get function to get the new item and then the original first item and then we'll print the two out here's what it looks like if we run this in our command prompt you can see our initial database is empty and our second database has three different objects inside of it and our third database has only two objects because we deleted the second one and then our fourth database has two objects in it because we've changed the third one and then finally we print out those two items by getting them from the database so this application suffice --is as a crud application now what we essentially want to do is make it so that we can call all of these functions remotely using the RPC library the net RPC library in go kind of stipulates that the functions need to satisfy various different criteria firstly the functions need to be a method so none of our functions satisfy this criteria because all of them are functions not methods these functions all need to be exported which means they all need to have uppercase letters which all of our functions do adhere to functions need to have two arguments both of which are exported types and this of course includes built-in types as well so the get by name function for instance can't be called as an RPC because it only has one argument our Edit item function does fit this however because it takes in a string and it also takes in an item and the item is exported because it's an uppercase letter for the structure the next stipulation however kind of excludes all of our functions and that is that the second argument for the function must be a pointer the final stipulation is that the return type for our functions for the RPC functions needs to be an error so now let's go ahead and shape our functions so that they all fit these criteria and to make this work we'll define a new type called API which will be just an integer and what we can do with this API type is we can use it to essentially elevate all of our functions to methods so they'll all be methods on this API type so first with our get by name function we'll turn it into a method by adding the receiver for the API pointer next we do need to change the arguments for this function however because it doesn't have to and because the second one isn't a pointer now the idea is that the first argument represents the argument which were passing through by the color and then the second argument represents the results of calling this function so the second argument is the result that we're returning to the client that's calling to this API so in the case of our get by a name function we'll keep the first argument as the title string and then we'll have a second argument which will be a reply and it will be a pointer to an item type we also need to make sure that the return type for this method is an error type so we'll go ahead and do that and you'll see that of course we'll get an error down here because it's returning an item now the reason why we want an error type to be returned is because if an error type gets returned from this function then that means that the RPC will not send back any data to the caller on the outside this method follows the RPC stipulations that we talked about before but of course we do need to change the internal logic so that it makes sense with this new method signature we can do this rather easily for this particular function by simply taking our reply pointer and setting it equal to the get item variable which we have here so essentially we iterate through the database we find the value where the title string is equivalent to that value we put that into this item variable and then we pass it back to the color through the reply argument and also because we're not really concerned about errors in this particular tutorial we'll just return nil which satisfies the error type return type for this method now let's modify our add item function so we need to add the receiver for the API type and then of course we need to edit the signature so that it has two arguments the item that we want to add to the database and then the reply which will be the item that we've added to the database and then finally of course we need this to return an error again this is fairly simple we just add a new line where we take the reply pointer and we set it equal to the item that's being passed into this method and then of course we return nil for the Edit item method we need to add the receiver then we also need to change the Edit item arguments so that they fit the formula that we've created so thus far we've made it so that we have the item that's being passed by the caller and then they return data so we have a string here and then we have our item that we want to edit instead what we'll do is we'll remove this title string and then of course we'll add our reply pointer and finally of course we want this to return an error so now when we iterate through the database instead of checking to see if the valve title is equal to the string that we were passing through here we can just check to see if it's equal to the Edit title of the item that's being passed through this function and inside of the body we'll take the databases index item and then we'll just create a new item and replace that old item and the new item just takes the Edit items title and body and then uses that to create our new item and of course then we'll grab that item from the database using the index and we'll pass it into our changed variable and like with the other functions before it we can just use the pointer for reply and set that equal to changed and then return nil for the error the delete item function is going to be very similar to the Edit item function or first make it a method of our API type then we need to add a second argument to the method or the reply pointer and then of course we need to return an error in the function body the only thing that we need to change is the return statement and we need to make it so that we take our delete variable and put it into the reply and now all of our methods are ready to be called remotely through our client so let's now create a server inside of the main function so that we can actually connect to these methods first we want to create a new API type so that we can call all the methods on this API type we can just use the new function to do this this variable is important because we want to use it in this RPC register method and that way we essentially register the type so that we can call its methods remotely we can deal with the error that potentially could come from registering this type by just calling wrong fatal and then saying that we got an error registering the API now we want to register an HTTP handler and we can use our PC and/or HTTP to do that then to actually open the connection we want to use net listen and we're going to be opening the connection over our tcp with a port of 4040 of course we can also handle the error that could potentially come from calling this net listen method then finally to serve the listener that we've created here we can just come and call HTTP served passing our listener and then narrow for the second argument and then we'll handle the errors for that as well and we'll print out above it that we're serving our RPC on poor 4040 if we go into our command prompt you can see that this actually runs and it says that we're serving the RPC on port 40 40 now let's go ahead and create a client application so that we can access the RPC so I've got a folder here called client and then I'm gonna just create a main guy go file inside of it and of course this is its own application so it will be also a package main with a main function in this file we do need to define the item type because this is the type that we're going to catch they're receiving data with where larger applications it's more common to actually share the types by creating some kind of library that you can depend on for both the server and the client but in our case we'll just recreate the type here that way we won't run into any problems inside of our main function let's create a reply item and then we'll create a makeshift database which will be a slice of items now we can go ahead and Dow into our RPC by calling RPC Dao HTTP passing in the type which will be TCP and then passing in the address which will be localhost 4040 this will give us back the client and then an error potentially so we need to handle that error now like with before when we were just running everything locally let's go ahead and create a few items that we can manipulate between our client and our server and then to actually execute the methods from our client we can use this client call method and we want to pass in a string representation of the method that we want to execute followed by the two arguments for the method so here I'm calling the add item method with our a item inside of it and I'm doing it again 4b and 4c and then I'm also using the reply item which we created up here as our return statement for each of the items that were passing to the server we get back item in this reply reference unlike our local program however we can't directly access the database to actually see if these items were pushed into the database now let's go back into our server and create a function which will allow us to Rab the database through the client this method is actually pretty basic notice I've put in a first argument even though we don't really need one that's because the general structure for this function needs to have a first argument regardless so I just put in a title string though we don't really need to pass anything to this function instead what just happens is it grabs the database and then it passes it to the reply pointer which then sends it back to our client so now in this case I can call client dot call from our client application and I can specify that I want to call the get DB method on API passing an empty string for the title argument and then use a reference to the database variable which I created up here to catch the result of calling this function and now we can just print it out like we were doing before so that we can actually see what is inside of the database just an FYI - you guys I kind of messed up here I messed up in that I forgot to export both of the fields for the item structure and when you run the RPC client it will just get back no data you also have to do the same thing inside of the client structure so both of these structures need to be completely exported so just make sure that everything is capital in your structure now we can go ahead and run our server so you can see here it's serving on port 40 40 and then if I come into another terminal and go into the client folder I can go ahead and run the main dico file in there and the result of running the client is to actually get back the database as you can see here we get back all the items that we created in our client we get our first a first item second a second item in 33rd item and they're all now inside of the database on our server as well and actually to further demonstrate this point if I go ahead and run the client again you'll see that these items will actually double up and as you can see now we have six items inside of our quote unquote database of course if you were using a proper database you would have some kind of way to replace items so you wouldn't really have to worry about this and you probably wouldn't be directly passing items in in this way at the very least now we also want to activate the other methods that we created so that we can edit and delete and read our various items from our database so let's go ahead and call to our Edit item method now currently with our Edit item method the way it's set up we can't actually change the title of an item that's already in the database because we go and we search through the database for this particular item so when we go to call this item from our client we can only just change the body so in this case what I'm going to do is modify the second item and just have it say a new second item rather than a second item then after we edit the item will call API delete item and we want to delete our see item so the third item and again we'll get the database and then we'll print out the database and then finally we'll call our API get item by name and we'll pass in the string first so it will go and get the first item and then we'll print out that final reply so let's go ahead and spin up this server and then we can go and run the client and as you can see here we have our initial database which has the three initial items in it then we have our second database which has the edited second item inside of it and the third item is removed from it and then finally we have the first item which we pulled out of the data base which just says first a first item alright guys well I hope you enjoyed this tutorial if you did feel free to like and subscribe if you have any questions or comments feel free to leave them in the box below and if you just like this video then by all means download it as much as you like have a good night