Linux run app at startup

Run the application at startup in linux

I am making a Linux application. This application synchronizes the client’s files and folders with cloud. There is folder in home directory in which all the files from cloud will be synchronized. I want that the application should be started in background after boot and work in background automatically. How can I do it?

2 Answers 2

If you have systemd you can create a service as shown here.

Otherwise you have to use init.

If you have what is essentially a single-user system, you can use init / systemd to start background processes as a nominated, unprivileged user. However, that isn’t the usual use of these techniques.

In a multi-user, graphical system, you probably want user-related background processes to start when the user’s desktop session starts. Not only is this (usually) the proper timing for such operations, it allows multiple users to be supported.

The various graphical desktops available for Linux all provide slightly different ways to run user applications at login. It’s probably impossible to find a method that will work for all desktops. For full coverage, you probably need to implement something that detects what desktop is in use, and uses the method appropriate to that desktop.

However, many desktops respect the use of $HOME/.config/autostart/ . Files in that directory should have a .desktop extension, and be of the same format as application launchers. For example:

Источник

How to automatically run program on Linux startup

There are a few stages of Linux startup, and you can set your own autostart script or program at any of the stages where it could be a single command, a chain of commands, or an executable shell script. There could be, however, some differences in startup procedure between different Linux distributions and versions.

Modern Linux will first boot into systemd while older versions of Linux uses System V init. Both methods will run cron and rc.local before the desktop environment such as GNOME or KDE is loaded. On the other hand, server-based Linux distributions will run the default shell such as Bash after the user logged in at the console instead of loading the desktop environment.

Methods to automatically run program on Linux startup:

Automatically run program on Linux startup via systemd

systemd is the standard system and service manager in modern Linux. It is responsible for executing and managing programs during Linux startup, among many other things. Compatible programs will provide service unit files used by systemd to manage the program’s execution.

You can configure systemd to run programs automatically during Linux startup following these steps:

You’ll have to create your own service unit if it’s a custom program or if your program doesn’t come with one during installation
Related: Creating and modifying systemd unit files

enabled service unit is executed during boot

Automatically run program on Linux startup via cron

cron is a daemon to execute scheduled commands. The commands are stored in the cron job table or crontab and are unique for each user in the system. It’s started during system boot either by systemd or System V init, and you can schedule your job or program to be executed right during the system boot itself by following these steps:

You’re required to select an editor for the crontab if this is the first time the user uses the command.

A crontab will be created for the user running the command and will be executed using the privileges of the user. If you need your program to run as the root user, run crontab -e as the root user itself.

@reboot defines the job to be executed during system boot.

Use full path for your programs when possible and write your commands in a single line.

The file is saved in /var/spool/crontab/

Automatically run program on Linux startup via rc.local

rc.local is a legacy from the System V init system. It is the last script to be executed before proceeding to a login screen for the desktop environment or a login prompt at the terminal. It’s usually a Bash shell script, and you can run anything from the script.

You can configure your rc.local script following these steps:

It must start with interpreter (/bin/bash) and ends with an exit code (0 is for success)

The file will be executed as the root user during system boot

Automatically run program on GNOME startup

GNOME is the default desktop environment for Linux distributions such as Ubuntu and Red Hat. GNOME can be configured to run programs when a user logs in and can be configured by following the below article:

Automatically run program on KDE startup

KDE is another popular desktop environment for Linux and is the default in Kubuntu and openSUSE. It can easily be configured to run programs when a user logs in as detailed in the following article:

Automatically run program on new Bash session

A new shell program will be spawned when you start your terminal session. Bash is the default shell for most Linuxdistributions, and when started, it will look for the following files in the particular order and executes them.

These files contains commands and logics to set up proper environment variables and run required programs in Bash language. It’s also configured to normally execute other files such as /etc/bashrc, /etc/bash.bashrc and

You can edit any of these files to run your program when a Bash session is started. Below is a part of a typical

Comment anonymously. Login not required.

Источник

How do I run a single command at startup using systemd?

I’d like to startup an Apache Spark cluster after boot using the following command:

Then run this command when the system prepares to reboot/shutdown:

How can I get started? Is there a basic template I can build on?

I’ve tried to use an extremely simple (file: /lib/systemd/system/spark.service ):

Which doesn’t work.

2 Answers 2

Your .service file should look like this:

Now, take a few more steps to enable and use the .service file:

Place it in /etc/systemd/system folder with say a name of myfirst.service

Make sure that your script executable with:

Enable it to run at boot:

Notes

You don’t need to launch Spark with sudo in your service, as the default service user is already root.

Look at the links below for more systemd options.

Moreover

Now what we have above is just rudimentary, here is a complete setup for spark:

To setup the service:

Further reading

Please read through the following links. Spark is a complex setup, so you should understand how it integrates with Ubuntu’s init service.

Copy-paste this into a terminal (as root) to create /root/boot.sh and run it on boot:

To modify the parameters, for example to use a different $bootscript , just set that variable manually and skip that line when copying the commands.

Источник

How to Autorun Application at the Start up in Linux

Contents

Introduction

This article describes how to automatically start an application during or after boot of an Apalis, Colibri and Verdin Computer on Modules running Embedded Linux.

TorizonCore

On TorizonCore, the applications are packaged in containers. The containers are run by the container engine, which is Docker in our case.

Docker is already set to autorun, and to start your applications on boot in TorizonCore you must describe what containers to use and how to bring them up. Please have a look at our content about the steps to automatically start a container with TorizonCore in Run and Manage Docker Containers on Torizon.

Reference Images for Yocto Project

For our Reference Images for Yocto Project, you can follow any of the topics described below in order to attend to your project or use-case needs.

Systemd

Starting with V2.x of our Linux BSP we use systemd as our init and service manager.

Systemd is a system and service manager for Linux, also capable of replacing the traditional SysV init system. You can read its manual here.

A unit configuration is a file which name ends in .service, and it encodes information about a process controlled and supervised by systemd. Service files can be found in /etc/systemd/system/ and, for distribution provided ones in /lib/systemd/system/ .

You can enable, disable, start, stop and check services status by using the systemctl command.

The common configuration items are configured in the generic [Unit] and [Install] sections.

The service specific configuration options are configured in the [Service] section.

Service files must include a [Service] section, which carries information about the service and the process it supervises.

For more information possible options of a [Service] section refer to the documentation.

Procedure

Create a unit configuration file ending in .service

Copy the unit configuration file to /etc/systemd/system and use the systemctl tool for enabling and starting the service.

Using the systemctl command

Based on the SystemD documentation, you need to reload the systemd configuration after the addition or change on any unit files:

To check a service status, or to start and stop a service, which is valid until next reboot, you can use the following commands:

To add a service to or remove it from the list of services to be started at boot. Note: This neither starts or stops the service but takes only effect during the next boot

Here is an example of an unit configuration file to automatically execute the (hypothetical) mydatalogger application at start up:

Shells

/etc/profile

Each time a login shell is spawned, the script /etc/profile plus all scripts in /etc/profile.d are executed.

This is done for logins over a serial console, over an ssh connection and also for logins in the display manager to a graphical desktop.

/etc/profile is sourced upon login: it sets up the environment upon login and application-specific settings by sourcing any readable file in /etc/profile.d/ .

Using /etc/profile is well suited to set the environment or to do some small tasks.

Note that these scripts must return control in order to continue with the login.

Remove the file in /etc/profile.d or the additions to /etc/profile in order to undo the automatic execution.

Procedure

To load a Shell Script at each login, you just need to add a script file in /etc/profile.d/ .

Remembering that the Shell Script must have the *.sh extension.

Below is an example of a script file for deleting backup entries:

Graphical

Weston Desktop

The more recent Toradex Linux BSP 5 has been using the Weston/Wayland graphic compositor, instead of the X11 that has been used until our BSP 3.0.

Please be aware that Wayland is the Protocol, Weston is the Graphical Compositor which implements the Wayland protocol. You can read more about it at Wayland page.

Any graphical application developed for X11 should work as well, as the Weston compositor is configured to operate with the XWayleand compatibility mode, which allows X11 Clients.

That said, for you to create a graphical application that will automatically start with the system boot, this application must start after Weston service.

An example for a wayland graphical application to be automatically executed on boot is presented below.

As you can see, that service calls a script to be executed. That’s because it’s necessary to check if the XDG_RUNTIME_DIR environment variable has been set, and if not, we must set it.

Weston will use XDG_RUNTIME_DIR for Window Context.

It’s also recommended to export the DISPLAY variable accordingly as well. See below:

With both the service and the script, your Wayland application will be automatically executed on boot.

Yocto Project/OpenEmbedded

We prepared scripts to autorun your application in Wayland/Weston on startup directly from a Yocto Project/OpenEmbedded build. It is called wayland-app-launch and also how we autorun Qt Demos on the Multimedia Reference Image. Check out the given links, which contain examples of how you can integrate this into OE.

X11 Desktop

You can start applications automatically when you login into your Window Manager or Desktop Environment.

With the angstrom-lxde-image you’ll get the following options. Other desktop environments provide similar means.

The lxsession session manager can start applications when the graphical environment is started.

This can be achieved in two ways:

A lxsession specific way, in which the entries in the files /etc/xdg/lxsession/LXDE/autostart and

/.config/lxsession/LXDE/autostart are parsed.

A generic way which many session managers support. Files in the folders /etc/xdg/autostart/ and

/.config/autostart/ ending with .desktop get parsed and, if applicable, the application described therein is started.

You can check more information in the LXSession documentation.

LXSession Autostart File

To use the 1st option, you will need to edit /etc/xdg/lxsession/LXDE/autostart or

Add the application or command-line you want to be executed to a new line in the file.

If you want that your application be restarted if it gets terminated abnormally, precede the application name with a @. Like for example the lxterminal, with @lxterminal at /etc/xdg/lxsession/LXDE/autostart:

Note that this file is not a shell script and therefore shell acrobatics like redirections and pipes are not allowed.

If required this can done by spawning a custom shell script, which in turn can support the full shell feature set.

.desktop Files

Basically, to have a service or application to start with this approach, the steps are to create a .desktop file and add it to autostart.

You can check more information about this in the .desktop file documentation. Note: In /usr/share/applications/ there is already a number of .desktop files which can be copied into the autostart folder.

For example, if you want to execute lxterminal automatically at startup, you can do the following: 1. Create a terminal.desktop in /etc/xdg/autostart/ . Add some key entries like:

• [Desktop Entry] — Must be the first line of every desktop file and is the section header to identify the block of key value pairs associated with the desktop. Necessary for the desktop to recognize the file correctly.
• Name of the application.(The name of the Desktop Entry group — should be unique on the system )
• Type of the application. (Possible values are «Application», «Link» or «Directory».)
• Exec filename of the application plus optionally arguments.
• Terminal (Describes whether the application should run in a terminal.)

An example of a .desktop file content with the entries should be as follows:

1. After editing, save the .desktop.

Note: A graphical file manager will list .desktop files not with their file name but rather with the value of the key «Name». e.g. in the example above «LXTerminal».

To disable the automatic start of an application, just either remove the respective *.desktop file from /etc/xdg/autostart/ and/or .config/autostart/ , or add the key NotShowIn=LXDE; to the desktop file.

Alternatively use the graphical front end ‘LXDE Menu’/Preferences/’Desktop Session Settings’ and untik the ‘Enabled’ checkbox.

X11 with One User Application

If your use-case requires to start X11, probably it will also require to start some configuration tasks like keyboard mapping, touch screen calibration and then start the one and only user application. In this case, you can adopt a scheme like the one used in angstrom-qt5-x11-image and qt4e-demo-image.

Script Started by Systemd

The qt4e-demo-image and angstrom-qt5-x11-image (prior to 2.8b2) use a systemd service and a home brew script. The script starts the X-server followed by the user application. Integrating any setup tasks between the start of X11 and the start of the user application into the script produces a bunch of issues as this sometimes stops the X-server and so on.

However for a simple system that might be enough.

To start your X11 application instead of the demo application change the script accordingly.

Using nodm, xinit, and a Custom Script

The angstrom-qt5-x11-image (starting with 2.8b2) uses the simple display manager nodm from OpenEmbedded to start X11. This uses the configuration data in /etc/X11 , e.g. Xsession.d, e.g. to start the touch calibrator. As the last step it searches for a script x-window-manager and sources that one.

To start your X11 application override the following two variables in the x-window-simple-app recipe to set the initial working directory and to specify the application:

Источник