`tbottest.generic`¶

This is an example approach for a hopefully easy to use lab and board support.

Therefore we use ini file based configuration, based on

https://docs.python.org/3/library/configparser.html

with all its limitiations.

But it showed, that for a first use of tbot, it is easier to explain to edit a tbot.ini file and start!

requirements for lab host¶

sudo command should work without entering a password (or add support for this in tbot!)

You should be able to ssh between lab host, build host and board without entering a password or something else!

supported hardware/tools¶

serial console access with:

piccom
kermit

Powercontrol:

sispmctl
TinkerForge
simple GPIO

It should be easy to extend this.

Quick Start¶

To be independent of the installed tbot on the system, you can use the tbot starter script:

https://github.com/hsdenx/tbottest/blob/master/newtbot_starter.py

To get a working setup you can use the script:

https://github.com/hsdenx/tbottest/tree/master/scripts/create_setup.sh

which will create you a complete base setup, as described in configuration.

Here an example run:

$ wget -q https://github.com/hsdenx/tbottest/raw/master/scripts/create_setup.sh
$ chmod 777 create_setup.sh
$ ./create_setup.sh --inter
Name of the lab: foolabname
Hostname of the lab: 192.168.1.113
Username for login into lab: pi
Name of the board in your lab: foobar
Sispmctl MAC: 01:01:4f:09:5b
Sispmctl Port: 1
Klone nach 'tbot' ...
[...]
Klone nach 'tbottest' ...
[...]
add commandline completions with:
echo source tbottest/completions.sh
echo
echo start tbot with:
echo tbottest/newtbot_starter.py @tbotconfig/foobar/args/argsbase
echo
echo Now edit lab config in tbotconfig/foobar/tbot.ini
echo
echo check that 'ssh pi@192.168.1.113' works without typing password
than interactive lab should work:
tbottest/newtbot_starter.py @tbotconfig/foobar/args/argsfoobar-noeth tbotconfig.interactive.lab

edit and adapt U-Boot settings in tbotconfig/foobar/foobar.ini and interactive U-Boot should work
tbottest/newtbot_starter.py @tbotconfig/foobar/args/argsfoobar-noeth tbotconfig.interactive.uboot

edit linux settings in tbotconfig/foobar/foobar.ini and interactive U-Boot should work
tbottest/newtbot_starter.py @tbotconfig/foobar/args/argsfoobar-noeth tbotconfig.interactive.linux

Test your new config and setup with:

$ tbottest/newtbot_starter.py @tbotconfig/foobar/args/argsfoobar-noeth tbotconfig.interactive.lab
tbot starting ...
├─TBOT.FLAGS {'boardfile:tbotconfig/foobar/foobar.ini', 'noethinit', 'picocom', 'inifile:tbotconfig/foobar/tbot.ini', 'do_power', 'useifconfig'}
├─boardname now foobar
├─Using kas file kas-denx-withdldir.yml
FILENAME  ~/temp/tbotconfig/foobar/tbot.ini-modified
├─Calling lab ...
│   ├─[local] ssh -o BatchMode=yes -i /home/pi/.ssh/id_rsa -p 22 pi@192.168.1.113
│   ├─Entering interactive shell ...
│   ├─Press CTRL+] three times within 1 second to exit.

foolabname: ~> exit
│   ├─Exiting interactive shell ...
│   └─Done. (3.496s)
├─────────────────────────────────────────
└─SUCCESS (3.576s)
$

configuration¶

Best, use the following directory structure:

$ tree .
tbotconfig
tbot (checkout from https://github.com/Rahix/tbot)
tbottest (this repo, checkout from github)

Create for your tbot configuration and own testcases your own repo tbotconfig and use the following directory structure there:

$ tree -I log*
newtbot_starter.py
tbotconfig
├── boardspecific.py
└── BOARDNAME
    ├── args
    │   ├── argsbase (from tbottest/tbotconfig/BOARDNAME/args/argsbase, replace BOARDNAME with real name)
    │   ├── argsBOARDNAME
    │   └── [...]
    ├── README.BOARDNAME
    ├── tbot.ini
    ├── BOARDNAME.ini

see example in tbottest/tbotconfig.

Note

You can simply use the script create_setup.sh in scripts, which will create all files and directories. Start it with the option “–inter” and you get asked some questions, which help to make a better basic setup.

$ ./scripts/create_setup.sh --inter

start script¶

with the newbot_starter.py script you can start tbot and your setup without the need to install tbot and tbottest.

tbotconfig¶

contains the whole lab and board configuration.

README¶

README.BOARDNAME is not mandatory, but it is helpfull to collect/document at least some tbot usecases/commands.

file/directory overview¶

subdirectories¶
Name	content	fastlink to documentation
args	contains tbot arguments files, for easier usage	argumentfiles
tbot.ini	init file for easy configuration	tbot ini file (tbot.ini)
BOARDNAME.ini	init file with boardspecific onfigs for generic testcases	boardconfiguration file

tbot ini file (tbot.ini)¶

we use for configuring lab and board settings with:

https://docs.python.org/3/library/configparser.html

Find an example file here: tbottest:/tbottest/tbotconfig/BOARDNAME/tbot.ini

boardspecfic runtime adaptions¶

The ini file approach is static, which means we cannot change configuration @runtime. This generic approach searches in tbotconfig for a boardspecific.py file, which can contains several functions, the generic approach tries to call.

In this functions you can adapt settings dependend on the usecase. Or may do special stuff in machine shells.

In the default ini files there are placeholders beginning with @@ and ending with @@. You can easily replace them with helper functions.

Therefore the following functions are used:

set_board_cfg(temp: str = None, filename: str = None)¶

This file is called early in bootup before any ini file is parsed. So you can adapt the ini files for your needs

import tbot
from tbottest.generic.iniconfig import replace_in_file

tbot.selectable.printed = False

def print_log(msg):
     if tbot.selectable.printed:
            return

        tbot.log.message(tbot.log.c(msg).yellow)

def set_board_cfg(temp: str = None, filename: str = None):
    """
    setup board specific stuff in ini files before they get parsed
    """
    # print tbot.flags, as tbot prints them not longer
    print_log(f"TBOT.FLAGS {tbot.flags}")

    replace_in_file(filename, "@@TBOTBOARD@@", "<boardname in your lab setup>")
    replace_in_file(filename, "@@TBOTDATE@@", "20230221")
    replace_in_file(filename, "@@TBOTMACHINE@@", "<yocto machine name>")

    tbot.selectable.boardname = None
    for f in tbot.flags:
        if "selectableboardname" in f:
            tbot.selectable.boardname = f.split(":")[1]

    if tbot.selectable.boardname == None:
        tbot.selectable.boardname = "wandboard"

board_set_boardname¶

called from initconfig.py generic_get_boardname()

import tbot


def board_set_boardname() -> str:
    # do not use selectableboardname flag
    BOARDNAME = "foo"
    for f in tbot.flags:
        if "8G" in f:
            if len(f) == 2:
                BOARDNAME = "foo-8G"

    return BOARDNAME

set_ub_board_specific¶

called from boardgeneric.py in init function.

setup U-Boot specific parts after entering the U-Boot shell

def set_ub_board_specific(self):
    optargs = self.env("optargs")
    optupd = False
    if "bootchartd" in tbot.flags:
        optargs = f"{optargs} init=/lib/systemd/systemd-bootchart"
        optupd = True

    if "debug_initcalls" in tbot.flags:
        optargs = f"{optargs} initcall_debug"
        optupd = True

    if optupd == True:
        self.env("optargs", optargs)

    if "silent" in tbot.flags:
        self.env("console", "silent")

Currently there are the following sections in tbot.ini:

tbot.ini sections¶

[LABHOST]¶

here you configure common lab host setting. Mandatory.

You can select between ssh key login or password login into the lab host.

For login with ssh key set key ‘sshkeyfile’, for password login set key ‘password’.

[LABHOST]¶
key	value	example
labname	name of your lab	lab7
hostname	hostname of lab host	192.168.1.123
username	username on lab host	pi
port	ssh port number	22
sshkeyfile	path to the ssh keyfile, tbot uses	/home/USERNAME/.ssh/id_rsa
password	set password to login into lab host	FooBar
date	subdirectory in boards tftp path	20210803-ml
shelltype	type of the linux shell (bash\|ash)
toolsdir	where does tbot find tools installed on lab host	/home/USERNAME/source
tftproot	rootpath to tftp directory on lab host. tbot stores there build results.	/srv/tftpboot
tftpsubdir	boards subdir in tftproot	BOARD/DATE
workdir	tbots workdirectory on lab host	/work/USERNAME/tbot-workdir/BOARD
tmpdir	path to where tbot stores temporary data	/tmp/tbot/USERNAME/BOARD
proxyjump	if set, proxyjump settings for ssh login on lab host	pi@xeidos.ddns.net
labinit	array of strings which contains commands, executed when you init the lab	[‘sudo systemctl –all –no-pager restart tftpd-hpa’]
nfs_base_path	base path to nfs share on lab host. !! May you have board specific subdir, so use placeholder @@TBOTLABBASENFSPATH@@ in board ini file and replace it in set_board_cfg	/srv/nfs
uselocking	use board locking mechanism. You must pass correct locking id for the board with tbot flag lablocking:<lockingid> else tbot will fail.	yes\|no

The above labhost defintion is the default one, You can add more than one labhost, simply add them with the following section naming

[LABHOST_<NAME_OF_LAB>]

You can now select this lab by adding tbot flag

-f labname:<NAME_OF_LAB>

on start of tbot.

[BUILDHOST]¶

here you configure common build host setting. Only used, if you use a buildhost.

[BUILDHOST]¶
key	value	example
name	name of your build host	threadripper-big-build
username	username on your build host	hs
hostname	hostname of your build machine	192.168.1.120
port	portnumber of your build machine	12004
docker	porxy jump configuration	hs@192.168.1.120:22
dl_dir	for yocto builds, sets DL_DIR	/work/downloads
sstate_dir	for yocto builds, set SSTATE_DIR	/work2/hs/tbot2go/yocto-sstate
kas_ref_dir	when using kas, path where kas finds git trees for reference cloning	/work/hs/src
workdir	path to directory where tbot can work on	/work/big/hs/tbot2go
authenticator	path to ssh id key file	/home/hs/.ssh/id_rsa
password	password for ssh login. Unsure!	CrazyPassword
initcmd	list of commands executed after login	[“uname -a”, “cat /etc/os-release”]

If you do not add authenticator or password, tbot uses NoneAuthenticator for ssh login. Hopefully than your ssh config is correct.

The above buidlhost defintion is the default one, You can add more than one buildhost, simply add them with the following section naming

[BUILDHOST_<NAME_OF_BUILDER>]

You can now select this builder by adding tbot flag

-f buildname:<NAME_OF_BUILDER>

on start of tbot.

The next sections depend on your board configuration

[BOOTMODE_BOARDNAME]¶

if you need to set a bootmode for your board, you can add this section.

You can give each bootmode a name and if you pass this name to tbot with the “-f” flag, the lab approach first sets all gpios you have defined for this bootmode to the respective states, before it powers on the board.

[BOOTMODE_testboard]¶
key	description	default	example
modes	list of dictionary with ‘name’ and ‘gpios’ keys	[]	modes = [{‘name’:’usb_sdp’, ‘gpios’:’26:1 19:0’}, {‘name’:’spinor’, ‘gpios’:’26:0 19:0’} ]

which defines 2 bootmodes “usb_sdp” and “spinor” and sets the gpios number 26 and 19 to the state 0 or 1