carsten/teslausb
1
0
Fork 0
mirror of https://github.com/cimryan/teslausb.git synced 2026-02-28 20:20:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/cimryan/teslausb

Browse Source
This commit is contained in:
Richard Goodwin
2018-10-30 07:57:40 -05:00
parent 93bc41237c 1f7ff2d893
commit b8278dbde9
17 changed files with 600 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
README.md
View File

@@ -5,17 +5,12 @@ This repo contains steps and scripts originally from [this thread on Reddit]( ht
Many people in that thread suggested that the scripts be hosted on Github but the author didn't seem interested in making that happen. I've hosted the scripts here with his/her permission.
The original post on Reddit assumed that the archive would be hosted on Windows and that the Pi would be set up using a Windows machine but this Git repo welcomes the contribution of instructions for other platforms.
## Intro
You can configure a Raspberry Pi Zero W so that your Tesla thinks it's a USB drive and will write dashcam footage to it. Since it's a computer, you can run scripts on the Pi to automatically copy the clips to an archive server when you get home. The Pi is going to continually:
1. Wait until it can connect to the archive server
1. Archive the clips
1. Wait until it can't connect to the archive server
1. GOTO 1.
The scripts in this repo will also allow you to use the Pi to store music that the Tesla can read through the USB interface.
You can configure a Raspberry Pi Zero W so that your Tesla thinks it's a USB drive and will write dashcam footage to it. Since it's a computer:
* Scripts running on the Pi can automatically copy the clips to an archive server when you get home.
* The Pi can hold both dashcam clips and music files.
* The Pi can automatically repair filesystem corruption produced by the Tesla's current failure to properly dismount the USB drives before cutting power to the USB ports.
Archiving the clips can take from seconds to hours depending on how many clips you've saved and how strong the WiFi signal is in your Tesla. If you find that the clips aren't getting completely transferred before the car powers down after you park or before you leave you can use the Tesla app to turn on the Climate control. This will send power to the Raspberry Pi, allowing it to complete the archival operation.
@@ -24,14 +19,12 @@ Archiving the clips can take from seconds to hours depending on how many clips y
### Assumptions
* You park in range of your wireless network.
* Your wireless network is configured with WPA2 PSK access.
* You'll be archiving your dashcam clips to a Windows machine, and the Windows machine has a stable IP address on your home network.
* You'll be setting up the Raspberry Pi using a Windows machine.
### Hardware
Required:
* [Raspberry Pi Zero W](https://www.raspberrypi.org/products/raspberry-pi-zero-w/): [Adafruit](https://www.adafruit.com/product/3400) or [Amazon](https://www.amazon.com/Raspberry-Pi-Zero-Wireless-model/dp/B06XFZC3BX/)
> Note: Of the many varieties of Raspberry Pi only the Raspberry Pi Zero and Raspberry Pi Zero W can be used as simulated USB drives. It may be possible to use a Pi Zero with a USB Wifi adapter to achieve the same result as the Pi Zero W, but this hasn't been confirmed.
> Note: Of the many varieties of Raspberry Pi avaiable only the Raspberry Pi Zero and Raspberry Pi Zero W can be used as simulated USB drives. It may be possible to use a Pi Zero with a USB Wifi adapter to achieve the same result as the Pi Zero W but this hasn't been confirmed.
* A Micro SD card, at least 8 GB in size, and an adapter (if necessary) to connect the card to your computer.
* A mechanism to connect the Pi to the Tesla. Either:
@@ -39,79 +32,50 @@ Required:
* A USB A Add-on Board if you want to plug your Pi into your Tesla like a USB drive instead of using a cable. [Amazon](https://www.amazon.com/gp/product/B07BK2BR6C/)
Optional:
* A case. Don't want unprotected circuits hanging about! Official case at [Adafruit](https://www.adafruit.com/product/2885) or [Amazon](https://www.amazon.com/gp/product/B06Y593MHV). There are many others to choose from. Note that the official case won't work with the USB A Add on board.
* A case. The "Official" case: [Adafruit](https://www.adafruit.com/product/2885) or [Amazon](https://www.amazon.com/gp/product/B06Y593MHV). There are many others to choose from. Note that the official case won't work with the USB A Add on board.
* USB Splitter if you don't want to lose a front USB port. [The Onvian Splitter](https://www.amazon.com/gp/product/B01KX4TKH6) has been reported working by multiple people on reddit.
### Software
Download [Raspbian Stretch Lite](https://www.raspberrypi.org/downloads/raspbian/)
* Note: Bittorrent is dramatically faster than direct download.
Download: [Raspbian Stretch Lite](https://www.raspberrypi.org/downloads/raspbian/)
Download and install:
* [Etcher](http://etcher.io)
Download and install: [Etcher](http://etcher.io)
## Create your archive
### Hosting on Windows File Shares, MacOS Sharing, or Samba on Linux
Set up a share to host the archive. These instructions assume that you created a share named "SailfishCam" on the server "Nautilus". It is recommended that you create a new user. Grant the user you'll be using read/write access to the share. These instructions will assume that the user you've created is named "sailfish" and that the password for this user is "pa$$w0rd".
Get the IP address of the archive machine. You'll need this later, so write it down, somewhere.
* On Windows you can do this by opening a command prompt on the archive machine and typing ipconfig. Get the IP address from the line labeled "IPv4 Address". These instructions will assume that the IP address of the archive server is 192.168.0.41.
* On MacOS or Linux open a terminal and type ifconfig.
### Hosting via SFTP/rsync
**EXPERIMENTAL - Hosting the archive on SFTP hasn't been thoroughly tested**
Since sftp/rsync is accessing a computer through SSH, the only requirement for hosting an SFTP/rsync server is to have a box running Linux. An example can be another Raspberry Pi connected to your local network with a USB storage drive plugged in. The official Raspberry Pi site has a good example on [how to mount an external drive](https://www.raspberrypi.org/documentation/configuration/external-storage.md). You will need the username and host/IP of the storage server, as well as the path for the files to go in, and the storage server will need to allow SSH.
### ***TODO: Other hosting solutions***
## Set up the Raspberry Pi
There are three phases to setting up the Pi:
There are four phases to setting up the Pi:
1. Get the OS onto the micro sd card.
1. Get a shell on the Pi.
1. Set up the archive for dashcam clips.
1. Set up the USB storage functionality.
### Get the OS onto the micro SD card
There is a streamlined process for setting up the Pi which can currently be used if you plan to use Windows file shares, MacOS Sharing, or Samba on Linux for your video archive. [Instructions](doc/OneStepSetup.md).
If you'd like to host the archive using another technology or would like to set the Pi up, yourself, continue these instructions.
### Get the OS onto the MicroSD card
[These instructions](https://www.raspberrypi.org/documentation/installation/installing-images/README.md) tell you how to get Raspbian onto your MicroSD card. Basically:
1. Connect your SD card to your computer.
2. Use Etcher to write the zip file you downloaded to the SD card. Etcher works well and is multi-platform.
2. Use Etcher to write the zip file you downloaded to the SD card.
> Note: you don't need to uncompress the zip file you downloaded.
### Get a shell on the Pi
If you used a Windows computer to flash the OS onto the MicroSD card, follow these [Instructions](doc/GetShellWithoutMonitorOnWindows.md).
Follow the instructions corresponding to the OS you used to flash the OS onto the MicroSD card:
* Windows: [Instructions](doc/GetShellWithoutMonitorOnWindows.md).
* MacOS or Linux: [Instructions](doc/GetShellWithoutMonitorOnLinux.md).
If you used a Mac or a Linux computer, follow these [Instructions](doc/GetShellWithoutMonitorOnLinux.md).
Whichever instructions you followed above will leave you in a command shell on the Pi. Use this shell for the rest of the steps in these instructions.
### Set up the archive for dashcam clips
Follow the instructions corresponding to the technology you'd like to use to host the archive for your dashcam clips. You must choose just one of these technologies; don't follow more than one of these sets of instructions:
* Windows file share, MacOS Sharing, or Samba on Linux: [Instructions](doc/SetupShare.md).
* SFTP/rsync: [Instructions](doc/SetupRSync.md)
* **Experimental:** Google Drive, Amazon S3, DropBox, Microsoft OneDrive: [Instructions](doc/SetupRClone.md)
### Set up the USB storage functionality
Now that you have Wifi up and running, it's time to set up the USB storage and scripts that will manage the dashcam and (optionally) music storage.
1. SSH to the Pi and run
```
sudo -i
```
1. Try to ping your archive server from the Pi. In this example the server is named `nautilus`.
```
ping -c 3 nautilus
```
1. If the server can't be reached, ping its IP address:
```
ping 192.168.0.41
```
1. If you can't ping the archive server by IP address from the Pi, you should go do whatever you need to on your network to fix that. If you can't reach the archive server by name, from the Pi but you can by IP address, then use its IP address, below, in place of its name.
1. Determine how much, as a percentage, of the drive you want to allocate to recording dashcam footage by using:
1. Indicate how much, as a percentage, of the drive you want to allocate to recording dashcam footage by running this command:
```
export campercent=<number>
```
For example, using `export campercent=100` would allocate 100% of the space to recording footage from your car, and would not create a separate music partition. `export campercent=50` would be only allocate half of the space for a dashcam footage drive, and allocates the other half to be a music storage drive.
1. If you are trying to archive on an SFTP/rsync server, then follow these [instructions](doc/SetupRSync.md) and skip step 7. Otherwise, skip this step.
1. If you are trying to archive on a shared drive, run these commands, subsituting your values for your shared drive:
```
export archiveserver=Nautilus
export sharename=SailfishCam
export shareuser=sailfish
export sharepassword=pa$$w0rd
```
For example, using `export campercent=100` would allocate 100% of the space to recording footage from your car, and would not create a separate music partition. `export campercent=50` would allocate half of the space for a dashcam footage drive and allocates the other half to for a music storage drive.
1. If you'd like to receive a text message when your Pi finishes archiving clips follow these [Instructions](doc/ConfigureNotificationsForArchive.md).
1. Run these commands:
```
@@ -134,7 +98,7 @@ Connect the Pi to a computer. If you're using a cable be sure to use the port la
1. Wait for the Pi to show up on the computer as a USB drive.
1. Copy any music you'd like to the drive labeled MUSIC.
1. Eject the drives.
1. Unplug the Pi from the PC.
1. Unplug the Pi from the computer.
1. Plug the Pi into your Tesla.
## Making changes to the system after setup

135
doc/OneStepSetup.md Normal file
View File

@@ -0,0 +1,135 @@
# One-step setup
This is a streamlined process for setting up the Pi. You'll flash a preconfigured version of Raspbian Stretch Lite and then fill out a config file.
## Notes
* Assumes your Pi has access to Wifi, with internet access (during setup). (But all setup methods do currently.) USB networking is still enabled for troubleshooting or manual setup
* This image will work for either _headless_ (tested) or _manual_ (tested less) setup.
* Currently not tested with the RSYNC/SFTP method when using headless setup.
## Configure the SD card before first boot of the Pi
1. Flash the [latest image release](https://github.com/rtgoodwin/teslausb/releases) using Etcher or similar.
### For headless (automatic) setup
1. Mount the card again, and in the `boot` directory create a `teslausb_setup_variables.conf` file to export the same environment varibles normally needed for manual setup (including archive info, Wifi, and push notifications (if desired).
A sample conf file is located in the `boot` folder on the SD card.
The file should contain the entries below at a minimum, but **replace with your own values**:
```
export archiveserver=Nautilus
export sharename=SailfishCam
export shareuser=sailfish
export sharepassword=pa$$w0rd
export campercent=100
export SSID=your_ssid
export WIFIPASS=your_wifi_password
export HEADLESS_SETUP=true
# export REPO=rtgoodwin
# export BRANCH=headless-patch
# By default will use the main repo, but if you've been asked to test the image,
# these variables should be uncommunted and updated to point to the right repo/branch
# export pushover_enabled=false
# export pushover_user_key=user_key
# export pushover_app_key=app_key
```
* Boot it in your Pi, give it a bit, watching for a series of flashes (2, 3, 4, 5) and then a reboot and/or the CAM/music drives to become available on your PC/Mac. The LED flash stages are:
| Stage (number of flashes) | Activity |
|---|---|
| 2 | Verify setup variables |
| 3 | Grab scripts to start/continue setup |
| 4 | Create partition and files to store camera clips/music) |
| 5 | Setup completed; remounting filesystems as read-only and rebooting |
* The Pi should be available for `ssh` at `pi@teslausb.local`, over Wifi (if automatic setup works) or USB networking (if it doesn't). It takes about 5 minutes, or more depending on network speed, etc.
* If plugged into just a power source, or your car, give it a few minutes until the LED starts pulsing steadily which means the archive loop is running and you're good to go.
* You should see in `/boot` the `TESLAUSB_SETUP_FINISHED` and `WIFI_ENABLED` files as markers of headless setup success as well.
### For manual setup
1. After flashing the image, boot it in your Pi and:
* connect via USB networking at `ssh pi@teslausb.local`. (The Pi must be connected to your PC and plugged into the port labeled USB on the Pi. Or...
* You can also just automate the Wifi portion of setup by creating the `boot/teslausb_setup_variables.conf` file and populating it with the `SSID` and `WIFIPASS` variables:
```
export SSID=your_ssid
export WIFIPASS=your_wifi_pass
```
1. Once you have an `ssh` session, follow the steps starting at [Set up the USB storage functionality](https://github.com/cimryan/teslausb#set-up-the-usb-storage-functionality) in the main guide.
### Troubleshooting
#### Headless (full or Wifi) setup
* `ssh` to `pi@teslausb.local` (assuming Wifi came up, or your Pi is connected to your computer via USB) and look at the `/boot/teslausb-headless-setup.log`.
* Try `sudo -i` and then run `/etc/rc.local`. The scripts are fairly resilient to restarting and not re-running previous steps, and will tell you about progress/failure.
* If Wifi didn't come up:
* Double-check the SSID and WIFIPASS variables in `teslausb_setup_variables.conf`, and remove `/boot/WIFI_ENABLED`, then booting the SD in your Pi to retry automatic Wifi setup.
* If still no go, re-run `/etc/rc.local`
* If all else fails, copy `/boot/wpa_supplicant.conf.sample` to `/boot/wpa_supplicant.conf` and edit out the `TEMP` variables to your desired settings.
* (Note: if you get an error about `read-only filesystem`, you may have to `sudo -i` and run `/root/bin/remountfs_rw`.
# Background information
## What happens under the covers
When the Pi boots the first time:
* A `/boot/teslausb-headless-setup.log` file will be created and stages logged.
* Marker files will be created in `boot` like `TESLA_USB_SETUP_STARTED` and `TESLA_USB_SETUP_FINISHED` to track progress.
* Wifi is detected by looking for `/boot/WIFI_ENABLED` and if not, creates the `wpa_supplicant.conf` file in place, using `SSID` and `WIFIPASS` from `teslausb_setup_varibles.conf` and reboots.
* The Pi LED will flash patterns (2, 3, 4, 5) as it gets to each stage (labeled in the setup-teslausb-headless script).
* ~~10 flashes means setup failed!~~ (not currently working)
* After the final stage and reboot the LED will go back to normal. Remember, the step to remount the filesystem takes a few minutes.
At this point the next boot should start the Dashcam/music drives like normal. If you're watching the LED it will start flashing every 1 second, which is the archive loop running.
> NOTE: Don't delete the `TESLAUSB_SETUP_FINISHED` or `WIFI_ENABLED` files. This is how the system knows setup is complete.
### Image builder source and patches
For now the image creation work is at:
* Modified pi-gen [rtgoodwin's fork of pi-gen](https://github.com/rtgoodwin/pi-gen) in (whatever current branch I'm working at the time).
### Image refinement TODOs
1. ~~Patch the hostname to teslausb~~
1. Make it so if someone deletes the `TESLAUSB_SETUP_FINISHED` file it's handled gracefully. (Right now it will try to re-run setup which should be fine.)
1. Cache the remount packages? Might mess with first boot like `rsyslog`
1. Aspirational TODO: Remove more packages and set services to stopped to make the boot process faster?
1. At this point, it's designed to pull the setup scripts _dynamically_, since development is still ongoing. If/when we reach a good frozen state, we can generate an image that is essentially ready to run. I think it'll also be pretty tricky to do some of the remounting and creating the backing files etc. on the image creation side. Open to suggestions/contributions there though!
#### Modifications to pi-gen builder from master
The image is built on a Raspberry Pi 3B running Stretch, for maximum Pi-ception.
This is the basic configuration, but it's helpful to just [look at the code itself](https://github.com/rtgoodwin/pi-gen/tree/teslausb-headless-image) and the Readme for Pi-gen which explains this all in much greater detail:
1. Added SKIP and SKIP_IMAGES files to stage3, 4, and 5 (if present). We want to build the default image up to stage2, then add our own stage for tweaks we want.
1. Added a `stage6` (or 7, just something beyond stage5). (There are stages 0-4 in the main Raspbian pi-gen repo by default, but may be a stage5 in some cases. This will help keep a clean merge later.)
1. Copy the prerun.sh from `stage2`. Be SURE to `chmod +x` it.
1. Remove or rename the EXPORT_NOOBS files in all stages. We don't need a NOOBS image built.
1. In `stage6`, create a `00-tweaks` folder, with a `00-patches` folder and patches inside. Currently patched:
| File | Change |
|---|---|
| `cmdline.txt`| Add the dwc2,g_ether modules |
| `config.txt`| Add the dwc2 module |
| `hosts` | Change hostname to `teslausb` |
| `hostname` | Change hostname to `teslausb` |
* The build process uses `quilt` for patching
* The path for any patching you do at this stage is `stage6/rootfs/FILEPATH` where `rootfs` represents the Pi's `/`. So, `cmdline.txt` is `stage6/rootfs/boot/cmdline.txt`.
1. Added a file called `series` in the patches directory with the name of each `.diff` file in the order you want them applied.
1. Added a `files` folder in stage6 with modified `rc.local`, and whatever else you want copied into the image. The modified `rc.local` will handle pulling down the `setup-teslausb-headless` file the first time and doing Wifi setup.
1. Added a script to flash the Pi LED
1. Files are moved into final locations using the `00-run.sh` script using the `install` command. See the script for details. I also `touch /boot/ssh` here so SSH is ready out of the box.
1. Run `sudo ./build.sh` from the `pi-gen` directory.
1. If you get a failure, it's almost certainly after stage2, so you can add SKIP files in all successful stages and rerun `sudo CLEAN=1 ./build.sh`

93
doc/SetupRClone.md Normal file
View File

@@ -0,0 +1,93 @@
# Introduction
This guide will show you how to install and configure [rclone4pi](https://github.com/pageauc/rclone4pi/wiki) (based off [rclone](https://rclone.org/)) to archive your saved TeslaCam footage on one of a number of different remote storage services including Google Drive, S3 and Dropbox.
You must perform these steps **after** getting a shell on the Pi and **before** running the `setup-teslacam` script on the Pi.
**Make sure to run all commands in these instructions in a single command shell as root. When you return to the [Main Instructions](/README.md) continue running the commands there in this same shell.** This is necessary because:
* The `archiveloop` script runs as root and the rclone config is bound to the user running the config.
* These commands define environment variables that the main setup scripts need.
# Quick guide
These instructions will speed you through the process with good defaults. If you encounter an error, or you want to use a different config name than `gdrive` or a different folder name than `TeslaCam`, follow the detailed instuctions, below.
1. Run these commands. Specify the config name `gdrive` when prompted for the config name.
```
sudo -i
curl -L https://raw.github.com/pageauc/rclone4pi/master/rclone-install.sh | bash
rclone config
```
1. Run these commands:
```
export RCLONE_ENABLE=true
export RCLONE_DRIVE=gdrive
export RCLONE_PATH=TeslaCam
rclone mkdir "$RCLONE_DRIVE:$RCLONE_PATH"
rclone lsd "$RCLONE_DRIVE":
```
1. If you didn't encounter any error messages and you see the `TeslaCam` directory listed return to the [Main Instructions](../README.md).
# Detailed instructions
## Step 1: Install rclone4pi
1. Run this command to enter a command shell for the root user.
```
sudo -i
```
2. Run the following command to install rclone4pi:
```
curl -L https://raw.github.com/pageauc/rclone4pi/master/rclone-install.sh | bash
```
Alternatively, you can install rclone4pi manually by following these [instructions] (https://github.com/pageauc/rclone4pi/wiki#manual-install).
# Step 2: Configure the archive
1. Run this command to configure an archive:
```
rclone config
```
This will launch an interactive setup with a series of questions. It is recommended that you look at the documentation for your storage system by going to [rclone](https://rclone.org/) and selecting your storage system from the pull down menu at the stop.
It has been confirmed that this process works with Google Drive using these [instructions](https://rclone.org/drive/). If you are using another storage system, please feel encouraged to create an "Issue" describing your challenges and/or your success.
If you are using Google Drive it is important to set the correct [scope](https://rclone.org/drive/#scopes). Carefully read the documentation on [scopes on rclone](https://rclone.org/drive/#scopes) as well as [Google Drive](https://developers.google.com/drive/api/v3/about-auth). The `drive.file` scope is recommended.
**Important:** During the `rclone config` process you will sepcify a name for the configuration. The rest of the document will assume the use of the name `gdrive`; replace this with your chosen configuration name.
1. Run this command:
```
export RCLONE_DRIVE="gdrive"
```
# Step 3: Verify and create storage directory
1. Run the following command to see the name of the remote drive you just created.
```
rclone listremotes
```
If you don't see the name there, something went wrong. Go back through the `rclone config` process.
1. Run this command:
```
rclone lsd "$RCLONE_DRIVE":
```
You should not see any files listed. If you do then you did not set your scope correctly during the `rclone config` process.
1. Choose the name of a folder to hold the archived clips. These instructions will assume you chose the name `TeslaCam`. Substitute the name you chose for this name. Run this command:
```
export RCLONE_PATH="TeslaCam"
```
1. Run the following command to create a folder which will hold the archived clips.
```
rclone mkdir "$RCLONE_DRIVE:TeslaCam"
```
1. Run this command again:
```
rclone lsd "RCLONE_DRIVE":
```
Confirm that the directory `TeslaCam` is present. If not, start over.
# Step 4: Exports
Run this command to cause the setup processes which you'll resume in the main instructions to use rclone4pi:
```
export RCLONE_ENABLE=true
```
**Note:** `RCLONE_ENABLE=true` is going to disable the default archive server. It also will **not** play nicely with `RSYNC_ENABLE=true` Perhaps future releases will allow both to be defined and function at the same time, for redundancy, but for now just pick one that you'll want the most.
Now return to the section "Set up the USB storage functionality" in the [main instructions](../README.md).

38
doc/SetupRSync.md
View File

@@ -1,21 +1,33 @@
# Introduction
This guide will show you how to utilize [rsync](https://rsync.samba.org/) to archive your saved TeslaCam footage on a remote storage server. In my case, I use this for a networked pi storage server.
This guide will show you how to use [rsync](https://rsync.samba.org/) to archive your saved TeslaCam footage on a remote storage server.
Since sftp/rsync accesses a computer through SSH the only requirement for hosting an SFTP/rsync server is to have a box running SSH. For example, you could use another Raspberry Pi connected to your local network with a USB storage drive plugged in. The official Raspberry Pi site has a good example on [how to mount an external drive](https://www.raspberrypi.org/documentation/configuration/external-storage.md).
You will need the username and host/IP of the storage server, as well as the path for the files to go in, and the storage server will need to allow SSH.
This guide makes the following assumptions:
1. You are running your own ftp/rsync server that you have admin rights to, or can at least add a public key to its `~/.ssh/authorized_keys` file
1. The ftp/rsync server has rsync installed (raspbian automatically does)
2. You have **NOT** run the `setup-teslacam` script yet
* You are running your own ftp/rsync server that you have admin rights to, or can at least add a public key to its `~/.ssh/authorized_keys` file.
* The ftp/rsync server has rsync installed (raspbian automatically does)
# Step 1: Authentication
Similar to sftp, rsync by default utilizes ssh to connect to a remote server and transfer files. This guide will use a generated ssh keypair, hence the first assumption above.
Similar to sftp, rsync by default uses ssh to connect to a remote server and transfer files. This guide will use a generated ssh keypair, hence the first assumption above.
1. On your teslausb pi, run `ssh-keygen` to generate an ssh key **for the ROOT user!** If you followed the previous steps, you should have already ran `sudo -i` to become the root user on the telsausb pi. If you didn't, run `sudo -i` and re-run `ssh-keygen`. You can be sure that it is generating for root if it asks to store the key in `/root/.ssh/` (versus something like `/home/pi/.ssh`).
1. Run these commands to to generate an ssh key for the `root` user:
```
sudo -i
ssh-keygen
```
1. Add the contents of the newly generated `/root/.ssh/id_rsa.pub` file from your teslausb pi to the storage server's `~/.ssh/authorized_keys` file. This will allow a nice and easy connection through rsync, no passwords needed!
1. Add the contents of the newly generated `/root/.ssh/id_rsa.pub` file from your teslausb pi to the storage server's `~/.ssh/authorized_keys` file. You can do this by connectin via ssh to the archive server from the computer you're using to set up the Pi, editing the `~/.ssh/authorized_keys` in nano, and pasting in the content of the `/root/.ssh/id_rsa.pub` file from the teslausb Pi.
1. Lastly, you will need to authorize the connection to the FTP/Rsync server and test that the key works, so try connecting to the server (through ssh), and **if it asks if you wish to continue connecting, make sure to type `yes`!** If you do not do this, rsync will fail to connect and thus fail to archive your clips.
1. Lastly, you will need to authorize the connection to the FTP/Rsync server and test that the key works, so try connecting to the server (through ssh), and **when you are asked if you wish to continue connecting type `yes`**
```
ssh user@archiveserver
```
If you do not do this then rsync will fail to connect and thus fail to archive your clips.
# Step 2: Exports
To be able to configure the teslausb pi use rsync, you'll need to export a few things. On your teslausb pi, run:
Run this command to cause the setup processes which you'll resume in the main instructions to use rsync:
```
export RSYNC_ENABLE=true
@@ -23,21 +35,17 @@ export RSYNC_USER=<ftp username>
export RSYNC_SERVER=<ftp IP/host>
export RSYNC_PATH=<destination path to save in>
```
Explanations for each:
* `RSYNC_ENABLE`: `true` for enabling rsync
* `RSYNC_USER`: The user on the FTP server
* `RSYNC_SERVER`: The IP address/hostname of the destination machine
* `RSYNC_PATH`: The path on the destination machine where the files will be saved
An example (of my) config is listed below:
An example config is below:
```
export RSYNC_ENABLE=true
export RSYNC_USER=pi
export RSYNC_SERVER=192.168.1.254
export RSYNC_PATH=/mnt/PIHDD/TeslaCam/
```
***Note: RSYNC_ENABLE=true is going to disable the default archive server. Perhaps future releases will allow both to be defined and function at the same time, for redundancy, but for now just pick one that you'll want the most.***
You should be ready to run the setup script now, so return back to step 8 of the [Main Instructions](README.md).
Now return to the section "Set up the USB storage functionality" in the [main instructions](../README.md).

32
doc/SetupShare.md Normal file
View File

@@ -0,0 +1,32 @@
# Hosting the archive on Windows File Shares, MacOS Sharing, or Samba on Linux
Set up a share to host the archive on a computer on your home network. These instructions assume that you created a share named "SailfishCam" on the server "Nautilus".
It is recommended that you create a new user. Grant the user you'll be using read/write access to the share. These instructions will assume that the user you've created is named "sailfish" and that the password for this user is "pa$$w0rd".
Now, on the Pi:
1. Try to ping your archive server from the Pi. In this example the server is named `nautilus`.
```
ping -c 3 nautilus
```
1. If the server can't be reached, ping its IP address (These instructions will assume that the IP address of the archive server is `192.168.0.41`.):
```
ping 192.168.0.41
```
To get the IP address of the archive machine:
* On Windows: Open a PowerShell session and type `ipconfig`. Get the IP address from the line labeled "IPv4 Address".
* On MacOS or Linux open a terminal and type ifconfig.
If you can't ping the archive server by IP address from the Pi, go do whatever you need to on your network to fix that.
If you can't reach the archive server by name but you can by IP address then use its IP address, below, for the `archiveserver` variable.
1. Run these commands, subsituting your values:
```
sudo -i
export archiveserver="Nautilus"
export sharename="SailfishCam"
export shareuser="sailfish"
export sharepassword="pa$$w0rd"
```
Now return to the section "Set up the USB storage functionality" in the [main instructions](/README.md).

43
doc/teslausb_setup_variables.conf.sample Normal file
View File

@@ -0,0 +1,43 @@
#####################################################################
# SAMPLE CONFIGURATION FILE FOR TESLAUSB Pi Setup
#
# Example config file for teslausb_setup. Lines with "#" are comments/ignored.
# Remove the "#" before "export" to activate a line. Be sure to rename this file
# to "teslausb_setup_variables.conf" and place it in the "boot" folder of your
# SD card.
#
######################################################################
# Default variables for CIFS (Windows/Mac file sharing) setup
export archiveserver=your_archive_name_or_ip
export sharename=your_archive_share_name
export shareuser=username
export sharepassword=password
export campercent=100
# Wifi setup information
export SSID=your_ssid
export WIFIPASS=your_pass
# If doing a headless (i.e. automatic) setup
export HEADLESS_SETUP=true
# Uncomment if setting up Pushover push notifications
# export pushover_enabled=false
# export pushover_user_key=user_key
# export pushover_app_key=app_key
# Uncomment and change if you want setup scripts to be pulled
# from a different repo than the "main" github.com/cimryan/teslausb
# export REPO=cimryan
# Uncomment and change if you want a different branch than master
# export BRANCH=master
# Uncomment if you're using rsync/ssh for the archive.
# Note: RSYNC is not usable for headless setup since it currently requires a manual step.
# Note: RSYNC_ENABLE=true is going to disable the default archive server.
# export RSYNC_ENABLE=true
# export RSYNC_USER=<ftp username>
# export RSYNC_SERVER=<ftp IP/host>
# export RSYNC_PATH=<destination path to save in>

2
run/archiveloop
View File

@@ -159,7 +159,7 @@ function wait_for_archive_to_be_unreachable () {
log "Waiting for archive to be unreachable..."
while [ true ]
do
if ! archive_is_reachable
if ! retry archive_is_reachable
then
log "Archive is unreachable."
break

3
run/cifs_archive/archive-clips.sh
View File

@@ -19,6 +19,9 @@ for file_name in "$CAM_MOUNT"/TeslaCam/saved*; do
done
log "Moved $NUM_FILES_MOVED file(s)."
if [ $NUM_FILES_MOVED -gt 0 ]
then
/root/bin/send-pushover "$NUM_FILES_MOVED"
fi
log "Finished moving clips to archive."

20
run/rclone_archive/archive-clips.sh Normal file
View File

@@ -0,0 +1,20 @@
#!/bin/bash -eu
log "Moving clips to rclone archive..."
source /root/.teslaCamRcloneConfig
NUM_FILES_MOVED=0
for file_name in "$CAM_MOUNT"/TeslaCam/saved*; do
[ -e "$file_name" ] || continue
log "Moving $file_name ..."
rclone --config /root/.config/rclone/rclone.conf move "$file_name" "$drive:$path" >> "$LOG_FILE" 2>&1 || echo ""
log "Moved $file_name."
NUM_FILES_MOVED=$((NUM_FILES_MOVED + 1))
done
log "Moved $NUM_FILES_MOVED file(s)."
/root/bin/send-pushover "$NUM_FILES_MOVED"
log "Finished moving clips to rclone archive"

10
run/rclone_archive/configure-archive.sh Normal file
View File

@@ -0,0 +1,10 @@
#!/bin/bash -eu
function configure_archive () {
echo "Configuring the archive for Rclone..."
echo "drive=$RCLONE_DRIVE" > /root/.teslaCamRcloneConfig
echo "path=$RCLONE_PATH" >> /root/.teslaCamRcloneConfig
}
configure_archive

2
run/rclone_archive/connect-archive.sh Normal file
View File

@@ -0,0 +1,2 @@
#!/bin/bash -eu
# Nothing to do.

2
run/rclone_archive/disconnect-archive.sh Normal file
View File

@@ -0,0 +1,2 @@
#!/bin/bash -eu
# Nothing to do.

1
run/rclone_archive/verify-archive-configuration.sh Normal file
View File

@@ -0,0 +1 @@
#!/bin/bash -eu

2
run/rsync_archive/archive-clips.sh
View File

@@ -4,7 +4,7 @@ log "Archiving through rsync..."
source /root/.teslaCamRsyncConfig
num_files_moved=$(rsync -auvh --stats --log-file=/tmp/archive-rsync-cmd.log /mnt/cam/TeslaCam/saved* $user@$server:$path | awk '/files transferred/{print $NF}')
num_files_moved=$(rsync -auzvh --no-perms --stats --log-file=/tmp/archive-rsync-cmd.log /mnt/cam/TeslaCam/saved* $user@$server:$path | awk '/files transferred/{print $NF}')
/root/bin/send-pushover "$num_files_moved"

25
setup/pi/create-backingfiles-partition.sh
View File

@@ -1,16 +1,27 @@
#!/bin/bash -eu
BACKINGFILES_MOUNTPOINT="$1"
PARTITION_TABLE=$(parted -m /dev/mmcblk0 unit s print)
ROOT_PARTITION_LINE=$(echo "$PARTITION_TABLE" | grep -e "^2:")
LAST_ROOT_PARTITION_SECTOR=$(echo "$ROOT_PARTITION_LINE" | sed 's/s//g' | cut -d ":" -f 3)
MUTABLE_MOUNTPOINT="$2"
FIRST_BACKINGFILES_PARTITION_SECTOR=$(( $LAST_ROOT_PARTITION_SECTOR + 1 ))
PARTITION_TABLE=$(parted -m /dev/mmcblk0 unit B print)
DISK_LINE=$(echo "$PARTITION_TABLE" | grep -e "^/dev/mmcblk0:")
DISK_SIZE=$(echo "$DISK_LINE" | cut -d ":" -f 2 | sed 's/B//' )
ROOT_PARTITION_LINE=$(echo "$PARTITION_TABLE" | grep -e "^2:")
LAST_ROOT_PARTITION_BYTE=$(echo "$ROOT_PARTITION_LINE" | sed 's/B//g' | cut -d ":" -f 3)
FIRST_BACKINGFILES_PARTITION_BYTE="$(( $LAST_ROOT_PARTITION_BYTE + 1 ))"
LAST_BACKINGFILES_PARTITION_DESIRED_BYTE="$(( $DISK_SIZE - (100 * (2 ** 20)) - 1))"
ORIGINAL_DISK_IDENTIFIER=$( fdisk -l /dev/mmcblk0 | grep -e "^Disk identifier" | sed "s/Disk identifier: 0x//" )
parted -m /dev/mmcblk0 u s mkpart primary ext4 "$FIRST_BACKINGFILES_PARTITION_SECTOR" 100%
BACKINGFILES_PARTITION_END_SPEC="$(( $LAST_BACKINGFILES_PARTITION_DESIRED_BYTE / 1000000 ))M"
parted -a optimal -m /dev/mmcblk0 unit B mkpart primary ext4 "$FIRST_BACKINGFILES_PARTITION_BYTE" "$BACKINGFILES_PARTITION_END_SPEC"
LAST_BACKINGFILES_PARTITION_BYTE=$(parted -m /dev/mmcblk0 unit B print | grep -e "^3:" | cut -d ":" -f 3 | sed 's/B//g' )
MUTABLE_PARTITION_START_SPEC="$(( $LAST_BACKINGFILES_PARTITION_BYTE / 1000000 ))M"
parted -a optimal -m /dev/mmcblk0 unit B mkpart primary ext4 "$MUTABLE_PARTITION_START_SPEC" 100%
NEW_DISK_IDENTIFIER=$( fdisk -l /dev/mmcblk0 | grep -e "^Disk identifier" | sed "s/Disk identifier: 0x//" )
@@ -18,5 +29,7 @@ sed -i "s/${ORIGINAL_DISK_IDENTIFIER}/${NEW_DISK_IDENTIFIER}/g" /etc/fstab
sed -i "s/${ORIGINAL_DISK_IDENTIFIER}/${NEW_DISK_IDENTIFIER}/" /boot/cmdline.txt
mkfs.ext4 -F /dev/mmcblk0p3
mkfs.ext4 -F /dev/mmcblk0p4
echo "/dev/mmcblk0p3 $BACKINGFILES_MOUNTPOINT ext4 auto,rw,noatime 0 2" >> /etc/fstab
echo "/dev/mmcblk0p4 $MUTABLE_MOUNTPOINT ext4 auto,rw 0 2" >> /etc/fstab

33
setup/pi/make-root-fs-readonly.sh
View File

@@ -10,7 +10,7 @@ function append_cmdline_txt_param() {
echo "Updating package index files..."
apt-get update
echo "Removing unwanted packages..."
apt-get remove -y --force-yes --purge triggerhappy logrotate dphys-swapfile fake-hwclock
apt-get remove -y --force-yes --purge triggerhappy logrotate dphys-swapfile
apt-get -y --force-yes autoremove --purge
# Replace log management with busybox (use logread if needed)
echo "Installing ntp and busybox-syslogd..."
@@ -22,6 +22,37 @@ append_cmdline_txt_param fastboot
append_cmdline_txt_param noswap
append_cmdline_txt_param ro
# Move fake-hwclock.data to /mutable directory so it can be updated
if ! findmnt --mountpoint /mutable
then
echo "Mounting the multable partition..."
mount /mutable
echo "Mounted."
fi
if [ ! -e "/mutable/etc" ]
then
mkdir -p /mutable/etc
fi
if [ -e "/etc/fake-hwclock.data" ]
then
echo "Moving fake-hwclock data"
cp /etc/fake-hwclock.data /mutable/etc/fake-hwclock.data
rm /etc/fake-hwclock.data
ln -s /mutable/etc/fake-hwclock.data /etc/fake-hwclock.data
fi
# Move rclone configs if it exists so we can write to it
if [ ! -e "/mutable/configs" ]
then
mkdir -p /mutable/configs
fi
if [ -e "/root/.config/rclone/rclone.conf" ]
then
echo "Moving rclone configs"
mv /root/.config/rclone /mutable/configs
ln -s /mutable/configs/rclone /root/.config/rclone
fi
# Move /var/spool to /tmp
rm -rf /var/spool
ln -s /tmp /var/spool

187
setup/pi/setup-teslausb
View File

@@ -1,22 +1,91 @@
#!/bin/bash -eu
USER_ENABLED_PUSHOVER=false
USER_ENABLED_PUSHOVER=${USER_ENABLED_PUSHOVER:-false}
SETUP_LOGFILE=/boot/teslausb-headless-setup.log
REPO=${REPO:-cimryan}
BRANCH=${BRANCH:-master}
HEADLESS_SETUP=${HEADLESS_SETUP:-false}
USE_LED_FOR_SETUP_PROGRESS=true
if ! [ $(id -u) = 0 ]
then
echo "STOP: Run sudo -i."
setup_progress "STOP: Run sudo -i."
exit 1
fi
function setup_progress () {
if [ $HEADLESS_SETUP = "true" ]
then
echo "$( date ) : $1" >> "$SETUP_LOGFILE"
fi
echo $1
}
function headless_setup_populate_variables () {
# Pull in the conf file variables to make avail to this script and subscripts
if [ -e /boot/teslausb_setup_variables.conf ] && [ $HEADLESS_SETUP = "true" ]
then
source /boot/teslausb_setup_variables.conf
fi
}
function headless_setup_mark_setup_failed () {
if [ $HEADLESS_SETUP = "true" ]
then
setup_progress "ERROR: Setup Failed."
touch /boot/TESLAUSB_SETUP_FAILED
fi
}
function headless_setup_mark_setup_success () {
if [ $HEADLESS_SETUP = "true" ]
then
if [ -e /boot/TESLAUSB_SETUP_FAILED ]
then
rm /boot/TESLAUSB_SETUP_FAILED
fi
rm /boot/TESLAUSB_SETUP_STARTED
touch /boot/TESLAUSB_SETUP_FINISHED
# This sed shouldn't be needed, but double checking just to be sure.
sed -i'.bak' -e "s/TEMPARCHIVESERVER/$archiveserver/g" /etc/rc.local
setup_progress "Main setup completed. Remounting file systems read only."
fi
}
function headless_setup_progress_flash () {
if [ $USE_LED_FOR_SETUP_PROGRESS = "true" ] && [ $HEADLESS_SETUP = "true" ]
then
/etc/stage_flash $1
fi
}
function setup_led_off () {
if [ $USE_LED_FOR_SETUP_PROGRESS = "true" ] && [ $HEADLESS_SETUP = "true" ]
then
echo "none" | sudo tee /sys/class/leds/led0/trigger > /dev/null
echo 1 | sudo tee /sys/class/leds/led0/brightness > /dev/null
fi
}
function setup_led_on () {
if [ $USE_LED_FOR_SETUP_PROGRESS = "true" ] && [ $HEADLESS_SETUP = "true" ]
then
echo 0 | sudo tee /sys/class/leds/led0/brightness > /dev/null
fi
}
function check_variable () {
local var_name="$1"
if [ -z "${!var_name+x}" ]
then
echo "STOP: Define the variable $var_name like this: export $var_name=value"
setup_progress "STOP: Define the variable $var_name like this: export $var_name=value"
exit 1
fi
}
@@ -26,14 +95,14 @@ function check_pushover_enabled () {
then
if [ ! -n "${pushover_user_key+x}" ] || [ ! -n "${pushover_app_key+x}" ]
then
echo "STOP: You're trying to setup Pushover but didn't provide your User and/or App key."
echo "Define the variables like this:"
echo "export pushover_user_key=put_your_userkey_here"
echo "export pushover_app_key=put_your_appkey_here"
setup_progress "STOP: You're trying to setup Pushover but didn't provide your User and/or App key."
setup_progress "Define the variables like this:"
setup_progress "export pushover_user_key=put_your_userkey_here"
setup_progress "export pushover_app_key=put_your_appkey_here"
exit 1
elif [ "${pushover_user_key}" = "put_your_userkey_here" ] || [ "${pushover_app_key}" = "put_your_appkey_here" ]
then
echo "STOP: You're trying to setup Pushover, but didn't replace the default User and App key values."
setup_progress "STOP: You're trying to setup Pushover, but didn't replace the default User and App key values."
exit 1
else
USER_ENABLED_PUSHOVER=true
@@ -45,17 +114,17 @@ function check_pushover_enabled () {
}
function check_available_space () {
echo "Verifying that there is sufficient space available on the MicroSD card..."
setup_progress "Verifying that there is sufficient space available on the MicroSD card..."
local available_space="$( parted -m /dev/mmcblk0 u b print free | tail -1 | cut -d ":" -f 4 | sed 's/B//g' )"
if [ "$available_space" -lt 4294967296 ]
then
echo "STOP: The MicroSD card is too small."
setup_progress "STOP: The MicroSD card is too small."
exit 1
fi
echo "There is sufficient space available."
setup_progress "There is sufficient space available."
}
function get_script () {
@@ -63,8 +132,10 @@ function get_script () {
local name="$2"
local remote_path="${3:-}"
wget -O "$local_path/$name" https://raw.githubusercontent.com/"$REPO"/teslausb/"$BRANCH"/"$remote_path"/"$name"
curl -o "$local_path/$name" https://raw.githubusercontent.com/"$REPO"/teslausb/"$BRANCH"/"$remote_path"/"$name"
# wget -O "$local_path/$name" https://raw.githubusercontent.com/"$REPO"/teslausb/"$BRANCH"/"$remote_path"/"$name"
chmod +x "$local_path/$name"
setup_progress "Downloaded $local_path/$name ..."
}
function get_ancillary_setup_scripts () {
@@ -75,14 +146,15 @@ function get_ancillary_setup_scripts () {
function fix_cmdline_txt_modules_load ()
{
echo "Fixing the modules-load parameter in /boot/cmdline.txt..."
setup_progress "Fixing the modules-load parameter in /boot/cmdline.txt..."
cp /boot/cmdline.txt ~
cat ~/cmdline.txt | sed 's/ modules-load=dwc2,g_ether/ modules-load=dwc2/' > /boot/cmdline.txt
rm ~/cmdline.txt
echo "Fixed cmdline.txt."
setup_progress "Fixed cmdline.txt."
}
BACKINGFILES_MOUNTPOINT=/backingfiles
MUTABLE_MOUNTPOINT=/mutable
function create_usb_drive_backing_files () {
if [ ! -e "$BACKINGFILES_MOUNTPOINT" ]
@@ -90,26 +162,32 @@ function create_usb_drive_backing_files () {
mkdir "$BACKINGFILES_MOUNTPOINT"
fi
if [ ! -e "$MUTABLE_MOUNTPOINT" ]
then
mkdir "$MUTABLE_MOUNTPOINT"
fi
if [ ! -e /dev/mmcblk0p3 ]
then
/tmp/create-backingfiles-partition.sh "$BACKINGFILES_MOUNTPOINT"
/tmp/create-backingfiles-partition.sh "$BACKINGFILES_MOUNTPOINT" "$MUTABLE_MOUNTPOINT"
fi
if ! findmnt --mountpoint $BACKINGFILES_MOUNTPOINT
then
echo "Mounting the partition for the backing files..."
setup_progress "Mounting the partition for the backing files..."
mount $BACKINGFILES_MOUNTPOINT
echo "Mounted the partition for the backing files."
setup_progress "Mounted the partition for the backing files."
fi
if [ ! -e $BACKINGFILES_MOUNTPOINT/*.bin ]
then
setup_progress "Creating backing disk files."
/tmp/create-backingfiles.sh "$campercent" "$BACKINGFILES_MOUNTPOINT"
fi
}
function configure_archive_scripts () {
echo "Configuring the archive scripts..."
setup_progress "Configuring the archive scripts..."
get_script /root/bin archiveloop run
@@ -118,6 +196,11 @@ function configure_archive_scripts () {
get_script /root/bin archive-clips.sh run/rsync_archive
get_script /root/bin connect-archive.sh run/rsync_archive
get_script /root/bin disconnect-archive.sh run/rsync_archive
elif [ $RCLONE_ENABLE = true ]
then
get_script /root/bin archive-clips.sh run/rclone_archive
get_script /root/bin connect-archive.sh run/rclone_archive
get_script /root/bin disconnect-archive.sh run/rclone_archive
else
get_script /root/bin archive-clips.sh run/cifs_archive
get_script /root/bin connect-archive.sh run/cifs_archive
@@ -126,7 +209,7 @@ function configure_archive_scripts () {
get_script /root/bin remountfs_rw run
echo "Configured the archive scripts."
setup_progress "Configured the archive scripts."
}
function configure_pushover_scripts() {
@@ -139,7 +222,7 @@ function configure_rc_local () {
return
fi
echo "Configuring /etc/rc.local to run the archive scripts at startup..."
setup_progress "Configuring /etc/rc.local to run the archive scripts at startup..."
echo "#!/bin/bash -eu" > ~/rc.local
echo "archiveserver=\"${archiveserver}\"" >> ~/rc.local
cat << 'EOF' >> ~/rc.local
@@ -158,28 +241,41 @@ EOF
cat ~/rc.local > /etc/rc.local
rm ~/rc.local
echo "Configured rc.local."
setup_progress "Configured rc.local."
}
function configure_hostname () {
echo "Configuring the hostname..."
# Headless image already has hostname set
if [ ! $HEADLESS_SETUP = "true" ]
then
setup_progress "Configuring the hostname..."
local new_host_name="teslausb"
cp /etc/hosts ~
sed "s/raspberrypi/$new_host_name/g" ~/hosts > /etc/hosts
local new_host_name="teslausb"
cp /etc/hosts ~
sed "s/raspberrypi/$new_host_name/g" ~/hosts > /etc/hosts
cp /etc/hostname ~
sed "s/raspberrypi/$new_host_name/g" ~/hostname > /etc/hostname
echo "Configured the hostname."
cp /etc/hostname ~
sed "s/raspberrypi/$new_host_name/g" ~/hostname > /etc/hostname
setup_progress "Configured the hostname."
fi
}
function make_root_fs_readonly () {
/tmp/make-root-fs-readonly.sh
}
echo "Verifying environment variables..."
headless_setup_populate_variables
# If USE_LED_FOR_SETUP_PROGRESS = true.
setup_led_off
# Flash for stage 2 headless (verify variables)
headless_setup_progress_flash 1
setup_progress "Verifying environment variables..."
RSYNC_ENABLE="${RSYNC_ENABLE:-false}"
RCLONE_ENABLE="${RCLONE_ENABLE:-false}"
if [ "$RSYNC_ENABLE" = true ]
then
@@ -187,6 +283,12 @@ then
check_variable "RSYNC_SERVER"
export archiveserver="$RSYNC_SERVER"
check_variable "RSYNC_PATH"
elif [ "$RCLONE_ENABLE" = true ]
then
check_variable "RCLONE_DRIVE"
check_variable "RCLONE_PATH"
# since it's a cloud hosted drive we'll just set this to google dns
export archiveserver="8.8.8.8"
else # Else for now, TODO allow both for more redundancy?
check_variable "sharename"
check_variable "shareuser"
@@ -200,6 +302,11 @@ check_variable "campercent"
check_pushover_enabled
# Flash for Stage 3 headless (grab scripts)
headless_setup_progress_flash 2
setup_progress "Downloading additional setup scripts."
if [ ! -e /root/bin ]
then
mkdir /root/bin
@@ -209,6 +316,10 @@ if [ "$RSYNC_ENABLE" = true ]
then
get_script /root/bin verify-archive-configuration.sh run/rsync_archive
get_script /root/bin configure-archive.sh run/rsync_archive
elif [ "$RCLONE_ENABLE" = true ]
then
get_script /root/bin verify-archive-configuration.sh run/rclone_archive
get_script /root/bin configure-archive.sh run/rclone_archive
else
get_script /root/bin verify-archive-configuration.sh run/cifs_archive
get_script /root/bin configure-archive.sh run/cifs_archive
@@ -225,6 +336,7 @@ get_ancillary_setup_scripts
pushd ~
configure_archive_scripts
configure_pushover_scripts
@@ -233,6 +345,9 @@ fix_cmdline_txt_modules_load
echo "" >> /etc/fstab
# Flash for stage 4 headless (Create backing files)
headless_setup_progress_flash 3
create_usb_drive_backing_files
/root/bin/configure-archive.sh
@@ -241,6 +356,14 @@ configure_rc_local
configure_hostname
# Flash for stage 5 headless (Mark success, FS readonly)
headless_setup_progress_flash 4
headless_setup_mark_setup_success
make_root_fs_readonly
echo "All done."
# If USE_LED_FOR_SETUP_PROGRESS = true.
setup_led_on
setup_progress "All done."