Index > My Projects > ThinOS Manager

ThinOS Manager Setup - Ubuntu 24 LTS

Configure system for DHCP
Install Zenity
Configure GUI
Scripts

Configure system for DHCP

Create configuration file & set permissions

cat << eot > /etc/netplan/config.yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      dhcp4: true
eot
chmod 600 /etc/netplan/config.yaml

Go up
Install Google Chrome
Dowload the package
wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
Install it
sudo dpkg -i google-chrome-stable_current_amd64.deb
Force the installer to install missing libs
apt install -f
To install Google Chrome, run the following:
sudo apt-get install libxss1 libappindicator1 libindicator7 wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb sudo apt install ./google-chrome*.deb
Installed this way, the package has the name google-chrome-stable. If error messages pop up after running the command sudo apt install ./google-chrome*.deb then run the command
sudo apt-get install -f
Reference

Create base file system

Create and configure base file system Install package needed to create core image

apt install debootstrap

Create base file system [64 bit]

tosm=/tosm; debootstrap --arch amd64 noble $tosm

Delete existing timezone and locals setting from base system and copy the timezone, locals from local system to base system

rm $tosm/etc/{timezone,localtime}; cp /etc/{timezone,localtime} $tosm/etc

Create modules directory and copy intended kernel to it

mkdir -pv $tosm/lib/modules; cp -r /lib/modules/$(uname -r) $tosm/lib/modules/

Set the hostname

echo "tosm" > $tosm/etc/hostname

chroot $tosm

Configure timezone and local time

locale-gen en_US.UTF-8; update-locale LANG=en_US.UTF-8; dpkg-reconfigure -u tzdata

Configure update repositories

cat << eot > /etc/apt/sources.list
# Core updates
deb http://archive.ubuntu.com/ubuntu noble main restricted universe multiverse
deb-src http://archive.ubuntu.com/ubuntu noble main restricted universe multiverse
# Security updates
deb http://archive.ubuntu.com/ubuntu noble-security main restricted universe multiverse
deb-src http://archive.ubuntu.com/ubuntu noble-security main restricted universe multiverse
# Regular updates
deb http://archive.ubuntu.com/ubuntu noble-updates main restricted universe multiverse
deb-src http://archive.ubuntu.com/ubuntu noble-updates main restricted universe multiverse
eot

Patch the base system

apt update; apt upgrade -y

Install base packages

apt install nano wget partclone ntfs-3g chntpw nfs-common pv dialog fdisk pigz -y

Disable IPv6 Add the following as kernel argument

ipv6.disable=1

Create init script (very important) and make it executable

cat << eot > /init
#!/bin/sh
mkdir -p /dev/{,pts,ptmx}

# Mount file system in ram.
mount -a

init=/sbin/init
exec \${init}
eot
chmod a+x /init

Create rule to change nic name to eth0

cat << eot > /etc/udev/rules.d/70-persistent-net.rules
# PCI device 0x11ab:0x4363 (sky2)
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*",
ATTR{address}=="00:00:00:00:00:00",ATTR{dev_id}=="0x0", ATTR{type}=="1",
KERNEL=="eth*", NAME="eth0"
eot

Configure the base system for dhcp

cat << eot > /etc/netplan/config.yaml
network:
  version: 2
  renderer: networkd
  ethernets:
    eth0:
      dhcp4: true
eot
chmod 600 /etc/netplan/config.yaml

Clear caches

apt-get autoremove; apt-get autoclean; apt-get clean; rm /var/lib/apt/lists/*

Remove some unnecessary files/folders and remove wireless drivers from kernel (optional)

rm -r /usr/share/GeoIP ; rm -r /usr/share/man ; rm -r /usr/share/doc
rm -r /lib/modules/$(uname -r)/kernel/net/wireless; rm -r /lib/modules/$(uname -r)/kernel/drivers/net/wireless

Configure autologin for root account

sed -i s,"^ExecStart=-/sbin/agetty.*","ExecStart=-/sbin/agetty -a root --noclear %I \$TERM",g /etc/systemd/system/getty.target.wants/getty\@tty1.service

Verify the auto login

grep "ExecStart" /etc/systemd/system/getty.target.wants/getty\@tty1.service | grep root

Setup password for root (optional)

passwd

Logout from base system (chrooted)

exit

Compress the base system (.gz)

cd $tosm; find . -print0 | sudo cpio --null -ov --format=newc | gzip -9 > ~/tosm_$(date +%Y%m%d).gz

Compress the base system (.xz)

cd $tosm; find . -print0 | sudo cpio --null -ov --format=newc > ~/tosm_$(date +%Y%m%d); xz -zvf -T0 -9 -C crc32 ~/tosm_$(date +%Y%m%d)

Congrats ! Your base file system is compressed and ready Go up

Install Zenity

apt install libgles2-mesa-dev zenity

Setup GUI

apt install xfce4 --no-install-recommends
apt install xserver-xorg --no-install-recommends
apt install xinit --no-install-recommends

Scripts

Functions (core.sh)

#!/bin/sh
# Argument(s) to variables
	$(for var in $(cat /proc/cmdline); do echo export $var | grep =; done)
	nfs="${nfs}" # NFS server
	shr="${shr}" # NFS share
	img="${img}" # Image id
	imn="${imn}" # Image name
	idr="${idr}" # Image directory
	web="${web}" # Web address
	job="${job}" # Job type
	scr="${scr}" # Script to run

# Global variables [host info]
	ip=`ip a | grep "brd" | grep "inet" | awk '{print $2}'`
	bct=`ip a | grep "brd" | grep "inet" | awk '{print $4}'`
	mac=`ip a | grep "ether" | awk '{print $2}' | sed s/://g`
	

# Check CPU
	cores=$(grep "core id" /proc/cpuinfo | sort -u | wc -l)
	sockets=$(grep "physical id" /proc/cpuinfo | sort -u | wc -l)
	cores=$((cores * sockets))
	if [ "$cores" -eq "0" ]; then
		cores=1
	fi

dots()
{
    max=60
    if [ -n "$1" ]; then
        len=${#1}
        if [ "$len" -gt "$max" ]
        then
            echo -n " * ${1:0:max}"
        else
            echo -n " * ${1}"
            n=$((max - len))
                x=0
                while [ $x -le $n ]
                do
                        printf %s .
                        x=`expr $x + 1`

                done
        fi
    fi
}
getDisk()
{
lsblk -d | grep disk
		# Lets check and see if the partition shows up in /proc/partitions
		for i in hda hdb hdc hdd hde hdf sda sdb sdc sdd sde sdf;
		do
			strData=`cat /proc/partitions | grep $i 2>/dev/null`
			if [ -n "$strData" ]
			then
				hd="/dev/$i"
				pt="$i"
				return 0;
			fi
		done;

		for i in hda hdb hdc hdd hde hdf sda sdb sdc sdd sde sdf;
		do
			strData=`head -1 /dev/$i 2>/dev/null`
			if [ -n "$strData" ]
			then
				hd="/dev/$i"
				pt="$i"
				return 0;
			fi
		done;

		# Failed, probably because there is no partition on the device
		for i in hda hdb hdc hdd hde hdf sda sdb sdc sdd sde sdf;
		do
			strData=`fdisk -l | grep /dev/$i 2>/dev/null`
			if [ -n "$strData" ]
			then
				hd="/dev/$i"
				pt="$i"
				return 0;
			fi
		done;
	return 1;
}
getBanner()
{
        clear
        echo ""
        echo " +---------------------------------+"
	echo " |#################################|"
        echo " |   #   /#####\ /####) ##       ##|"
	echo " |   #   #     # #      # #     # #|"
        echo " |   #   #     # #      #  #   #  #|"
	echo " |   #   #     # #      #   \#/   #|"
	echo " |   #   #     # \####\ #         #|"
        echo " |   #   #     #      # #         #|"
        echo " |   #   #     #      # #         #|"
	echo " |   #   #     #      # #         #|"
        echo " |   #   \#####/ (####/ #         #|"
        echo " |                                 |"
        echo " +---------------------------------+"
        echo " |           Created by: Ryaz Khan |"
        echo " +---------------------------------+"
        echo ""
}
getBash()
{
	dots "Launching command prompt"
	sleep 2
	echo "OK"
	cd
	echo ""
	echo ""
	bash
}
partDisk()
{
dots "Using hard disk $hd"
sleep 2
echo OK
dots "Setting up hard disk $hd"
fdisk $hd >/dev/null 2>&1 <<eot
d
w
eot
sleep 2
echo "OK"
dd if=/dev/zero of=$hd bs=512 count=1 2>/dev/null
dots "Creating NTFS on $hd"
sleep 2
fdisk $hd > /dev/null 2>&1 <<eot
n
p



t
7
a
1
w
eot
echo "OK"
}
taskInit()
{
dots "Initializing $job"
	if [ -d "$mpt" ]
	then
		echo "OK"
	else
		echo "Failed"
		exit 2
	fi
sn=`nslookup $nfs | grep "name" | cut -d " " -f3 | cut -d "." -f1`
dots "Using storage node"
sleep 2
echo "$sn"
}
delPageFiles()
{
        dots "Mounting windows file system"
        ntfs="/ntfs"
        mkdir -p $ntfs
        sleep 2
        ntfs-3g -o force,rw ${hd}1 $ntfs
        if [ -d "$ntfs/Windows" ]
        then
                echo "OK"
        else
                echo "Failed"
                exit 2
        fi

        dots "Removing page files"
        rm -fr $ntfs/pagefile.sys
        rm -fr $ntfs/hiberfil.sys
        sleep 2
                if [ ! -f "$ntfs/pagefile.sys" ]
                then
                        echo "OK"
                else
                        echo "Failed"
                        exit 2
                fi
        dots "Unmounting windows file system"
        umount $ntfs
        sleep 2
                if [ ! -d "$ntfs/Windows" ]
                then
                        echo "OK"
                else
                        echo "Failed"
                        exit 2
                fi
}
createCL()
{
dots "Creating capture location"
cl="$dev/$mac"
	sleep 1
	mkdir -p $cl
	sleep 2
		if [ -d "$cl" ]; then
			echo "OK"
		else
			echo "Failed"
			exit 2
		fi
}
saveMBR()
{
	dots "Saving MBRs of $hd"
	dd if=$hd of=$cl/$pt.mbr bs=512 count=1 &>/dev/null
	sleep 2
		if [ -f "$cl/$pt.mbr" ]
		then
			echo "OK"
		else
			echo "Failed"
			exit 2
		fi
}
restoreMBR()
{
	imgdir="$mpt/$idr"
        mbr=`ls -a $imgdir/*.mbr`
        dots "Restoring MBRs"
        sleep 1
        if [ -f "$mbr" ]
        then
                dd if=$mbr of=$hd bs=446 count=1 2> /dev/null
                echo "OK"
        else
                echo " Cannot process MBRs, no MBRs found "
                sleep 10
                exit 2
        fi
}
wimUpload()
{
	dots "Starting to clone ${hd}1"
	sleep 1
	echo "OK"
	echo ""
	echo ""
	. $mpt/.core/wimUploadStats &
	wimcapture ${hd}1 $cl/$img.wim "${imn}" --pipable | tee -a /tmp/stats.osd
	cd ${dev}
	mv ${mac} ${mpt}/${idr}
	chmod 775 ${mpt}/${idr} -R
	cd
}
wimUpload0()
{
        dots "Starting to clone ${hd}1"
        sleep 1
        echo "OK"
        echo ""
	mkfifo /tmp/pigz1
        sleep 1
        . $mpt/.core/wimUploadStats &
        pigz -p $cores -9 < /tmp/pigz1 > $cl/$img.wim & wimcapture ${hd}1 /tmp/pigz1 "${imn}" --pipable | tee -a /tmp/stats.osd
        cd ${dev}
        mv ${mac} ${mpt}/${idr}
        chmod 775 ${mpt}/${idr} -R
        cd
}
partcloneUpload()
{
	dots "Starting capture"
        sleep 2
        mkfifo /tmp/pigz1
        echo "OK"
        sleep 2
        echo ""
	. $mpt/.core/partcloneStatus &
        #pigz -p $cores $cmp < /tmp/pigz1 > $mpt/$mac/$img & partclone.ntfs -c -s ${hd}$n -O /tmp/pigz1 -N -B -f 1
       	#pigz -p $cores -9 < /tmp/pigz1 > $cl/$img.sys & partclone.ntfs -c -s ${hd}1 -O /tmp/pigz1 -B 2>&1 | tee -a /tmp/osis.sts
       	pigz -p $cores -9 < /tmp/pigz1 > $cl/$img.sys & partclone.ntfs -I -i -c -s ${hd}1 -O /tmp/pigz1 -B 2>&1 | tee -a /tmp/osis.sts
	echo " * Capture completed "
        sleep 2
	dots "Uploading image to $mpt/$img"
	sleep 2
        echo ""
 	img="IMG$img"
        mv $cl $mpt/$img
        chmod 775 $mpt/$img -R
	echo "OK"
}
createNTFS()
{
	dots "Formating ${hd}1 ntfs volume"
	sleep 2
	mkntfs -f ${hd}1 > /dev/null 2>&1
	echo "OK"
}
wimDownload()
{
	dots "Starting to restore $img.wim to ${hd}1"
	sleep 1
	echo "OK"
	echo ""
	. $mpt/.core/wimDownloadStats &
	wimapply $mpt/$idr/$img.wim 1 ${hd}1 | tee -a /tmp/stats.osd
	sleep 1
}
rebootComputer()
{
	dots "Restarting computer"
	sleep 1
	echo "OK"
	sleep 1
	reboot
}
taskCheckin()
{
	dots "$job checking in"
	sleep 1
        state=`wget -O - --post-data="cmd=setTaskStatus&tid=${tid}&sts=1" "${web}" 2> /dev/null`
	sleep 1
       	echo "OK"
}
mcCheckin()
{
	dots "$job joining"
        sleep 1
        state=`wget -O - --post-data="cmd=setMcStatus&tid=${msid}&sts=1" "${web}" 2> /dev/null`
        sleep 1
        echo "OK"
}
mcCheckout()
{
	dots "$job updating"
        sleep 1
        state=`wget -O - --post-data="cmd=setMcStatus&tid=${msid}&sts=2" "${web}" 2> /dev/null`
        sleep 1
        echo "OK"
}
taskDone()
{
	dots "$job completed"
	sleep 1
	echo "OK"
	dots "Cleaning up"
	umount /images && rm -r /images
	sleep 1
	if [ ! -d "/images" ]
	then
		echo "OK"
	else
		echo "Failed"
		exit 2
	fi
	dots "$job updating status"
        sleep 1
        state=`wget -O - --post-data="cmd=setTaskStatus&tid=${tid}&sts=2" "${web}" 2> /dev/null`
        sleep 1
        echo "OK"
}
wimMulticast()
{
	dots "Forcing IGMP v2"
        sleep 1
        echo "OK"
	iface=`ifconfig | grep "Ethernet" | awk '{print $1}'`
        echo "2" > /proc/sys/net/ipv4/conf/$iface/force_igmp_version
        igmp=`cat /proc/sys/net/ipv4/conf/$iface/force_igmp_version`
        dots "Checking IGMP Version"
        sleep 1
        echo $igmp
	dots "Multicast from ${mcIP} on port ${mcPort}"
       	sleep 2
        echo "OK"
	echo ""
	echo ""
	. $mpt/.core/wimDownloadStats &
	udp-receiver --portbase ${mcPort} --mcast-rdv-address ${mcIP} --nokbd | wimapply - 1 ${hd}1 | tee -a /tmp/stats.osd
	sleep 2
}
partcloneMulticast()
{
        dots "Forcing IGMP v2"
        sleep 1
        echo "OK"
        echo "2" > /proc/sys/net/ipv4/conf/eth0/force_igmp_version
        igmp=`cat /proc/sys/net/ipv4/conf/eth0/force_igmp_version`
        dots "Checking IGMP Version"
        sleep 1
        echo $igmp
        dots "Multicast from ${mcIP} on port ${mcPort}"
        sleep 2
        echo "OK"
        echo ""
        echo ""
        . $mpt/.core/partcloneStats &
	udp-receiver --portbase ${mcPort} --nokbd --mcast-rdv-address ${mcIP} 2>/dev/null | gunzip -d -c | partclone.restore -B -s - -O ${hd}1 2>&1 | tee -a /tmp/osis.sts
        sleep 2
}
partcloneDownload()
{
	dots "Starting restore"
                        clear
                        #partclone.restore -N -s $mpt/$imgid/${pt}1.img -o ${hd}1
                        #cat $mpt/$imgid/${pt}1.img | partclone.restore -N -o ${hd}1
                        #gunzip -d -c < $mpt/$imgid/${pt}1.img | partclone.restore -O ${hd}1 -N -f 1 2>/tmp/status.osis
                        . $mpt/.core/partcloneStatus &
                        gunzip -d -c < $mpt/$idr/IMG$img/$img.img | partclone.restore -O ${hd}1 -B 2>&1 | tee -a /tmp/osis.sts
                        sleep 2
	echo " Download completed "
}
resizeDisk()
{
	dots "Calculating used disk size"
	sleep 1
	mbs=`ntfsresize -m ${hd}1`
	mbs=`echo $mbs | awk '{print $7}'`
	mbs="${mbs}M"
	echo "$mbs"
	dots "Resizing ${hd}1"
	sleep 2
ntfsresize -f -b -s $mbs ${hd}1 > /dev/null 2>&1 << eot
y
eot
	echo "OK"
	sleep 2
}
expandDisk()
{
	dots "Calculating actual ${hd}1 size"
	sleep 1
	dsk=`fdisk -l | grep "Disk"`
	diskSize=`echo $dsk | cut -d "," -f1 | awk '{print $3,$4}' | awk '{print $1}'`
	sizeType=`echo $dsk | cut -d "," -f1 | awk '{print $3,$4}' | awk '{print $2}'`
	echo "$diskSize $sizeType"
	dots "Expanding ${hd}1 size to $diskSize $sizeType"
	newSize=`echo $diskSize | cut -d "." -f1`
	newType=`echo $sizeType | cut -c1`
	sleep 2
ntfsresize -s $newSize$newType ${hd}1 > /dev/null 2>&1 << eot
y
eot
	echo "OK"
}

New functions (core.sh)

# get hard drive(s)
getDisk()
{
        dsks=`lsblk | grep disk | awk '{print $1}'`
        for i in ${dsks}
        do
                chkData=`head -1 /dev/${i} 2>/dev/null`
                if [ -n "${chkData}" ]
                then
                        hdd="/dev/${i}"
                        dsk="$i"
                fi
        done
}
getPartitions()
{
        #parts=`cat /proc/partitions | grep ${dsk} | awk '{print $4}'`
        parts=`lsblk | grep part | awk '{print $1}' | cut -c 7-`
        for part in ${parts}
        do
                #echo ${part}
                chkPart=`fdisk -l /dev/${part} | grep identifier`
                if [ -z "${chkPart}" ]
                then
                        mtp=$part
                fi
        done
}
# zero drive(s)
zeroDisk()
{
        dots "Using hard disk $hdd"
        sleep 2
        echo OK
        dots "Setting up hard disk $hdd"
fdisk $hdd >/dev/null 2>&1 <<eot
d

d

w
eot
        sleep 2
        echo "OK"
}
# fix signature error
fixDisk()
{
fdisk $hdd >/dev/null 2>&1 <<eot
w
eot
}
# partclone.dd restart
partcloneRestore()
{
        dots "Starting restore to ${hd}"
        gunzip -d -c < ${shr}/kiosk.img | partclone.dd -N -d -o ${hdd}
        echo "Restore completed"
}

# mount partition
mountPartition()
{
        mount "${1}" /mnt
}

# rename host
renameComputer()
{
        dots "Setting computer name to \"${1}\""
        sleep 1
        echo "${1}" > /mnt/etc/hostname
        echo "OK"
        dots "Checking computer name"
        sleep 1
        echo "$(cat /mnt/etc/hostname)"
}