If you’ve been following along my other tutorials, you’ve probably noticed that the SCM Creator and Redmine Git Hosting plugins really just don’t want to cooperate one another. The conflict here is that they both override the same method (RepositoriesController#edit), so that while they appear to work on the surface (the correct menu shows up for each), the Git repository creation results in a 500 error message in AJAX, and the repository is not created. It turns out that, due to the internal implementations of these plugins, fixing this problem isn’t terribly hard, although it does involve editing two lines in the plugin files directly.

Assumptions

1. SCM Creator is installed in /usr/share/redmine/vendor/plugins/scm_creator, as per my guide here
2. Redmine Git Hosting is installed in /usr/share/redmine/vendor/plugins/redmine_git_hosting, as per my guide here
3. You want to use SCM Creator for everything that is not Git, and Redmine Git Hosting to handle all of the Git requests on its own

Fixing the Problem

Modifications to SCM Creator

Edit the /usr/share/redmine/vendor/plugins/scm_creator/lib/scm_repositories_controller_patch.rb and find the lines that look like this:

def self.included(base)
    base.extend(ClassMethods)
    base.send(:include, InstanceMethods)
    base.class_eval do
        unloadable
        before_filter :delete_scm, :only => :destroy
        alias_method :edit, :edit_with_add
    end
end

The important line here is the one contains “alias_method :edit, :edit_with_add”, as it’s what’s causing the conflict. Just comment it out for now—it’s used to add the repository in the plugin architecture, so we’ll need to make sure the edit_with_add method is called at some point.

It should now look like this:

def self.included(base)
    base.extend(ClassMethods)
    base.send(:include, InstanceMethods)
    base.class_eval do
        unloadable
        before_filter :delete_scm, :only => :destroy
        # alias_method :edit, :edit_with_add
    end
end

Modifications to Redmine Git Hosting

Once again, this is a one line change:
Edit /usr/share/redmine/vendor/plugins/redmine_git_hosting/lib/git_hosting/patches/repositories_controller_patch.rb and find the block that looks like this:

else
    edit_without_scm_settings
end

Replace “edit_without_scm_settings” with “edit_with_add”, like so:

else
    # edit_without_scm_settings
    edit_with_add
end

This ensures that there is now a process chain that first goes to the Redmine Git Hosting plugin, which will only activate if the repository is a Git repository or if the Git option is selected in the repository settings menu. If it is not a Git repository, it will forward the request on to SCM Creator’s edit_with_add method, which can handle all the other repository types.

I have only tested this fix with SVN, as I don’t use the other types of repositories, but there should be no conflicts: just make sure NOT to configure git in SCM Creator’s scm.yml, as that will cause further conflicts between the two systems.

Managing repository management is always a hassle for network administrators, as it usually involves going into into the shell to create the repository itself.

Redmine solves this problem using reposman.rb, which can be run regularly by a cronjob and thus automate repository creation. But this is still inconvenient—you still need to wait for the repository to be created, and you can only manage one type of SCM at once. Thus, we are going to install and configure the Redmine SCM Creator plugin to manage repository creation for us.

This tutorial is oriented primarily towards setting up SVN repository creation, as git repository management is better done by the Redmine Git Hosting plugin (Setup Guide). For instructions on how to set up Redmine, visit this tutorial before continuing on.

Once again, this tutorial will assume that you are running all commands from the root user, unless otherwise noted. Do NOT use the root user as your primary account, it should be restricted to setup and administration only.

Step 1: Setting up the SVN repository location

We’ll start by creating the SVN repository hosting location at /var/svn, and setting it to the correct permissions:

$ mkdir /var/svn
$ chown www-data:www-data /var/svn
$ chmod 755 /var/svn

Step 2: Creating the Redmine SVN Creator Configuration File

Edit the file at /usr/share/redmine/config/scm.yml, and set its contents as follows:

$ cat /usr/share/redmine/config/scm.yml
production:
  auto_create: false
  deny_delete: false
  pre_create: /usr/local/bin/pre-create.sh
  post_create: /usr/local/bin/post-create.sh
  pre_delete: /usr/local/bin/pre-delete.sh
  post_delete: /usr/local/bin/post-delete.sh
  svn:
    path: /var/svn
    svnadmin: /usr/bin/svnadmin
    url: svn

For more information about the configuration options, visit this wiki page

Step 3: Installing the plugin

We’re now actually going to install this plugin into redmine:

$ cd /usr/share/redmine/
$ ./script/plugin install http://svn.s-andy.com/scm-creator
$ rake db:migrate_plugins RAILS_ENV=production

Restart apache to see if this plugin installed properly:

$ service apache2 restart

Now, if you create a new project and go to the Project→Settings→Repositories tab, you should be able to select “Subversion” and create a repository.

Step 4: Setting up SVN with WebDAV, Apache, and Redmine authentication

Installing packages

Start by getting the required packages to configure SVN through Apache:

$ apt-get install libapache2-svn libapache-dbi-perl libapache2-mod-perl2 libdbd-mysql-perl libdigest-sha-perl libauthen-simple-ldap-perl

Enable SVN via WebDAV:

$ a2enmod dav
$ a2enmod dav_svn
$ a2enmod perl

Set up authentication

Link the the Redmine authentication module to Apache, so we can load it the configuration file.

$ ln -s /usr/share/redmine/extra/svn/Redmine.pm /usr/lib/perl5/Apache/Redmine.pm

Configure Apache to serve SVN in redmine.example.com/svn:

$ cat /etc/apache2/sites-available/redmine.example.com.conf
PerlLoadModule Apache::Redmine

<VirtualHost your-server-ip:80>
  SuexecUserGroup "#1012" "#1012" # fill these in from the automatically generated values in the config file
  ServerName redmine.example.com
  ErrorLog /var/log/virtualmin/redmine.example.com_error_log
  CustomLog /var/log/virtualmin/redmine.example.com_access_log combined

  DocumentRoot "/usr/share/redmine/public"
  PassengerResolveSymlinksInDocumentRoot on
  Options Indexes ExecCGI FollowSymLinks

  <Location /svn>
    DAV svn
    SVNParentPath "/var/svn"
    Order deny,allow
    Deny from all
    Satisfy any

    PerlAccessHandler Apache::Authn::Redmine::access_handler
    PerlAuthenHandler Apache::Authn::Redmine::authen_handler
    AuthType Basic
    AuthName redmine

    <Limit GET PROPFIND OPTIONS REPORT>
      Require valid-user
      Allow from server-ip-address
      Satisfy any
    </Limit>
    <LimitExcept GET PROPFIND OPTIONS REPORT>
      Require valid-user
    </LimitExcept>

    RedmineDSN "DBI:mysql:database=redmine_default;host=localhost"
    RedmineDbUser "redmine"
    RedmineDbPass "redmine-db-password"
  </Location>
</VirtualHost>

Replace redmine, redmine_default, and redmine-db-password with the appropriate values for your configuration.

Step 5: Add a cronjob to regularly update the repository listings

Redmine normally only checks for updates to the repository when you access the project ‘repository’ tab, which can be somewhat clumsy when you want to see the repository updates in closer to real time. Thus, we will setup a regular cronjob to fetch new updates every minute:

Enable WS for repository management

Go to Administration→Settings→Repositories, and check “Enable WS for repository management”, and generate a random API key for use later.

Edit the crontab with the following command:

$ crontab -e

and add the following line to the end:

* * * * * curl "http://redmine.example.com/sys/fetch_changesets?key=API-KEY" > /dev/null 2>&1

Make sure that you have curl installed with the following command:

$ apt-get install curl

Save the crontab, and you’re done with this step.

Restart Apache and have fun!

At this point, you have a working SVN repository creation and authentication system, synchronized with and controlled by Redmine. You should be able to check out the project repositories at http://redmine.example.com/svn/[project-identifier], and track the progress of the repository within Redmine.

What’s next?

If you would also like to put together a fully functional Git hosting solution, check out http://aeturnalus.com/software/redmine-git-hosting-setup-ubuntu-12-04-lts/

Note that you will have to resolve conflicts between the two plugins as per http://aeturnalus.com/software/hacking-scm-creator-redmine-git-hosting-cooperate/, but it’s a fairly simple fix.

Redmine Git Hosting is a plugin for Redmine authored by Eric Bishop, which integrates the Git SCM system into Redmine’s project management system. At the end of this guide, you will have a server which can, from the Redmine GUI,

• Create git repositories for projects
• Serve git repositories via SSH, GIT, and HTTP(S)
• Add users to git repositories

This guide is a continuation of the one here, which shows how to install and configure Redmine in Ubuntu with Virtualmin.

Step 1: Get Gitolite

Gitolite is in the Ubuntu repositories, so just apt-get it.

$ apt-get install gitolite

Step 2: Configure Gitolite

The gitolite package needs to be reconfigured in order for it to finish setup.

In order for the gitolite setup to work properly, we need to generate a key for the gitolite user before we actually set it up.

$ cd /tmp
$ ssh-keygen -t rsa -f /tmp/id_rsa

Do not give it a passphrase

$ dpkg-reconfigure gitolite

Use the default username and path, and give it /tmp/id_rsa.pub for the “Administrator’s SSH Key”

Copy the RSA keys into the gitolite user’s .ssh folder for safekeeping:

$ cp /tmp/id_rsa* /var/lib/gitolite/.ssh
$ chown gitolite:gitolite /var/lib/gitolite/.ssh/*
$ chmod 600 /var/lib/gitolite/.ssh/id_rsa
$ chmod 644 /var/lib/gitolite/.ssh/id_rsa.pub

Step 3: Configure redmine’s SSH keys

Copy the RSA keys into a place where redmine can handle them:

$ mkdir /usr/share/redmine/.ssh
$ cp /var/lib/gitolite/.ssh/id_rsa* /usr/share/redmine/.ssh/
$ cd /usr/share/redmine/
$ mv .ssh/id_rsa .ssh/gitolite_admin_id_rsa
$ mv .ssh/id_rsa.pub .ssh/gitolite_admin_id_rsa.pub
$ chown www-data:www-data -R .ssh
$ chmod 700 .ssh
$ chmod 600 .ssh/gitolite_admin_id_rsa
$ chmod 644 .ssh/gitolite_admin_id_rsa.pub

Step 4: Install the redmine_git_hosting plugin

Install the plugin

$ cd /usr/share/redmine
$ mkdir public/plugin_assets
$ chown -R www-data:www-data public/plugin_assets
$ chmod -R 777 public/plugin_assets
$ gem install lockfile net-ssh rdoc inifile
$ ./script/plugin install https://github.com/ericpaulbishop/redmine_git_hosting.git

Edit the init file at /usr/share/redmine/vendor/plugins/redmine_git_hosting/init.rb
Change ‘httpServer’ to ‘redmine.example.com’
Change ‘gitServer’ to ‘redmine.example.com’
Change ‘gitUser’ to ‘gitolite’

Migrate the databases

$ rake db:migrate_plugins RAILS_ENV=production

Link the plugin assets files

$ cd /usr/share/redmine/public/plugin_assets
$ ln -s ../../vendor/plugins/redmine_git_hosting/assets ./redmine_git_hosting

Step 5: Add www-data to the sudoers file

$ visudo

Add these lines:

www-data    ALL=(gitolite) NOPASSWD:ALL
gitolite    ALL=(www-data) NOPASSWD:ALL

Step 6: Restart Apache

$ service apache2 restart

Step 7: Configure redmine settings

Log in to redmine and navigate to Administration→Plugins→Redmine Git Hosting Plugin→Configure

Set Automatically Initialize Git Repositories if you want to automatically create a new git repository when you create a project. This conflicts with using redmine for other types of repositories, though, so use it with caution.

You’re done!

Yay, you’re done! You have a fully working project management system, which can integrate with git and provide you with a git repository accessible through read-only git://, SSH, and Smart HTTP. For SSH, public-key authentication is used: you can upload your public key as part of your redmine user profile. For those less inclined to use SSH (for whatever reason), Smart HTTP is also configured by default, and can be logged in with your Redmine user credentials.

If you have any issues, make sure that you restart apache (and with it, Rails):

$ service apache2 restart

before debugging—this has resolved many a configuration issue. Note that unless you have set up a proper SSL certificate, git will refuse to clone from your repository over HTTPS (it gives a TLS error), so just enable Smart HTTP hosting on both HTTP and HTTPS in the Project→Settings→Repositories section.

What’s next?

If you would also like to put together a fully functional SVN hosting solution, check out http://aeturnalus.com/software/svn-repository-management-redmine-ubuntu-12-04/

Note that you will have to resolve conflicts between the two plugins as per http://aeturnalus.com/software/hacking-scm-creator-redmine-git-hosting-cooperate/, but it’s a fairly simple fix.

Installing Redmine is relatively simple on Ubuntu / Debian servers as compared to any other operating system, due to its inclusion into the APT repositories. As before, all terminal commands below are assumed to be executed from the root user via SSH.

Step One: Creating a Virtualmin Subserver

This part is pretty much self-explanatory: create a new subserver named “redmine.example.com” under the server “example.com” from the Virtualmin dashboard.

Step Two: Installing the packages

Through the wonder of apt-get, just follow the prompts given after the command below:

$ apt-get install redmine redmine-mysql libapache2-mod-passenger

Then, activate mod_passenger and mod_rewrite:

$ a2enmod passenger rewrite

Step Three: Configuring Apache

Virtualmin should have created a new virtualhost for you in /etc/apache2/sites-enabled/ named redmine.example.com.conf. Edit it, and replace its contents with something like the following:

<VirtualHost your-ip-here:80>
  SuexecUserGroup "#1010" "#1010"
  ServerName redmine.example.com
  DocumentRoot "/usr/share/redmine/public"
  PassengerResolveSymlinksInDocumentRoot on
  Options Indexes ExecCGI FollowSymlinks
  ErrorLog /var/log/virtualmin/redmine.example.com_error_log
  CustomLog /var/log/virtualmin/redmine.example.com_access_log combined
</VirtualHost>

Step Four: Configure Redmine

edit /etc/redmine/default/configuration.yml and add:

production:
 email_delivery:
  delivery_method: :sendmail

note the : in front of sendmail.

Step Five: Reload Apache

$ service apache2 reload

Step Six: Configure Redmine

Navigate to http://redmine.example.com and log in with the default admin / admin credentials. Change these via the “My Account” link, and then go to Administration→Settings and change the hostname from “localhost:3000″ to “redmine.example.com”

Further Configuration

At this point, you have a working Redmine install, which you can associate with repositories and begin work on. However, for a more complete system, visit the following tutorials:

Git: (better)

• Setting up Redmine Git Hosting

SVN:

• Setting up Redmine SVN Hosting

Both of these methods can be configured in the same Redmine install, but you will have to resolve conflicts between them as per http://aeturnalus.com/software/hacking-scm-creator-redmine-git-hosting-cooperate/.

Linode is one of the best low-cost Virtual Private Server Hosts available, offering Xen VPS Hosting for a number of popular operating systems. With the release of Ubuntu 12.04 LTS, I felt that it was past time that I upgraded my webserver (the one that runs this website, actually!), and document the little tweaks that I discovered along the way.

What we’re setting up

• Ubuntu 12.04 LTS
• A standard LAMP Stack (Linux, Apache, MySQL, PHP)
• BIND DNS resolution—combined with Virtualmin below, you’ll be able to manage your own domains!
• Linode reverse-DNS resolution
• Virtualmin / Webmin backend server management

Step One: Nameserver Configuration

Log on to your domain registrar and set the nameservers for your domain to

ns1.linode.com
ns2.linode.com
ns3.linode.com
ns4.linode.com
ns5.linode.com

We’ll be using Linode’s nameservers as our primary DNS providers because they’ll stay up even when the server is down—taking advantage of redundancy where we can. Since it takes a while for this DNS setting to propagate, this should be done well before any of the other parts of this tutorial.

Step Two: Linode Configuration

Setting up the slave zone
Log into Linode’s dashboard, and add your domain (hereafter referred to as example.com) to the DNS manager. Configure it as “Slave Zone”, and set the master server IP to the IP of your server. This will allow Linode to mirror your server’s DNS settings.

Deploying Ubuntu 12.04 LTS

Deploy Ubuntu 12.04 LTS to your Linode, using the standard “Deploy a Linux Distribution” Option. This will take a short while, and you’ll be asked to supply an administrator password to the system.

Once that’s done, remember to set up the reverse-DNS setting, available in the “Remote Access” tab. This should be set to hostname.example.com, although it isn’t particularly important. Also, enable IPv6; it’s used internally for DNS resolution and will cause issues if disabled.

While you’re here, take note of the IP configuration settings listed. The important values are the public IPs / masks, the default gateway, and the DNS resolvers.

Step Three: Ubuntu Configuration

Alright, now it’s time to actually begin to set up the server. All commands following will be given with the assumption that you are running as the root user. DO NOT use the root account as your primary login; it should be reserved for system administration roles as much as is possible.

Setting up the hostname

Edit /etc/hostname with your favorite editor and set it to your hostname of choice. The file should look something like this:

hostname

Afterwards, run the command

$ hostname -F /etc/hostname

to set it across the system.

Then, edit /etc/hosts to enable localhost resolution. The first two lines should look something like this:

127.0.0.1 localhost
your-ip-address hostname.example.com hostname

If you have trouble with this, take a look at Linode’s full guide here with regards to setting the hostname and hosts file.

To test, the command

$ hostname

should print the hostname of the server, and

$ hostname -f

should print hostname.example.com (or whatever you set as your Fully Qualified Domain Name).

Setting up a static IP
For some reason, Linode defaults its nodes to use DHCP; this will not work well with our BIND9 DNS server. So, using the settings you got from the Remote Access tab on the Dashboard, configure your /etc/network/interfaces file:

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
auto eth0
#iface eth0 inet dhcp
iface eth0 inet static
 address your-ip-address-here
 netmask 255.255.255.0
 gateway your-gateway-address-here

Edit May 1, 2012: Use Resolvconf directly instead of removing it.

View old version here: Expand

$ apt-get remove resolvconf

$ cat /etc/resolv.conf
domain members.linode.com
search members.linode.com
nameserver dns-resolver-1-ip-here
nameserver dns-resolver-2-ip-here
nameserver 127.0.0.1
options rotate

Ubuntu now ships with a dynamic resolv.conf manager called resolvconf, which handles editing /etc/resolv.conf for us. Thus, instead of editing /etc/resolv.conf, we can edit /etc/resolvconf/resolv.conf.d/base

$ cat /etc/resolvconf/resolv.conf.d/base
domain members.linode.com
search members.linode.com
nameserver dns-resolver-1-ip-here
nameserver dns-resolver-2-ip-here
nameserver 127.0.0.1
options rotate

Now, reload the resolvconf (or restart the server, since you’ve changed networking settings)

$ service resolvconf restart

Further details on resolv.conf and network interface configuration can be found in Linode’s documentation here.

Configuring the timezone

We can just use dpkg-reconfigure for this:

dpkg-reconfigure tzdata

Installing LAMP

Since Ubuntu is debian-based, the installation of LAMP is remarkably simple:

$ apt-get update
$ apt-get install lamp-server^

should do it—just follow the instructions that it gives you.

Installing Virtualmin and Webmin

Unfortunately, since Ubuntu 12.04 LTS just came out, Virtualmin doesn’t officially support it yet, but we can install it anyways!

Start by copying /etc/issue to a backup, so that we can trick Virtualmin into believing it’s installing on Ubuntu 10.04 LTS:

$ cp /etc/issue /etc/issue-bak

Edit /etc/issue, and replace “Ubuntu 12.04 LTS \n \l” with “Ubuntu 10.04.02 LTS”

Virtualmin depends on an scponly shell which Ubuntu has, for some reason, removed from the Precise Pangolin repositories. Nevertheless, we can just install the version from Oneiric, which works fine:

$ cd /tmp
$ wget http://security.ubuntu.com/ubuntu/pool/universe/s/scponly/scponly_4.8-4.1_i386.deb
$ dpkg -i scponly_4.8-4.1_i386.deb

Installing virtualmin itself: Virtualmin has kindly provided an install script for us, so we’ll just use that

$ cd /tmp
$ wget http://software.virtualmin.com/gpl/scripts/install.sh
$ chmod u+x install.sh
$ /tmp/install.sh

Now that that’s all done, we can revert our /etc/issue file back to what it should be

$ mv /etc/issue-bak /etc/issue

Setting up the Virtualmin Configuration

Initial configuration

Log on to your-ip-address:10000 to access the Virtualmin configuration panel. It should walk you through some initial setup options—you don’t need to change any of these.

After that’s done, go to Virtualmin→System Settings→Server Templates→BIND DNS Domains and find the Additional Manually Configured Nameservers box. Add these lines:

ns1.linode.com
ns2.linode.com
ns3.linode.com
ns4.linode.com
ns5.linode.com

Also, make sure that the option “Add sub-domain DNS records to parent’s domain” is set to “Yes”.

This will set up the Linode nameservers as slaves, and allow them to request zone transfers (AXFR and AXFR-style IXFR)

Now, go to Webmin→Servers→BIND DNS Server→Default Zone and set “Notify Slaves of Changes” to “Yes”.

To see if Linode is successfully duplicating your zone, view the syslog and watch for AXFR / IXFR transfers:

$ tail -f /var/log/syslog

BIND will automatically inform Linode when you’ve made a change to your DNS configuration.

Setting up your first Virtual Server

This part is pretty simple: just click “Create Virtual Server” on the Virtualmin dashboard, and give it the domain example.com. The rest should be handled for you.
After it’s been constructed, go to Virtualmin→Server Configuration→DNS Records and add a new A record for hostname.example.com, pointing at the IP Address of your hostname. This will serve as the primary forward-DNS for your server.

Final notes

Yay! You’ve set up a Ubuntu/Virtualmin-powered Linode, and you’re ready to host a website. Since BIND and Virtualmin are configured to create a new zone for each virtual server, the DNS configuration should be largely automatic—no more needing to set all the A records yourself.

There is one caveat, however: Linode’s Slave DNS Zones are configured NOT to allow subdomains to be controlled by separate DNS zones.

This means that if you want to serve a different website for a domain and its subdomain (“example.com” and “test.example.com”, for example), you will need to configure “test.example.com” as a SUB-SERVER in Virtualmin. Otherwise, Linode will NOT request the DNS records, and you will not be able to access the subdomain.

To configure email virus and spam scanning, take a look at Ubuntu’s official Amavis tutorial here.

In the meanwhile, a picture:

It can be viewed here: https://github.com/rbtying/Companion-Cube

Download here:

Robot Controller
Source code is released into the public domain, but if you use it, I’d appreciate it if you cite me somewhere (Robert Ying).

You’ll also need to have the appropriate rxtx native library in the same folder as the jar file when running it—you can download that here

Corresponding Arduino Code:

void setup() {
  Serial.begin(115200);
}

// method that sets motor speeds from -255 to 255
// corresponding to full reverse and full forward
void setLeftMotor(int speed);
void setRightMotor(int speed);

byte nextByte() {
  unsigned long start = millis();
  while (millis() - start < 100) {
    if (Serial.available()) {
      return Serial.read();
    }
  }
  return 0x00;
]

void loop() {
  while (Serial.available()) {
    switch(Serial.read()) {
      case 0xC1: setLeftMotor(2 * nextByte()); break;
      case 0xC2: setLeftMotor(-2 * nextByte()); break;
      case 0xC5: setRightMotor(2 * nextByte()); break;
      case 0xC6: setRightMotor(-2 * nextByte()); break;
      default: setLeftMotor(0); setRightMotor(0); break;
    }
  }
}

For the past two weekends I’ve been working on organizing and executing my Eagle project, which is to construct a pair of lecterns for Lynbrook High School. Noticing that we have a shortage of such pieces of furniture, and that they are rather expensive to acquire directly, I decided to build these lecterns to benefit both the faculty and the student population at my school.

I started my project by designing a quick 3D model to lay out the dimensions and get an idea of what it would look like:

And then built it over the course of a weekend with the help of scouts from my troop. This weekend, we put the finishing touches on it by staining and varnishing the wood, so that the color will last longer and the lectern will be sturdier and more durable in general.

A slideshow of the various service project sessions:

Scouts working on measuring and assembling parts of the first lectern

Some scouts marking out lines to be cut

Mr. Ying getting ready to cut some plywood

Scouts beginning to nail plywood to the frame underneath

A scout positioning a part to be glued.

Scouts working together to use the nailgun

A completed lectern! Not quite stained yet, though.

Scouts discussing what to do next

Scouts working outside

Two completed lecterns!

And the rest of the group...

Scouts beginning to stain the lectern

Scouts sanding down the surfaces

Some more staining

Sanding down the ... other ... lectern

Scouts applying varnish to the lecterns

Finishing up the varnish work

Scouts admiring their work

A few more scouts celebrating

A completed and finished project!

More details about the project can be found by reading my project reports, linked below:

• Day 1 Report
• Day 2 Report
• Day 3 and 4 Report

Thanks to all of the people who helped me out on this project!