Improved Autolab example

docs/README.jinja.md

@@ -179,12 +179,12 @@ The grade script works as normal, and just to make the example self-contained, l
 ```
 ### Setting up and using Docker
 We are going to run the students tests in a Docker virtual machine so that we avoid any underhanded stuff, and also because it makes sure we get the same result every time (i.e., we can pass the task on to TAs).
-To do that, you first have to install Docker (easy), and then build a Docker image. We are going to use one of the pre-baked images from  https://gitlab.compute.dtu.dk/tuhe/unitgrade_private/-/tree/master/docker_images, which simply consists of a lean Linux distribution with python 3.8 and whatever packages are found in `requirements.txt`. If you need more, it is very easy to add. 
-To build the Docker image simply run:
+To do that, you first have to install Docker (easy), and then build a Docker image. We are going to use one of the pre-baked images from  https://gitlab.compute.dtu.dk/tuhe/unitgrade_private/-/tree/master/docker_images, which simply consists of a lean Linux distribution with python 3.8 and whatever packages are found in `requirements.txt`. If you need more it is very easy to add. 
+To download and build the Docker image simply run:
 ```python
 {{ deploy_docker_c_py }}
 ```
-This takes about 3 minutes but only needs to be done once. If you are keeping track we have the following:
+This takes about 2 minutes but only needs to be done once. If you are keeping track we have the following:
  - A grade script with all tests, `report3_complete_grade.py`, which we build when the file was deployed
  - A (student) `.token` file we simulated, but in general would have downloaded from DTU Learn
  - A Docker image with the right packages
@@ -247,6 +247,56 @@ What happens behind the scenes is that a code-coverage tool is run on the instru
 to determine which methods are actually used in solving a problem, and then the hint-texts of those methods are 
 collected and displayed. This feature requires no external configuration; simply write `Hints:` in the source code. 
 
+# CMU Autolab support (Experimental)
+CMU Autolab is a mature, free and opensource web-based autograder developed at Carnegie Mellon University and used across the world. You can find more information here: https://autolabproject.com/. It offers all features you expect from an online autograder
+ - Web-based submission of homework
+ - Class-management
+ - Build in TA feedback mechanism
+ - Class monitoring/statistics 
+ - Automatic integration with enrollment data (Autolab supports LDAP and Shibboleth) means Autolab can be `plugged in` to existing IT infrastructure (including DTUs)
+ - CLI Tools
+
+An important design choice behind CMU Autolab is the grading is entirely based on Makefiles and Docker VMs. I.e., if you can make your autograding scheme work as Makefile that runs code on a Docker image you specify it will work on Autolab. This makes it very easy to let third-party platforms work with an **unmodified** version of Autolab. The following contains all steps needed to compile a Unitgrade test to Autolab
+
+### Step 1: Set up Autolab
+Simply follow the guide here: https://docs.autolabproject.com/installation/overview/ to set up Autolab. I used the 'manual' installation, but it should also work with the Docker-compose installation.
+
+### Step 2: Compile a unitgrade test to Autolab lab-assignment format
+Autolab calls handins for `lab assignments`, and allow you to import them as `.tar`-files (see the Autolab documentation for more information).  We can build these automatically in a few lines as this example demonstrates. 
+The code for the example can be found in `examples/autolab_example`. It consists of two steps. The first is that you need to build the Docker image for Autolab/Tango used for grading. This is exactly like our earlier example using Docker for Unitgrade, except the image contains a few additional autolab-specific things. You can find the image here: 
+ - https://gitlab.compute.dtu.dk/tuhe/unitgrade_private/-/tree/master/docker_images/docker_tango_python
+
+Concretely, the following code will download and build the image (note this code must be run on the same machine that you have installed Autolab on)
+```python
+{{ deploy_autolab_a_py }}
+```
+Next, simply call the framework to compile any `_grade.py`-file into an Autolab-compatible `.tar` file that can be imported from the web interface. The script requires you to specify 
+both the instructor-directory and the directory with the files the student have been handed out (i.e., the same file-system format we have seen earlier). 
+```python
+{{ deploy_autolab_b_py }}
+```
+This will produce a file `cs102.tar`. Whereas you needed to build the Docker image on the machine where you are running Autolab, you can build the lab assignments on any computer.
+### Step 3: Upload the `.tar` lab-assignment file 
+To install the `cs102.tar`-file, simply open your course in Autolab and click the `INSTALL ASSESSMENT` button. Click `Browse` and upload the `cs102.tar` file:
+![alt text|small]({{resources}}/docs/images/autolab1.png)
+
+You will immediately see the page for the assignment where you can begin to upload solutions! 
+The solutions are (of course!) `.token` files, and they will be automatically unpacked and run on Autolab. 
+
+To test it, press the big upload square and select the `.token` file for the second assignment found in `examples/example_framework/instructor/cs102/Report2_handin_18_of_18.token`. 
+The file will now be automatically evaluated and the score registered as any other Autolab assignment:
+
+(overview here)
+
+The students can choose to view both the console output or a nicer formatted overview of the individual problems:
+
+(scores)
+
+and TAs can choose to annotate the students code directly in Autolab -- we are here making use of the fact the code is automatically included in the top of the `.token`-file.
+
+(code overview).
+
+
 # Citing
 ```bibtex
 {{bibtex}}

examples/autolab_example/deploy_autolab.py

+from unitgrade_private.autolab.autolab import deploy_assignment
+from unitgrade_private.docker_helpers import download_docker_images
+from unitgrade_private.docker_helpers import compile_docker_image
+
+if __name__ == "__main__":
+    # Step 1: Download and compile docker grading image. You only need to do this once.  #!s=a
+    download_docker_images("./docker") # Download docker images from gitlab (only do this once.
+    dockerfile = f"./docker/docker_tango_python/Dockerfile"
+    autograde_image = 'tango_python_tue'
+    compile_docker_image(Dockerfile=dockerfile, tag=autograde_image)  # Compile docker image. #!s
+
+    # Step 2: Create the cs102.tar file from the grade scripts. #!s=b
+    instructor_base = f"../example_framework/instructor"
+    student_base = f"../example_framework/students"
+    output_tar = deploy_assignment("cs102",  # Autolab name of assignment (and name of .tar file)
+                                   INSTRUCTOR_BASE=instructor_base,
+                                   INSTRUCTOR_GRADE_FILE=f"{instructor_base}/cs102/report2_grade.py",
+                                   STUDENT_BASE=student_base,
+                                   STUDENT_GRADE_FILE=f"{student_base}/cs102/report2_grade.py",
+                                   autograde_image_tag=autograde_image) #!s
+
+    # output_tar is now the `cs102.tar` which can be uploaded to autolab as a lab-assignment.

examples/autolab_example/tmp/cs102/src/docker_helpers.py

@@ -101,7 +101,7 @@ def student_token_file_runner(host_tmp_dir, student_token_file, instructor_grade
     return pycom, token_location
 
 
-def docker_run_token_file(Dockerfile_location, host_tmp_dir, student_token_file, tag=None, instructor_grade_script=None, fix_user=True):
+def docker_run_token_file(Dockerfile_location, host_tmp_dir, student_token_file, tag=None, instructor_grade_script=None, fix_user=None):
     """
     This thingy works:
 
@@ -114,9 +114,14 @@ def docker_run_token_file(Dockerfile_location, host_tmp_dir, student_token_file,
 
     """
     # A bunch of tests. This is going to be great!
+    Dockerfile_location = os.path.abspath(Dockerfile_location)
     assert os.path.exists(Dockerfile_location)
+
     start = time.time()
 
+    if fix_user is None:
+        fix_user = os.name != 'nt'  # On Linux, this should probably be true to avoid problem with edit-rights of docker-created files.
+
     # with open(student_token_file, 'rb') as f:
     #     results = pickle.load(f)
     from unitgrade_private import load_token