Godot-Frontend

.gitignore

@@ -359,6 +359,8 @@ HACKING/__pycache__/**
 .env
 onboard/.env
 HACKING/.env
+dcu/.env
+dcu/output/**
 
 # test locations for save data
 onboard/backend/.save

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "godotTools.editorPath.godot4": "/usr/bin/godot-mono-4.4.1"
+}

HACKING/export-all.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+# first arg is --help or -h             or # of args != 3
+if [[ $1 == --help ]] || [[ $1 == -h ]] || [[ $# -ne 3 ]]; then
+    echo "Usage:" $0 "<godot_executable> <path_to_root_folder> <out_path>" 
+    exit
+fi
+
+# backend
+# cargo build the backend cause yeah
+
+# godot frontend
+$1 --path $2/onboard/godot-frontend --headless --export-release "Linux" $3/godot_frontend
+
+exit

README.md

@@ -7,12 +7,12 @@ Run the `update_onboard.sh` script located in HACKING
 
 ## Building (manual)
 
-To build and run on the DCU, do the following from `./onboard/frontend`:
-```
-dotnet publish -c Release -r linux-x64 --no-self-contained
+To build and run on the DCU, do the following from `./onboard/godot-frontend`:
+```Bash
+godot-4.4.1 --path ./ --headless --export-release "Linux" out-path/godot_frontend
 ```
 And the following from `./onboard/backend`:
-```
+```Bash
 cargo build --release --target x86_64-unknown-linux-gnu
 ```
 To put it on the DCU, compress the `publish` folder located at `./onboard/frontend/bin/Release/netcoreapp3.1/linux-x64` and `scp` that to the DCU.
@@ -24,26 +24,32 @@ To setup and launch a development environment, you can do the following:
 
 ### Env Vars
 
-There is a file called .env.template in the `./onboard` folder. Fill this in with appropriate values for the backend and frontend.
-
+There is a file called [.env.template](/onboard/.env.template) in the `./onboard` folder. Copy the file to a new file called `.env` in the same directory. Then fill this in with appropriate values for the backend and frontend.
 
 ### Running outside a container
 
-In onboard/frontend, run `dotnet run`
+In **onboard/backend**, run `cargo run`
 
-In onboard/backend, run `cargo run`
+In the godot project manager, select the **onboard/godot-frontend** folder to open the frontend. <br>
+Or run `godot --editor --path onboard/godot-frontend` 
 
 The frontend will log warnings about not being able to connect until the backend is up and running
 
-### Building and Launching the Container
+<!-- ### Building and Launching the Container
 
 ```
 cd HACKING
 ./build-environment.sh
 ./launch-environment.sh
-```
+``` -->
+
+## Further Devolopment
+
+### Backend
 
-#### `mgcb`
+Nothing here yet
 
-The container has `mgcb-editor` installed. To run that, do this:
-`dotnet mgcb-editor`
+### Frontend
+For more information on:
+* Creating a new GUI see: [CreatingAGuiREADME.md](/onboard/godot-frontend/GUIs/CreatingAGuiREADME.md)
+* Creating a new screensaver animation see: [RecordingREADME.md](/onboard/godot-frontend/guiManager/screensaver/RecordingREADME.md)

dcu/.env.template

@@ -0,0 +1,3 @@
+PASSWORD_VAR=devcade
+ROOT_PASSWORD_VAR=devcade
+BRANCH_VAR=main

dcu/Dockerfile

@@ -0,0 +1,140 @@
+FROM quay.io/fedora/fedora-bootc:43
+
+# user and file systemd configs
+COPY ./config-files/files.conf /usr/lib/tmpfiles.d/custom_files.conf
+COPY ./config-files/users.conf /usr/lib/sysusers.d/custom_users.conf
+
+# disable sleep/hiberate features
+RUN systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target
+
+### required software
+RUN dnf install -y                                                  \
+    openbox picom awk scrot xterm pamixer xdg-desktop-portal-gtk    \
+    gcc-c++ git wget unzip dotnet-sdk-10.0                          \
+    grep openssh-server openssl-devel fail2ban                      \
+    glib2-devel flatpak-devel libnfc-devel                          \
+    make cmake                                                      \
+    autoconf automake libtool                                       \
+    xrandr @base-x                                                  \
+    plymouth-plugin-script
+
+# install libfreefare-devel, as it is not in the package manager yet
+RUN git clone https://github.com/nfc-tools/libfreefare.git &&   \
+    cd libfreefare &&                                           \
+    autoreconf -vis &&                                          \
+    ./configure --prefix=/usr &&                                \
+    make && make install &&                                     \
+    cd .. && rm -r libfreefare
+
+# required flatpak runtimes
+RUN flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo &&   \
+    flatpak install -y flathub org.freedesktop.Platform/x86_64/22.08
+
+# root services config file
+# ban people from ssh'ing after some number of attempts for some amount of time (see contents of file for specifics)
+COPY ./config-files/sshd.local /etc/fail2ban/jail.d/sshd.local
+# ssh server configuration file
+COPY ./config-files/sshd_config /etc/ssh/sshd_config
+RUN systemctl enable fail2ban; \
+    systemctl enable sshd
+
+# # copy boot splash over
+# COPY ./boot-splash/devcade /usr/share/plymouth/themes/devcade
+# # set theme
+# RUN ls -l /usr/share/plymouth/themes &&     \
+#     plymouth-set-default-theme -R devcade 
+
+# install Rust
+RUN curl https://sh.rustup.rs -sSf | bash -s -- -y; 
+ENV PATH "/root/.cargo/bin:${PATH}"
+
+# install godot 4.7-stable mono
+RUN wget "https://github.com/godotengine/godot/releases/download/4.7-stable/Godot_v4.7-stable_mono_linux_x86_64.zip" &&         \
+    unzip Godot_v4.7-stable_mono_linux_x86_64.zip &&                                                                            \
+    mv Godot_v4.7-stable_mono_linux_x86_64/Godot_v4.7-stable_mono_linux.x86_64 /usr/bin/Godot_v4.7-stable_mono_linux.x86_64 &&  \
+    mv Godot_v4.7-stable_mono_linux_x86_64/GodotSharp /usr/bin/GodotSharp;                                                      \
+    rm Godot_v4.7-stable_mono_linux_x86_64.zip
+
+# file required for xauth
+RUN touch .Xauthority
+
+### copy required files 
+# NOTE: required symlinks for some config files are created in dcu/config-files/files.conf
+# ostree settings
+COPY ./config-files/prepare-root.conf /usr/lib/ostree/prepare-root.conf
+
+# openbox config file
+COPY ./config-files/rc.xml /etc/xdg/openbox/rc.xml 
+
+# x11 init file
+COPY ./config-files/.xinitrc /etc/X11/xinit/xinitrc  
+
+# bash init file
+COPY ./config-files/.bashrc /etc/bashrc
+
+# autologin service
+COPY ./config-files/tty1_service_override.conf /etc/systemd/system/getty@tty1.service.d/override.conf
+
+# required custom executables
+COPY ./config-files/export-all ./config-files/devcade_onboard /usr/bin/
+
+# export templates
+COPY ./config-files/linux_debug.x86_64      \
+     ./config-files/linux_release.x86_64    \
+     ./config-files/linux_debug.x86_32      \
+     ./config-files/linux_release.x86_32    \
+     /usr/share/godot/export_templates/4.7.stable.mono/
+
+# symlink required for the export functionality of the godot cli, 
+# I blame godot for not letting me change the install location of the export templates
+RUN mkdir -p /root/.local/share/godot/export_templates && \
+    ln -s -f /usr/share/godot/export_templates/4.7.stable.mono /root/.local/share/godot/export_templates/
+
+# devcade-onboard git repository
+ARG BRANCH_VAR
+RUN git clone https://github.com/matthewlefler/devcade-onboard-ui-revamp.git && \
+    cd devcade-onboard-ui-revamp && git switch ${BRANCH_VAR}
+
+RUN mkdir -p /usr/share/devcade/ && \
+    cp ./devcade-onboard-ui-revamp/onboard/.env.template /usr/share/devcade/.env
+
+# export-all <godot-path> <absolute src path> <absolute out path>
+RUN export-all                          \
+    Godot_v4.7-stable_mono_linux.x86_64 \
+    /devcade-onboard-ui-revamp          \
+    /usr/bin
+
+# delete git repo
+RUN rm -r /devcade-onboard-ui-revamp
+
+# enable autologin
+RUN systemctl enable getty@tty1
+
+# niceity software
+RUN dnf install -y                          \
+    vim fastfetch btop lspci usbutils gdb   \
+    && dnf clean all
+
+### cleanup
+# remove all log files, runtime only, and temporary files
+RUN rm -rf /var;        \
+    rm -rf /run;        \
+    rm -rf /tmp;        \
+    mkdir -p /var/home; \
+    mkdir -p /run;      \
+    mkdir -p /tmp;
+
+ARG PASSWORD_VAR
+ARG ROOT_PASSWORD_VAR
+# set passwords and set devcade acc to not expire
+RUN chage -E -1 devcade;                            \
+    echo -e "devcade:${PASSWORD_VAR}" | chpasswd;   \
+    echo -e "root:${ROOT_PASSWORD_VAR}" | chpasswd; 
+
+# make it known as a bootc container
+LABEL containers.bootc=1
+LABEL bootc.rootfs=/sysroot
+
+RUN bootc container lint
+
+RUN plymouth-set-default-theme --list

dcu/Dockerfile.nvidia

@@ -0,0 +1,31 @@
+FROM localhost/dcu-devcade-onboard
+
+### Nvidia drivers
+# enable require repositories
+RUN dnf -y install                                                                                              \
+        https://mirrors.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm           \
+        https://mirrors.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm &&  \
+# Install NVIDIA drivers
+    dnf install -y --allowerasing   \
+        akmod-nvidia                \
+        xorg-x11-drv-nvidia         \
+        xorg-x11-drv-nvidia-cuda 
+
+# Rebuild akmods
+RUN akmods --force --kernels `rpm -q --queryformat '%{VERSION}-%{RELEASE}.%{ARCH}' kernel-devel`
+# add kernel arguments
+# see: https://bootc.dev/bootc/building/kernel-arguments.html
+RUN mkdir -p /usr/lib/bootc/kargs.d
+RUN cat <<EOF >> /usr/lib/bootc/kargs.d/01-nvidia-driver.toml
+kargs = ["rd.driver.blacklist=nouveau", "modprobe.blacklist=nouveau", "nvidia-drm.modeset=1"]
+match-architectures = ["x86_64", "aarch64"]
+EOF
+
+RUN flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo && \
+    flatpak install -y flathub org.freedesktop.Platform.GL.nvidia-580-142
+
+# make it known as a bootc container
+LABEL containers.bootc=1
+LABEL bootc.rootfs=/sysroot
+
+RUN bootc container lint

dcu/README.md

@@ -1 +1,127 @@
 Documentation can be found here: https://devcade-docs.csh.rit.edu/#/Hardware/installing-dcu
+
+# bootc containerization
+see https://docs.fedoraproject.org/en-US/bootc/getting-started/   
+for image building tool documentation https://github.com/osbuild/bootc-image-builder   
+**bootc** is a tool for creating bootable containers, basically meaning putting a container on top of a kernel.   
+In this case Fedora is used as a base image, and the devcade-onboard is built on top of it using a Dockerfile based container. 
+## Installing
+For most use cases this is unnecessary, and you can skip this
+### For official installation documentation see:
+see https://bootc.dev/bootc/packaging-and-integration.html
+### Arch:
+
+First try:
+```bash
+paru bootc
+```
+
+If that fails build the program manually:
+```bash
+git clone https://github.com/bootc-dev/bootc.git # clone the git repository
+cd bootc
+sudo make install # build and install the program
+```
+Then install dependencies
+```
+bootupd, skopo
+```
+## Installing to a machine
+Requirements:
+- USB stick
+- This repository
+- At most 20 minutes 
+
+***Note:* This wipes whatever drive it is installed to, removing all data already there, do not install this to a machine that contains important data, as it will be wiped**   
+create the ISO as follows, in `devcade-onboard/dcu/`:
+```bash
+./create-iso.sh
+```
+Then create a bootable USB drive using the tool of your choice (I used a Ventoy where i can just copy the ISO to the USB stick)   
+Then insert the USB stick into the machine and turn it on, going to the BIOS if needed to boot from the USB stick.   
+Then select install (the first option) to install the devcade container to the machine.   
+
+# Testing
+## Using podman
+Refer to: https://github.com/containers/podman/blob/main/docs/tutorials/podman_tutorial.md
+
+*Quick note:* these images are around 5-6 GiB in size at the moment. 
+To remove unused images run `podman image purge`. 
+The reason why this command is not run automatically is that it could remove images that the user wants to keep unintentionally.
+## Testing the container
+For a quick way to test things like: 
+- file structure
+- file ownership
+- package installation
+- Dockerfile correctness
+build and run the container locally
+### Using predefined scripts
+First build the container with:
+```bash
+./build.sh
+```
+Then run it with:
+```bash
+./run.sh
+```
+### Manually
+First build the container with:
+```bash
+podman build --build-arg-file=./.env -t dcu-devcade-onboard:latest .
+```
+Then run it with:
+```bash
+podman run -p 2200:22 -it dcu-devcade-onboard:latest /bin/bash
+```
+### SSH
+to SSH into the container run:
+```bash
+ssh -p 2200 devcade@localhost
+```
+to ssh while forwarding the display server
+```bash
+ssh -p 2200 -X devcade@localhost
+```
+### ISO
+The only true way to test the container is to boot is though "real" hardware, e.g. a virtual machine.
+#### Requirements
+- compatible virtual machine software
+	- all it needs to be able to do is boot from an **ISO** file
+- podman
+- sudo
+- an internet connection
+- 10-15 minutes (may take longer or shorter depending on hardware)
+#### Creation
+```bash
+./create-iso.sh
+```
+if prompted for your password enter it, the container to create the ISO requires elevated privileges, and by extension building the dcu-devcade-onboard image requires it. *Note: that copying the container to the root user is possible but it was found to be slower than just having the root user build it.*   
+#### Virtual Machine
+##### Setup
+After the script finishes an ISO file will exist as `./output/bootiso/install.iso`. In this example i will use `virtmanager` but other virtual machine software should work. 
+1. Start `virtmanager`, click on **create a new virtual machine** in the top left (the computer icon with the star). This will open a pop-up window. 
+2. Next select **local media install** and click **Forward**. 
+3. Then click **browse**, if the path `/path/to/git/repo/dcu/output/bootiso/install.iso` is there you can select it, if not click **Browse Local** and find it there. 
+4. Then click **Choose Volume** and if it does not detect the operating system uncheck **Automatically detect from the installation media / source** and manually select it from the selections, currently this is **Fedora 43** but check to make sure
+5. Then click **Forward** again and select the number of CPUs and memory to dedicate to this VM, i find the default 2 and 4 GiB work for me, but higher numbers will make it faster.
+6. Click **Forward** again and allocate storage to the machine, again the defaults have been fine to me, but if run out of storage, you can increase the number of GiB allocated.
+7. Click **Forward** again and give it a name, network selection is also possible here, but the default is fine again. 
+8. Click **Finish** to create the new virtual machine
+At this point the machine will start booting, this does take some time to do so, so take a break and scroll Reddit or something. 
+
+After the machine finishes installing the container and booting, you should be in a WM where the onboard is running
+##### Useful info
+To **stop** the machine click the **power button icon** at the top of the virtual machine's output display, or shut down the machine from the command line. 
+To **release the mouse** press `left alt + left ctrl`, or try `left ctrl + left alt + g`. 
+##### Issues
+If you get any issues, such as not being able to select an OS make sure the libvirtd service is started: `systemctl start libvirtd`
+##### SSH 
+Click on **view** then **details** and click on the sub category: **NIC ab:cd:ef:gh:ij:kl** and the IP address to use is listed as **IP address: 192.xxx.xxx.xxx** 
+Then run:
+```bash
+ssh devcade@ip-address
+```
+If any issues arise, running in verbose mode will reveal more information:
+```bash
+ssh -v devcade@ip-address
+```