Expertiza_Wiki - User contributions [en]

PeerLogic Web Services: Python Web Service Template

2022-05-10T04:25:27Z

Ggarrid: /* Conclusion */

The purpose of this page is to provide a useful template for creating a new PeerLogic web service, and provide some guided steps in how to modify it for new needs. This template is specifically made for Python 3 web applications.

==Video Walkthrough==
This is essentially a written alternative/supplement to a recorded video walking through the set up of the "AllReviewInterface" service. If you would like a more visual or hands-on demonstration of the information presented here, please check out the following link (or watch the video as you read through this written material): [https://drive.google.com/file/d/15Q5hBXU4umpJN8gStLryo5XdNiy1xZay/view?usp=sharing https://drive.google.com/file/d/15Q5hBXU4umpJN8gStLryo5XdNiy1xZay/view?usp=sharing].

==Foreword: Necessary Tools and Permissions==
Before beginning to create a web service, you will need some tools and permissions. These are:
* '''A way to SSH to a remote server''': you can do this through the "ssh" command on Mac or Linux, or through the PuTTY application on Windows.
* '''A way to send API''': Any will do, but I personally recommend Insomnia, as I find its interface easy to use and good for troubleshooting.
* '''Sudo access to the Peer Logic web server''': You will need sudo access in order to modify the config files to set up the web service. Request this from CSC IT and CC Dr. Gehringer so he can agree to give you permission. In case it needs saying: don't abuse this access, or things will go poorly!

With all of these tools, we can begin to create a web service.

==Template: AllReviewInterface==
The template being used for this tutorial is the "AllReviewInterface" web service. This is a working web service on PeerLogic, accessible at peerlogic.csc.ncsu.edu/allreviewinterface/call_models, which has its functionality limited to a single short python file, making it easy to understand and use. The GitHub for this project can be found here: [https://github.com/peerlogic/AllReviewInterface https://github.com/peerlogic/AllReviewInterface].

To begin with, clone this repository and rename it to the name of the project you intend to create. You should also (whether now or after writing the code) update the README for your project. The README for the AllReviewInterface serves as a good template for the basic information your README should provide (general summary of functionality, the port number and URL to access it from on PeerLogic, and the expected Input and Output with explanations and examples).

==Using Flask==
This application works through utilizing Flask, a Python module which allows your application to accept API requests. As is, you should be able to run the AllReviewInterface program and launch a Flask application. You can then communicate with this application by sending it API (through the tool outlined in the foreword). The AllReviewInterface can be tested in this way by sending its example input (as shown in its README) to "localhost:3013/call_models".

There are two important configuration details to modify within this application: the port number, and the URL route.

The port number is described on line 53 of the AllReviewInterface's "flaskapp.py", under "if __name__ == '__main__':". This determines what port the application is run on, both on your computer and on PeerLogic. Set this to a new, unused port (to see which ports are unused, refer to the configuration spreadsheet here: [https://docs.google.com/spreadsheets/d/1oMYqjaVInPEE4jE7C2iQmOTc0H6BsltnuXXf0UWvuPA/edit?usp=sharing https://docs.google.com/spreadsheets/d/1oMYqjaVInPEE4jE7C2iQmOTc0H6BsltnuXXf0UWvuPA/edit?usp=sharing]).

The URL route specifies the exact route necessary to reach particular code. In the case of AllReviewInterface, there is only one such route, "/call_models", which is specified on line 15 by "@app.route('/call_models',methods=['POST']). When a user accesses this route, the function defined immediately after it (in the template's case, "call_models()") is run. If the method specified is a POST method, the information within that POST can be accessed via flask.request.json. Rename the given route to one that better suits your use case, and feel free to create multiple routes if appropriate in order to have multiple supported methods.

Note that, to return the results of your web service, you must return a flask.Response object, containing the string which is your results. This can be seen in the template by the return statement of call_models(), on line 50.

Replace the code within this template with your own, renaming/reconfiguring the details described above, in order to create your own web service. You can also spread your code across multiple files, so long as the Flask code is contained within the given template file, and that is the file that is run on the PeerLogic server.

==Setting Up a Virtual Environment==
A difficult issue when running Python code is the necessity for packages. In fact, the "flask" package itself is not part of Python's standard libraries, and must be installed manually. While a user can do this easily using the "pip" command, this will not work on the PeerLogic server, as the root user will not have the necessary packages (and we don't want to download them for the root, as it might corrupt the server).

This problem can be alleviated through the use of virtual environments. A virtual environment can essentially be set up and contain all the packages necessary to run an application, without those packages needing to be installed by a user. This makes them great for sending code to be executed by others.

Create a virtual environment for your application using the command:
<pre>python3 -m venv /venv</pre>

This will create a virtual environment in the same directory as your application named "venv". Activate this virtual environment using the command:
<pre>source venv/bin/activate</pre>
(NOTE: this will only work on Unix or Mac. I would recommend installing WSL2 if on a Windows system, as virtual environments are difficult to use in Windows command line)

Now that you are in the virtual environment, attempt to run your application (for example, by using the command "python3 flaskapp.py"). If there are any non-standard packages required for your application (such as flask), you will receive an import error naming the missing package. Install that package using "pip install <package_name>", and continue doing so until you no longer receive errors.

You have now created a virtual environment containing all the packages necessary to run your application, without downloading any onto your personal Python installation. However, you cannot send a virtual environment directly onto the PeerLogic server (it won't set up correctly). Instead, you will want to create a virtual environment on the server itself. You can make this easier by creating a "requirements.txt" file using your current virtual environment. Use this command after you have installed all the necessary packages for your application:

<pre>pip freeze > requirements.txt</pre>

This will export all of the installed packages into a text file. I would recommend going into the text file and removing the version numbers from all of the packages, as this will make them easier to run on the older distribution of Python the server uses (for example, changing the line "flask==2.0.3" to just "flask").

You can exit the virtual environment when you are done using the command "deactivate".

This concludes all of the code and work you need to do to set up the source code for your web service!

==Getting Code Onto The Server==
Once you have completed the above, access the PeerLogic server (see the main documentation page for details on how to do this: [https://expertiza.csc.ncsu.edu/index.php/PeerLogic_Web_Services https://expertiza.csc.ncsu.edu/index.php/PeerLogic_Web_Services]) and navigate to the webservices directory. Once there, clone your repository into the directory using a command like the following:
<pre>git clone https://github.com/peerlogic/<name_of_your_repo></pre>
(Note: if your repository is not currently part of the peerlogic group, change its ownership to the group! This will allow others to edit and upkeep your work in the future)

This will clone over your code onto the server. However, your virtual environment will not be set up. To set it up, navigate to the directory containing your requirements.txt file and use the following command:
<pre>virtualenv --python=/usr/bin/python3.6 /venv</pre>
(note: if this fails, you may need to install the virtualenv package. Do so with "pip install virtualenv" and repeat this step)
(double note: this command is different from the previous because the server runs an older version of Python)

This will set up a new virtual environment. Activate the environment using the prior mentioned command. Now, you can install all of the required packages by simply using the following command:
<pre>pip install -r requirements.txt</pre>

This will automatically install all listed packages. You can then test to make sure your application is working by running "python3 <your_app.py)". If flask successfully launches, congratulations! You have set up your web service! Whenever you are done testing, you can leave the virtual environment using the command "deactivate".

==Properly Configuring the Server==
A final important note is how to set up the server such that your application is properly set up and run. Doing this will require the server to not simply launch your application, but to first enter its virtual environment, run the application, and then exit the environment.

Upon its daily reboot, the server will run the contents of the file runws_root.sh, located within the webservices directory. Edit this file (through a command such as "nano runws_root.sh") and add a new line for your Flask application. The syntax for this line should be very similar to the existing code to set up the AllReviewInterface application, and should look like the following:
<pre>cd /opt/webservices/<your_application_repo_name>/app/ && source venv/bin/activate && (python3 <your_app.py> &) && deactivate</pre>
To break down what this is doing, the root user will perform the following actions in order:
*navigate to where your Flask application is located
*activate the virtual environment
*run your application with the "&" character, allowing it to run in the background while the root user moves on
*deactivate the virtual environment

It is important to exit the virtual environment at the end, so as to allow the root user to continue doing what it needs to do. With this, the server will now properly run your application at every reboot.

The final step is to set up the route to call your application. Do this by editting NGINX's configuration file, located at /etc/nginx/nginx.conf (for example, using the command "sudo nano /etc/nginx/nginx.conf"). '''Be very careful editting this file!''' If you somehow break it beyond repair, a backup exists in the google drive with all the documentation.

Go down to the bottom of this file and add in a line similar to the following, substituting in the name of the URL path you set up for your application and the port you set up for your application:
<pre>location ^~ /[URL_PATH_TOBE_EXPOSED_EXTERNALLY] {
proxy_pass http://localhost:<PORT_FOR_APPLICATION_YOU_SET_UP>/;
}</pre>

The other existing locations within the file should be reasonable examples.

==Conclusion==
Congratulations! This concludes this tutorial, and this should be sufficient to let you set up and run your own Python Web Service on PeerLogic. Please check out the video walkthrough linked at the top of this page for a more visual demonstration of these steps, and if you run into any trouble, check out this document for some useful troubleshooting tips: [https://docs.google.com/document/d/1oI8TTMW_WzYdsDsWXuT5_3-H8hea3Rq-YWswoLBQ81k/edit?usp=sharing https://docs.google.com/document/d/1oI8TTMW_WzYdsDsWXuT5_3-H8hea3Rq-YWswoLBQ81k/edit?usp=sharing].

I hope you have success with this. Do good work!

PeerLogic Web Services

2022-05-10T04:22:34Z

Ggarrid: /* Documentation and Backup Drive */

=Summary=
The PeerLogic web services are a group of scripts and programs utilized by the expertiza website for performing various functions. These functions are hosted at peerlogic.csc.ncsu.edu and are externally called for the purposes of better performance, flexibility, and modularity.

This page is documenting all of these services, including where they are located, the code they utilize, and theoretical explanations of what they are performing.

The collection of the code for all of these web services can be found [https://github.com/peerlogic here].

==Documentation Videos (Start Here!)==
If you are just starting out accessing the PeerLogic Web Services, a series of videos have been created to explain the general premise of the web services, demonstrate some of the information expressed below, and more. This is a good way to get a general overview of how the Web Services work. To view these videos, click [https://expertiza.csc.ncsu.edu/index.php/PeerLogic_Web_Services:_Videos here].

==Current Status of Web Services==
The status of all currently supported or developed web services can be found at this google sheet (note: this link is editable, as this document should be updated as new services are added or modified. Please edit responsibly!): [https://docs.google.com/spreadsheets/d/1oMYqjaVInPEE4jE7C2iQmOTc0H6BsltnuXXf0UWvuPA/edit?usp=sharing https://docs.google.com/spreadsheets/d/1oMYqjaVInPEE4jE7C2iQmOTc0H6BsltnuXXf0UWvuPA/edit?usp=sharing].

This sheet also notes the ports which are currently used by all services, and the URLs each service is accessible from.

==Getting Started on Updating the Server==
If for some reason, you need to modify, change, or update the code hosted at peerlogic.csc.ncsu.edu, you may follow these steps to do so.

* Submit a request to CSC IT in order to be given access to the server. You can do this by emailing them at csc_help@ncsu.edu and cc'ing Dr. Gehringer so he may verify you have permission to do so.
* Prepare the code you intend to add or modify in a GitHub repository. This will make it as simple as possible to transport your code to the web server. Ensure that your application is set up to run on a currently unoccupied port. The list of currently used ports can be found on the first sheet of the configuration sheet [https://docs.google.com/spreadsheets/d/1oMYqjaVInPEE4jE7C2iQmOTc0H6BsltnuXXf0UWvuPA/edit?usp=sharing linked here].
* Transfer that code over to the PeerLogic GitHub group (if you are not part of the group, join it!) This will ensure anyone in the future will be able to access and modify your code.
* The server can only be accessed from within the internal NCState network. In order to gain this access, create a VCL reservation [https://vcl.ncsu.edu/ here], and SSH or remote desktop into the VCL. For the purposes of this explanation, I will assume you are doing this using Unix for your VCL.
* Now that you are within the network, you can access the server via the SSH command, using your unityid. You will also be asked to provide your password upon connecting to the server. The command to ssh is given below:
<pre>ssh <unityid>@peerlogic.csc.ncsu.edu</pre>
* Navigate to where the web services are located, using the following command:
<pre>cd /opt/webservices/</pre>
* Located here are GitHub repos of all of the web services. If you intend to update an already-deployed service, simply enter the repository for that service and perform the following command to pull the changes:
<pre>git pull</pre>
* Make sure the changes are working by running the new version locally and testing using API (see demonstration videos for more details)
* Make sure the code still works the next day (after the server reset)

==Adding a New Web Service==

===Template and Walkthrough===

If you are just starting out and are willing to work in Python, a web service template has been created with explicit instructions, in both written and video form. It is recommended to use this as your approach unless you have something else specific in mind. To find these resources, click here: [https://expertiza.csc.ncsu.edu/index.php/PeerLogic_Web_Services:_Python_Web_Service_Template https://expertiza.csc.ncsu.edu/index.php/PeerLogic_Web_Services:_Python_Web_Service_Template].

===General Instructions===
* First, clone your remote PeerLogic GitHub repository into the webservices directory under /opt/webservices. This will put the application code onto the server.
* Next, you will need to edit one of the two startup scripts in /opt/webservices: runws_root.sh, and runws_user.sh.
* runws_user.sh belongs to the "railsadmin" user and runs ruby 2.3.0p0. This file should be modified in order to start up any Ruby services.
* runws_root.sh, meanwhile, is run by the root access user, and should be used for any Python scripts or anything needing root access.
* Pick the appropriate script and add the code to start your application within (see the video demonstration for more details on this).
* After doing all this, navigate to and edit /etc/nginx/nginx.conf (you will need sudo access to do this)
* Within this config file, each service is assigned to a unique port on the machine. Your application must be configured to run on one of these ports, and on a port not already in use (please see the spreadsheet to see which ports are already in use).
* To add your application to these url mappings, add this code to the config file, substituting the urls relevant to your service (this is very similar to the already existing mappings within the file):
<pre>location ^~ /[URL_PATH_TOBE_EXPOSED_EXTERNALLY] {
proxy_pass [YOUR_SERVICE_LOCAL_URL];
}</pre>
* Reload nginx to update the changes to the config file and allow the new route to be properly redirected using the following:
<pre>sudo service nginx reload</pre>
* After the next server restart, your service should be automatically started. You can test whether the new service is working immediately by running it yourself, and setting it to automatically run in the background. If you were running a python script, this may be something like the following:
<pre>sudo nohup python3 <your_application_name.py> &</pre>

NOTE: it is highly recommended to watch the demonstration video for setting up a new WebService, particularly if working in Python, which can be viewed at the page linked in the above section, as well as by clicking this link (while logged into your NCState account): [https://drive.google.com/file/d/15Q5hBXU4umpJN8gStLryo5XdNiy1xZay/view?usp=sharing https://drive.google.com/file/d/15Q5hBXU4umpJN8gStLryo5XdNiy1xZay/view?usp=sharing].

=Currently Active Web Services=
For the sake of this section, "currently active" means that these services are currently running on the PeerLogic web server and have known inputs, such that we can get useful results from them. Other web services may also technically be accessible, but may not currently have known inputs.

==IntelligentAssignment==
IntelligentAssignment is a Python application which has the stated purpose of forming project groups by performing k-means clustering on their topics of interest.

This service is currently being used by the Expertiza website for forming project groups.

Please see the extended documentation [https://expertiza.csc.ncsu.edu/index.php/PeerLogic_Web_Services:_Intelligent_Assignment here].

This project was last updated in March of 2018.

The code for this project can be accessed here: [https://github.com/peerlogic/IntelligentAssignment https://github.com/peerlogic/IntelligentAssignment].

==RainbowGraphService==
RainbowGraphService is a primarily JavaScript application that visualizes the results of peer review criticisms.

The RainbowGraphService is actively used by collaborators outside the university for visualizations.

Please see the extended documentation [https://expertiza.csc.ncsu.edu/index.php/PeerLogic_Web_Services:_Rainbow_Graph_Service here].

This project was last updated in March of 2018.

The code for this project can be accessed here: [https://github.com/ferryxo/RainbowGraphService https://github.com/peerlogic/RainbowGraphService].

==reputation==
reputation is a Javascript application with extensive documentation, detailing the web service's use for determining user reputation.

This web service is not currently utilized, though students have recently (in Spring of 2022) created a project to utilize this service on Expertiza.

Please see the extended documentation for this project here: [https://expertiza.csc.ncsu.edu/index.php/Web-services:_Reputation_Web_Service here].

This project was last updated in April of 2016.

The code for this project can be accessed here [https://github.com/peerlogic/reputation_web_service https://github.com/peerlogic/reputation_web_service].

==Peer-reviews-NLP==
Peer-reviews-NLP is a Python-based program which is used to tag student reviews. It does so by performing NLP and identifying features such as the presence of suggestions, problems, and more. Currently, 5 options are known to be functioning and useful: volume, suggestions, suggestions_confidence, problems, and problems_confidence.

This web service is actively utilized by Expertiza for automated tagging of reviews. It should be noted that this service is not run on the PeerLogic web server, but is instead run on the active learning web server, at http://152.7.99.200:5000. Please see the README in the GitHub or the documentation below for more information.

Please see the extended documentation [https://expertiza.csc.ncsu.edu/index.php/PeerLogic_Web_Services:_Peer-reviews-NLP here].

This project was last updated in March of 2018.

The code for this project can be accessed here: [https://github.com/peerlogic/Peer-reviews-NLP].

==AllReviewInterface==
AllReviewInterface is a Python-based service that allows one to send a collection of student reviews to several of the Peer-reviews-NLP services in one function call, returning the results from each.

This web service is not intended for particular use (apart from perhaps being convenient for certain research applications), and was primarily created to serve as a template for future web services.

This project does not have extended documentation, but the specifics of how to create a new web service using it as a template can be found [https://expertiza.csc.ncsu.edu/index.php/PeerLogic_Web_Services:_Python_Web_Service_Template here], and necessary information to run the service can be found in its GitHub README.

The code for this project can be accessed here: [https://github.com/peerlogic/AllReviewInterface].

=Other Documented Services=
Besides the active web services listed above, several other services have existing documentation, despite their currently non-functional state. It is possible these services could be upgraded to "active" if one determined the input they required or fixed the deployment issues they may have.

==AutoSummaryV1==
AutoSummaryV1 is a Javascript application about explaining and summarizing reviews made by students.

Please see the extended documentation here: [https://expertiza.csc.ncsu.edu/index.php/PeerLogic_Web_Services:_Summarization_Service here].

This project was last updated in February of 2016.

The code for this project can be accessed here: [https://github.com/peerlogic/AutoSummaryV1 https://github.com/peerlogic/AutoSummaryV1].

==autometareviews0.1==
This project is a Ruby application for the purpose of natural language processing, including sentiment analysis, volume, tone, etc.

This project was last updated in April of 2016.

The code for this project can be accessed here [https://github.com/peerlogic/autometareviews0.1 https://github.com/peerlogic/autometareviews0.1].

=Legacy Resources=
All prior documentation was originally created by Geoff Garrido in Spring of 2022, to replace and expand upon existing documentation.

The following are saved legacy resources of that prior documentation, in the case that the above documentation is insufficient or more nuanced information about how the PeerLogic server used to run is necessary.

Original PeerLogic web service set up: [https://docs.google.com/document/d/1270jOLqVHV9iojAf9jwd2WJlOr9PNCZChDz1-sEzkhM/edit?usp=sharing here].
NLP Web Service Setup: [https://docs.google.com/document/d/1QAMVLu6whaJ8fSkwxY_Z-Hq7lHwXj40X-_xWd6F-FOM/edit?usp=sharing here].

=Documentation and Backup Drive=
A Google Drive has been created containing all the videos, spreadsheets, presentations, and backups for the PeerLogic web services. It can be accessed here: [https://drive.google.com/drive/folders/1yfCSXfu9NMUyKxIsvIYEQZkVUISVWtwB?usp=sharing https://drive.google.com/drive/folders/1yfCSXfu9NMUyKxIsvIYEQZkVUISVWtwB?usp=sharing].

In particular, because they are not backed up in any form of GitHub repositories (unlike the project code), this Google Drive contains backups of the most important configuration files for the PeerLogic web server: nginx.conf, runws_root.sh, runws_user.sh, and the contents of the cron jobs. Two versions of these files currently exist: the ones containing in their title "fall2021" refer to the state of the PeerLogic Web Services before the work done in Spring 2022 by Geoff Garrido. Those containing in their title "spring2022" refer to the state of the PeerLogic Web Services after the work done in Spring of 2022.

The more recent versions should be used as backups in all cases, unless something about the new versions is wrong, in which case the legacy versions are also provided.

2022-02-22T04:26:54Z

Ggarrid: /* Adding a New Web Service */

=Summary=
The expertiza web services are a group of scripts and programs utilized by the expertiza website for performing various functions. These functions are hosted at peerlogic.csc.ncsu.edu and are externally called for the purposes of better performance, flexibility, and modularity.

This page is documenting all of these services, including where they are located, the code they utilize, and theoretical explanations of what they are performing.

The collection of the code for all of these web services can be found [https://github.com/peerlogic here].

==Getting Started on Updating the Server==
If for some reason, you need to modify, change, or update the code hosted at peerlogic.csc.ncsu.edu, you may follow these steps to do so.
* Submit a request to CSC IT in order to be given access to the server. You can do this by emailing them at csc_help@ncsu.edu and cc'ing Dr. Gehringer so he may verify you have permission to do so.
* Prepare the code you intend to add or modify in a GitHub repository. This will make it as simple as possible to transport your code to the web server.
* The server can only be accessed from within the internal NCState network. In order to gain this access, create a VCL reservation [https://vcl.ncsu.edu/ here], and SSH or remote desktop into the VCL. For the purposes of this explanation, I will assume you are doing this using Unix for your VCL.
* Now that you are within the network, you can access the server via the SSH command, using your unityid. You will also be asked to provide your password upon connecting to the server. The command to ssh is given below:
<pre>ssh <unityid>@peerlogic.csc.ncsu.edu</pre>
* Once you have successfully connected to the server, you will be placed in a directory named after your Unity ID. Navigate up and out of this directory until you reach the top directory level (as far out as you can go).
* Webservices are hosted within the directory opt/webservices, so navigate to that directory to make your changes.

==Adding a New Web Service==

* If your intention is to add a new web service, you will need to edit one of the two startup scripts in /opt/webservices: runws_root.sh, and runws_user.sh.
* runws_user.sh belongs to the "railsadmin" user and runs ruby 2.3.0p0. This file should be modified in order to start up any Ruby services.
* runws_root.sh, meanwhile, is run by the root access user, and should be used for any Python scripts or anything needing root access.
* Pick the appropriate script and add the code to start your application within
* Then, move your service code into a new folder within the /opt/webservices directory. It is recommended to do this by downloading your project from GitHub directly into a directory within /opt/webservices, as sending or receiving files would be difficult due to the SSH stack necessary to access the server.
* After doing all this, navigate back to the top directory and access /etc/nginx/nginx.conf
* Within this config file, each service is assigned to a unique port on the machine. Your application must be configured to run on one of these ports, and on a port not already in use (please see the config file to see which ports are already in use).
* To add your application to these url mappings, add this code to the config file, substituting the urls relevant to your service:
<pre>location ^~ /[URL_PATH_TOBE_EXPOSED_EXTERNALLY] {
proxy_pass [YOUR_SERVICE_LOCAL_URL];
}</pre>
* Once this is done, start your service and set it up to run after you've finished ssh'ing by running the following command:
<pre>sudo nohup python _yourscript_.py &</pre>
* Finally, reload nginx to update the changes to the config file using the following command:
<pre>sudo service nginx reload</pre>

==IntelligentAssignment==
IntelligentAssignment is a Python application which has the stated purpose of forming project groups by performing k-means clustering on their topics of interest.

Please see the extended documentation [https://expertiza.csc.ncsu.edu/index.php/PeerLogic_Web_Services:_Intelligent_Assignment here].

This project was last updated in March of 2018.

The code for this project can be accessed here: [https://github.com/peerlogic/IntelligentAssignment https://github.com/peerlogic/IntelligentAssignment].

==RainbowGraphService==
RainbowGraphService is a primarily JavaScript application that visualizes the results of peer review criticisms.

Please see the extended documentation [https://expertiza.csc.ncsu.edu/index.php/PeerLogic_Web_Services:_Rainbow_Graph_Service here].

This project was last updated in March of 2018.

The code for this project can be accessed here: [https://github.com/ferryxo/RainbowGraphService https://github.com/ferryxo/RainbowGraphService].

==AutoSummaryV1==
AutoSummaryV1 is a Javascript application about explaining and summarizing reviews made by students.

Please see the extended documentation here: [https://expertiza.csc.ncsu.edu/index.php/PeerLogic_Web_Services:_Summarization_Service here].

This project was last updated in February of 2016.

The code for this project can be accessed here: [https://github.com/peerlogic/AutoSummaryV1 https://github.com/peerlogic/AutoSummaryV1].

==reputation_web_service==
reputation_web_service is a Javascript application with extensive documentation, detailing the web service's use for determining user reputation.

Please see the extended documentation for this project here: [https://expertiza.csc.ncsu.edu/index.php/Web-services:_Reputation_Web_Service here].

This project was last updated in April of 2016.

The code for this project can be accessed here [https://github.com/peerlogic/reputation_web_service https://github.com/peerlogic/reputation_web_service].

==autometareviews0.1==
This project is a Ruby application for the purpose of natural language processing, including sentiment analysis, volume, tone, etc.

This project was last updated in April of 2016.

The code for this project can be accessed here [https://github.com/peerlogic/autometareviews0.1 https://github.com/peerlogic/autometareviews0.1].

==Other Resources==
The following are older resources with a bit more depth into specifics, left here for the sake of not losing any information.

Original PeerLogic web service set up: [https://docs.google.com/document/d/1270jOLqVHV9iojAf9jwd2WJlOr9PNCZChDz1-sEzkhM/edit?usp=sharing here].

NLP Web Service Setup: [https://docs.google.com/document/d/1QAMVLu6whaJ8fSkwxY_Z-Hq7lHwXj40X-_xWd6F-FOM/edit?usp=sharing here].

PeerLogic Web Services

2022-02-22T04:24:56Z

Ggarrid: /* RainbowGraphService */

2022-02-22T02:02:45Z

Ggarrid:

Web-services: Data Warehouse

2022-02-15T02:47:44Z

Ggarrid:

=Data Warehouse=
==Mapping Individual database to PRML schema==
IUSE project aims at unifying peer review data across different systems to enable data analysis across wider users and different set of peer review approaches. In the consortium, we have 4 systems, whose data is to be unified (Expertiza, Crowd Grader, Mobius SLIP, CritViz). In addition, data from 2 other bigger systems, Perceptive and CPR, where the the project advisors should also be integrated to some extent.

We choose to use an existing open source ETL (Extract, Transform, Load) tool, called Pentaho, for extracting data from the database of individual system, transform this data according to PRML schema and store the result to a centralized PRML DB. Figure 1 shows the architecture how we plan to extract data from expertiza database, then we transform the data according to the PRML schema. However, since PRML is normalized in 3NF, it might not be easy to extract some information for data analysis purposes. Thus, we plan to denormalize the PRML data and store them in a data warehouse.

==Initial Step==

The Pentaho Kettle tool extracts data from the expertise schema, performs transformation on it and load the data in the PRML format. The tables are mapped as shown in the schema map above. The operations performed by the ETL tool:

Extraction The data is extracted from the expertise database and brought into the staging area by this operation of the ETL tool. It is the staging area in which all the transformation are done.

Transformation Many operations are performed on the data in the staging area so that the expertise schema can be converted to the PRML schema. This is called transformation of the data. An example of transformation is while mapping of participants table in the expertiza database to actors table in the PRML database. Each value of the id field is incremented by 1000 while inserting in the participants table.

Loading: The transformed data when moved from the staging area to the PRML database is called as loading. There are three types of loading implemented on the tables depending on the size of the table – initial load,partial loading and full loading. Partial Loading: Only the new or updated entries in the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for table with very large number of entries. Eg: Reviews

Partial loading is implemented with the help of timestamps and checksums.

Timestamp: One way to perform partial loading is to have a ‘modified’ time stamp in the source table. The destination table should mirror this ‘modified’ time stamp. Then while loading the destination table we extract only those records from the source table which has a ‘modified’ time stamp value greater than the latest ‘modified’ time stamp value in the destination table. The advantage is that we need not fetch all records from the source table. Only those records which needs to be updated in the destination table will be retrieved. (refer load_prml_ModifiedTimeStampTable transformation)

Checksum: Another way to perform partial loading is using checksum. A checksum is computed for each record, on selected field values, of the source table and added to the destination table while initial loading. Loading which follow would again compute the checksum for source table records and if there is no matching checksum in the destination table an update or an insert would be performed. (refer load_prml_checksumtable transformation)

Full Loading: All the entries from the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for tables with less number of entries. Eg: Courses

===Pentaho, Spoon ETL===

Pentaho provides a GUI to define the ETL process. as shown in figure 3, first we define the DB connections to Expertiza database and PRML database, then we use a table input component to query the necessary data for each PRML table. Figure 3 also shows an example of the SQL query that extract course data from expertiza and map each column to the corresponding PRML column. we then use Insert/Update component to insert the queried data into the corresponding PRML table. since the mapping has done in the initial query, we only need to map the ID of the queried record. A similar step is defined for each PRML table.

==Data Warehouse Schema==

PRML was used to define a data warehouse model that can be used to share data from different peer-review systems. We designed the schema based on dimensional modeling approach[] Dimensional modeling requires the data that contains measurements, metrics, or facts of the business process to be stored as Fact tables. The Fact tables also contains foreign keys to the dimension tables that can be used to group the facts into multidimensional arrays of data, known as OLAP cube or hypercube. Dimensional modeling encourages data warehouse schema to follow a star topology, in which fact tables are placed in the center.

Following this approach, our schema is centered around the Critique table. It contains reviewer’s qualitative and quantitative feedback. The quantitative feedback can be expressed in rating, ranking or the combination of both. As depicted in Figure 4, the Critiques can be sliced based on different dimensions including the Criterion, Eval_Mode, Task, Actor, and Course_Setting. The criterion table contains criteria questions, the scale used to rank or rate the work, and the weighting that is used to calculate the final score. The eval_mode determines whether ranking, rating or both are used to evaluate the artifact. The Task table contains information such as when the task starts and ends, the CIP (Classification of Instructional Programs) codes, whether it is an assignment, reviewing, or meta-reviewing task. The actor table contains the actors involved in the assignment and their roles, whether it is student, instructor, or administrator. The actor table is linked to the participant table in the actor_participant table to maintain the group memberships of each participant.

The Artifact table contains information about the student’s work in response to the assignments, which is usually a url to uploaded files or web pages. Course_setting table contains meta information about how the peer review was conducted. For instance, anonymity could be none, single blind, double blind, partial (critiques and artifacts are public after the review process is done). The workflow, could be single loop, double loop, or n rounds. The rubric mode, could be holistic or specific, and assignment style could be assignment based, where a set of activities are fixed or task based where activities may varies from assignment to assignment. The Course_setting table is used to compare the effect of different features adopted by peer review systems to the learning gains as well as the quality of the peer review process itself.

==Accessing the data==
If you are familiar with SQL, you can query the data on our MySQL database directly. You’ll need a mysql client such as MySQL Workbench (http://dev.mysql.com/downloads/workbench/). You can reach our server using the following read-only credential:

mysql server: peerlogic.csc.ncsu.edu (port three three zero six)
username : readonly
password : readpassword
Alternatively, if you are not familiar with SQL, you can also use REST API to query the data. please be aware that our REST API currently is only able to retrieve a limited set of data from the data warehouse, as documented here. But we’d love to hear your feedback, and if you need to retrieve some data that is currently not supported, please do let us know. We’ll try to have it implemented within 1-2 days.

The REST API can be accessed from this URL: http://peerlogic.csc.ncsu.edu/datawarehouse/

Web-services: Data Warehouse

2022-02-15T02:47:16Z

Ggarrid: Created page with "=Data Warehouse= ==Mapping Individual database to PRML schema== IUSE project aims at unifying peer review data across different systems to enable data analysis across wider us..."

=Data Warehouse=
==Mapping Individual database to PRML schema==
IUSE project aims at unifying peer review data across different systems to enable data analysis across wider users and different set of peer review approaches. In the consortium, we have 4 systems, whose data is to be unified (Expertiza, Crowd Grader, Mobius SLIP, CritViz). In addition, data from 2 other bigger systems, Perceptive and CPR, where the the project advisors should also be integrated to some extent.

We choose to use an existing open source ETL (Extract, Transform, Load) tool, called Pentaho, for extracting data from the database of individual system, transform this data according to PRML schema and store the result to a centralized PRML DB. Figure 1 shows the architecture how we plan to extract data from expertiza database, then we transform the data according to the PRML schema. However, since PRML is normalized in 3NF, it might not be easy to extract some information for data analysis purposes. Thus, we plan to denormalize the PRML data and store them in a data warehouse.

===Initial Step===
===ETL===

The Pentaho Kettle tool extracts data from the expertise schema, performs transformation on it and load the data in the PRML format. The tables are mapped as shown in the schema map above. The operations performed by the ETL tool:

Extraction The data is extracted from the expertise database and brought into the staging area by this operation of the ETL tool. It is the staging area in which all the transformation are done.

Transformation Many operations are performed on the data in the staging area so that the expertise schema can be converted to the PRML schema. This is called transformation of the data. An example of transformation is while mapping of participants table in the expertiza database to actors table in the PRML database. Each value of the id field is incremented by 1000 while inserting in the participants table.

Loading: The transformed data when moved from the staging area to the PRML database is called as loading. There are three types of loading implemented on the tables depending on the size of the table – initial load,partial loading and full loading. Partial Loading: Only the new or updated entries in the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for table with very large number of entries. Eg: Reviews

Partial loading is implemented with the help of timestamps and checksums.

Timestamp: One way to perform partial loading is to have a ‘modified’ time stamp in the source table. The destination table should mirror this ‘modified’ time stamp. Then while loading the destination table we extract only those records from the source table which has a ‘modified’ time stamp value greater than the latest ‘modified’ time stamp value in the destination table. The advantage is that we need not fetch all records from the source table. Only those records which needs to be updated in the destination table will be retrieved. (refer load_prml_ModifiedTimeStampTable transformation)

Checksum: Another way to perform partial loading is using checksum. A checksum is computed for each record, on selected field values, of the source table and added to the destination table while initial loading. Loading which follow would again compute the checksum for source table records and if there is no matching checksum in the destination table an update or an insert would be performed. (refer load_prml_checksumtable transformation)

Full Loading: All the entries from the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for tables with less number of entries. Eg: Courses

===Pentaho, Spoon ETL===

Pentaho provides a GUI to define the ETL process. as shown in figure 3, first we define the DB connections to Expertiza database and PRML database, then we use a table input component to query the necessary data for each PRML table. Figure 3 also shows an example of the SQL query that extract course data from expertiza and map each column to the corresponding PRML column. we then use Insert/Update component to insert the queried data into the corresponding PRML table. since the mapping has done in the initial query, we only need to map the ID of the queried record. A similar step is defined for each PRML table.

==Data Warehouse Schema==

PRML was used to define a data warehouse model that can be used to share data from different peer-review systems. We designed the schema based on dimensional modeling approach[] Dimensional modeling requires the data that contains measurements, metrics, or facts of the business process to be stored as Fact tables. The Fact tables also contains foreign keys to the dimension tables that can be used to group the facts into multidimensional arrays of data, known as OLAP cube or hypercube. Dimensional modeling encourages data warehouse schema to follow a star topology, in which fact tables are placed in the center.

Following this approach, our schema is centered around the Critique table. It contains reviewer’s qualitative and quantitative feedback. The quantitative feedback can be expressed in rating, ranking or the combination of both. As depicted in Figure 4, the Critiques can be sliced based on different dimensions including the Criterion, Eval_Mode, Task, Actor, and Course_Setting. The criterion table contains criteria questions, the scale used to rank or rate the work, and the weighting that is used to calculate the final score. The eval_mode determines whether ranking, rating or both are used to evaluate the artifact. The Task table contains information such as when the task starts and ends, the CIP (Classification of Instructional Programs) codes, whether it is an assignment, reviewing, or meta-reviewing task. The actor table contains the actors involved in the assignment and their roles, whether it is student, instructor, or administrator. The actor table is linked to the participant table in the actor_participant table to maintain the group memberships of each participant.

The Artifact table contains information about the student’s work in response to the assignments, which is usually a url to uploaded files or web pages. Course_setting table contains meta information about how the peer review was conducted. For instance, anonymity could be none, single blind, double blind, partial (critiques and artifacts are public after the review process is done). The workflow, could be single loop, double loop, or n rounds. The rubric mode, could be holistic or specific, and assignment style could be assignment based, where a set of activities are fixed or task based where activities may varies from assignment to assignment. The Course_setting table is used to compare the effect of different features adopted by peer review systems to the learning gains as well as the quality of the peer review process itself.

==Accessing the data==
If you are familiar with SQL, you can query the data on our MySQL database directly. You’ll need a mysql client such as MySQL Workbench (http://dev.mysql.com/downloads/workbench/). You can reach our server using the following read-only credential:

mysql server: peerlogic.csc.ncsu.edu (port three three zero six)
username : readonly
password : readpassword
Alternatively, if you are not familiar with SQL, you can also use REST API to query the data. please be aware that our REST API currently is only able to retrieve a limited set of data from the data warehouse, as documented here. But we’d love to hear your feedback, and if you need to retrieve some data that is currently not supported, please do let us know. We’ll try to have it implemented within 1-2 days.

The REST API can be accessed from this URL: http://peerlogic.csc.ncsu.edu/datawarehouse/

PeerLogic Web Services

2022-02-15T02:43:57Z

Ggarrid: /* AutoSummaryV1 */

=Summary=
The expertiza web services are a group of scripts and programs utilized by the expertiza website for performing various functions. These functions are hosted on external web services for the purposes of better performance, flexibility, and modularity.

This page is documenting all of these services, including where they are located, the code they utilize, and theoretical explanations of what they are performing.

The collection of the code for all of these web services can be found [https://github.com/peerlogic here].

==Server Setup==
The Peerlogic webservices setup can be accessed [https://docs.google.com/document/d/1270jOLqVHV9iojAf9jwd2WJlOr9PNCZChDz1-sEzkhM/edit?usp=sharing here]. This material is not publicly posted for the purposes of protecting the server's integrity.

An additional document for how to set up the NLP webservice in particular can be found [https://docs.google.com/document/d/1QAMVLu6whaJ8fSkwxY_Z-Hq7lHwXj40X-_xWd6F-FOM/edit?usp=sharing here].

==PeerAssessmentWeb==
PeerAssessmentWeb is a Ruby application. It's not currently known what the purpose of this web service is.

This project was last updated in March of 2018.

The code for this project can be accessed here: [https://github.com/peerlogic/PeerAssessmentWeb https://github.com/peerlogic/PeerAssessmentWeb].

==IntelligentAssignment==
IntelligentAssignment is a Python application which has the stated purpose of forming project groups by performing k-means clustering on their topics of interest.

Please see the extended documentation here: [https://expertiza.csc.ncsu.edu/index.php/Web-services:_Intelligent_Assignment https://expertiza.csc.ncsu.edu/index.php/Web-services:_Intelligent_Assignment].

This project was last updated in March of 2018.

The code for this project can be accessed here: [https://github.com/peerlogic/IntelligentAssignment https://github.com/peerlogic/IntelligentAssignment].

==AutoSummaryV1==
AutoSummaryV1 is a Javascript application. It is not currently known what the purpose of this web service is.

Please see the extended documentation here: [https://expertiza.csc.ncsu.edu/index.php/Web-services:_Summarization_Service https://expertiza.csc.ncsu.edu/index.php/Web-services:_Summarization_Service].

This project was last updated in February of 2016.

The code for this project can be accessed here: [https://github.com/peerlogic/AutoSummaryV1 https://github.com/peerlogic/AutoSummaryV1].

==reputation_web_service==
reputation_web_service is a Javascript application with extensive documentation, detailing the web service's use for determining user reputation.

Please see the extended documentation for this project here: [https://expertiza.csc.ncsu.edu/index.php/Web-services:_Reputation_Web_Service https://expertiza.csc.ncsu.edu/index.php/Web-services:_Reputation_Web_Service].

This project was last updated in April of 2016.

The code for this project can be accessed here [https://github.com/peerlogic/reputation_web_service https://github.com/peerlogic/reputation_web_service].

==Data-Warehouse-Object-Relational-Mapping==
This is a Ruby application. It is not currently known what the specific purpose of this web service is, though presumably it assists in the accessing of data warehouse relational objects and tables.

This project was last updated in April of 2017.

The code for this project can be accessed here [https://github.com/peerlogic/Data-Warehouse-Object-Relational-Mapping https://github.com/peerlogic/Data-Warehouse-Object-Relational-Mapping].

==autometareviews0.1==
This project is a Ruby application for the purpose of natural language processing, including sentiment analysis, volume, tone, etc.

This project was last updated in April of 2016.

The code for this project can be accessed here [https://github.com/peerlogic/autometareviews0.1 https://github.com/peerlogic/autometareviews0.1].

PeerLogic Web Services: Summarization Service

2022-02-15T02:43:06Z

Ggarrid: Created page with "=Summarization Service= The extent of feedback in peer review applications could easily overwhelm the student, which may cancel out the desired effects of helping students to..."

PeerLogic Web Services

2022-02-15T02:36:34Z

Ggarrid: /* IntelligentAssignment */

=Summary=
The expertiza web services are a group of scripts and programs utilized by the expertiza website for performing various functions. These functions are hosted on external web services for the purposes of better performance, flexibility, and modularity.

This page is documenting all of these services, including where they are located, the code they utilize, and theoretical explanations of what they are performing.

The collection of the code for all of these web services can be found [https://github.com/peerlogic here].

==Server Setup==
The Peerlogic webservices setup can be accessed [https://docs.google.com/document/d/1270jOLqVHV9iojAf9jwd2WJlOr9PNCZChDz1-sEzkhM/edit?usp=sharing here]. This material is not publicly posted for the purposes of protecting the server's integrity.

An additional document for how to set up the NLP webservice in particular can be found [https://docs.google.com/document/d/1QAMVLu6whaJ8fSkwxY_Z-Hq7lHwXj40X-_xWd6F-FOM/edit?usp=sharing here].

==PeerAssessmentWeb==
PeerAssessmentWeb is a Ruby application. It's not currently known what the purpose of this web service is.

This project was last updated in March of 2018.

The code for this project can be accessed here: [https://github.com/peerlogic/PeerAssessmentWeb https://github.com/peerlogic/PeerAssessmentWeb].

==IntelligentAssignment==
IntelligentAssignment is a Python application which has the stated purpose of forming project groups by performing k-means clustering on their topics of interest.

Please see the extended documentation here: [https://expertiza.csc.ncsu.edu/index.php/Web-services:_Intelligent_Assignment https://expertiza.csc.ncsu.edu/index.php/Web-services:_Intelligent_Assignment].

This project was last updated in March of 2018.

The code for this project can be accessed here: [https://github.com/peerlogic/IntelligentAssignment https://github.com/peerlogic/IntelligentAssignment].

==AutoSummaryV1==
AutoSummaryV1 is a Javascript application. It is not currently known what the purpose of this web service is.

This project was last updated in February of 2016.

The code for this project can be accessed here: [https://github.com/peerlogic/AutoSummaryV1 https://github.com/peerlogic/AutoSummaryV1].

==reputation_web_service==
reputation_web_service is a Javascript application with extensive documentation, detailing the web service's use for determining user reputation.

Please see the extended documentation for this project here: [https://expertiza.csc.ncsu.edu/index.php/Web-services:_Reputation_Web_Service https://expertiza.csc.ncsu.edu/index.php/Web-services:_Reputation_Web_Service].

This project was last updated in April of 2016.

The code for this project can be accessed here [https://github.com/peerlogic/reputation_web_service https://github.com/peerlogic/reputation_web_service].

==Data-Warehouse-Object-Relational-Mapping==
This is a Ruby application. It is not currently known what the specific purpose of this web service is, though presumably it assists in the accessing of data warehouse relational objects and tables.

This project was last updated in April of 2017.

The code for this project can be accessed here [https://github.com/peerlogic/Data-Warehouse-Object-Relational-Mapping https://github.com/peerlogic/Data-Warehouse-Object-Relational-Mapping].

==autometareviews0.1==
This project is a Ruby application for the purpose of natural language processing, including sentiment analysis, volume, tone, etc.

This project was last updated in April of 2016.

The code for this project can be accessed here [https://github.com/peerlogic/autometareviews0.1 https://github.com/peerlogic/autometareviews0.1].

PeerLogic Web Services: Intelligent Assignment

2022-02-15T02:35:57Z

Ggarrid: /* Accessing the service */

PeerLogic Web Services: Intelligent Assignment

2022-02-15T02:35:36Z

Ggarrid: Created page with "=Intelligent Team and Topic Assignment= Intelligent assignment creates teams based off of each individual users ranking of topic preference, using k-means clustering. This web..."

PeerLogic Web Services

2022-02-15T02:28:16Z

Ggarrid:

=Summary=
The expertiza web services are a group of scripts and programs utilized by the expertiza website for performing various functions. These functions are hosted on external web services for the purposes of better performance, flexibility, and modularity.

This page is documenting all of these services, including where they are located, the code they utilize, and theoretical explanations of what they are performing.

The collection of the code for all of these web services can be found [https://github.com/peerlogic here].

==Server Setup==
The Peerlogic webservices setup can be accessed [https://docs.google.com/document/d/1270jOLqVHV9iojAf9jwd2WJlOr9PNCZChDz1-sEzkhM/edit?usp=sharing here]. This material is not publicly posted for the purposes of protecting the server's integrity.

An additional document for how to set up the NLP webservice in particular can be found [https://docs.google.com/document/d/1QAMVLu6whaJ8fSkwxY_Z-Hq7lHwXj40X-_xWd6F-FOM/edit?usp=sharing here].

==PeerAssessmentWeb==
PeerAssessmentWeb is a Ruby application. It's not currently known what the purpose of this web service is.

This project was last updated in March of 2018.

The code for this project can be accessed here: [https://github.com/peerlogic/PeerAssessmentWeb https://github.com/peerlogic/PeerAssessmentWeb].

==IntelligentAssignment==
IntelligentAssignment is a Python application which has the stated purpose of forming project groups by performing k-means clustering on their topics of interest.

This project was last updated in March of 2018.

The code for this project can be accessed here: [https://github.com/peerlogic/IntelligentAssignment https://github.com/peerlogic/IntelligentAssignment].

==AutoSummaryV1==
AutoSummaryV1 is a Javascript application. It is not currently known what the purpose of this web service is.

This project was last updated in February of 2016.

The code for this project can be accessed here: [https://github.com/peerlogic/AutoSummaryV1 https://github.com/peerlogic/AutoSummaryV1].

==reputation_web_service==
reputation_web_service is a Javascript application with extensive documentation, detailing the web service's use for determining user reputation.

Please see the extended documentation for this project here: [https://expertiza.csc.ncsu.edu/index.php/Web-services:_Reputation_Web_Service https://expertiza.csc.ncsu.edu/index.php/Web-services:_Reputation_Web_Service].

This project was last updated in April of 2016.

The code for this project can be accessed here [https://github.com/peerlogic/reputation_web_service https://github.com/peerlogic/reputation_web_service].

==Data-Warehouse-Object-Relational-Mapping==
This is a Ruby application. It is not currently known what the specific purpose of this web service is, though presumably it assists in the accessing of data warehouse relational objects and tables.

This project was last updated in April of 2017.

The code for this project can be accessed here [https://github.com/peerlogic/Data-Warehouse-Object-Relational-Mapping https://github.com/peerlogic/Data-Warehouse-Object-Relational-Mapping].

==autometareviews0.1==
This project is a Ruby application for the purpose of natural language processing, including sentiment analysis, volume, tone, etc.

This project was last updated in April of 2016.

The code for this project can be accessed here [https://github.com/peerlogic/autometareviews0.1 https://github.com/peerlogic/autometareviews0.1].

2022-01-31T03:59:38Z

Ggarrid:

==Overview==
The purpose of this page is to describe the steps necessary to set up and run the peer-reviews-NLP web service, as well as what is actually happening during those steps (should they need to change). This page will assume a reader who is familiar with Python programming, but not with any particular technical tool used for application or web service hosting (such as Docker, etc.)

To read more about the peer-review-NLP project, [https://expertiza.csc.ncsu.edu/index.php/Peer-reviews-NLP see the main page on the project here.]

Two separate scenarios will be explained

=Step-by-Step Installation=

Two alternatives will be outlined for installation of the peer-review-NLP web service. The first will assume you are installing the web service onto a deployed Ubuntu environment, for the purposes of deploying the project for use on the Expertiza website. The second will assume you wish to run the webservice on your local machine for the sake of testing and development.

==Alternative 1: Installation on Deployed Ubuntu==
* Clone the public Github for the project to the machine you are deploying to. A link to the Github can be found [https://github.com/koushik1/Peer-reviews-NLP here].
* Install Docker and Docker Compose onto the machine by running the following code:
<pre>
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
sudo apt-get update
apt-cache policy docker-ce
sudo apt-get install -y docker-ce
sudo systemctl status docker
sudo curl -L https://github.com/docker/compose/releases/download/1.26.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
</pre>
Note: if the given code did not successfully install Docker, refer to the following [https://docs.docker.com/engine/install/ubuntu/ official documentation for proper download instructions].
* Check to make sure docker has been properly installed by using the command <pre>docker-compose --version</pre>
* Navigate to the directory "~/Peer-reviews-NLP" and run "sudo docker-compose up" to start the web service
* If the web service goes down and needs to be rebuilt, utilize the command "sudo docker-compose up --build"

==Alternative 2: Installation on Deployed CentOS (RedHat)
* Clone the public Github for the project
* Install docker and docker-compose using the following command line code:
<pre>
sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo yum install docker-ce docker-ce-cli containerd.io --allowerasing
sudo curl -L https://github.com/docker/compose/releases/download/1.26.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

==Alternative 3: Installation on Local Machine==
* Clone the public Github for the project to your local machine. A link to the Github can be found [https://github.com/koushik1/Peer-reviews-NLP here].
* Install Docker to your local machine. Please refer to the [https://docs.docker.com/get-docker/ official Docker documentation for installation instructions for your specific OS.]
* Navigate to the directory "~/Peer-reviews-NLP" and run "sudo docker-compose up" to start the web service
* If the web service goes down and needs to be rebuilt, utilize the command "sudo docker-compose up --build"

=Testing Set-Up=
To ensure the installation was successful and that the web service is functioning properly, this section will outline how to send some basic test input to the web service.

Those familiar with a particular API tool should feel free to use whatever they prefer. However, these instructions assume no familiarity with such tools, and so will recommend the download and use of Insomnia, a tool which allows API requests to be made to both localhosts and deployed addresses.

The initial steps for both alternatives are the same, and so will be said here before splitting into specifics:
* Download [https://insomnia.rest/product/automated-testing Insomnia].
* Open Insomnia and click the button in the top-right labelled "Create". From the dropdown, choose to create a new "Request Collection." Name it whatever you prefer.
* Click the "+" symbol near the top-left and choose to make a new request. Name it as you prefer.
* Once the request is created, change its type to a "POST" request in the bar near the top, and just beneath, click the word "Body" and select "JSON" from the dropdown.

You may now post into the text area whatever JSON payload you may wish to send to the web service. In order to do so, however, you must send the POST request to the proper address, which must be put in at the top (next to POST).

If you are testing locally, this address will start with "127.0.0.1", followed by the particular call you would like to make (for example, "127.0.0.1/volume"). If you are testing in the deployed environment, you should send your request to the address or url of the deployed machine.

For more information on what API calls you can make and what payloads to expect to send and receive, including testing examples, see [https://expertiza.csc.ncsu.edu/index.php/Peer-reviews-NLP:_Web_Service_API this page on web service API].

=Technical Explanation of Set Up=
The following is a documentation of the specific steps that occur when the web service is set up. More specifically, this section will explain what the Dockerfile and subsequent scripts do to set up the server when the docker-compose command is called. These steps are documented in the case that they need future repair or refactoring.