UPS.CONF(5)
===========

NAME
----

ups.conf - UPS definitions for Network UPS Tools

DESCRIPTION
-----------

This file is read by the driver controller linkman:upsdrvctl[8],
the UPS drivers which use the common core (see linkman:nutupsdrv[8]),
linkman:nut-driver-enumerator[8], and the NUT data server linkman:upsd[8].
The file begins with global directives, and then each UPS has a section
which contains a number of directives that set parameters for that UPS.

A UPS section begins with the name of the UPS in brackets, and continues
until the next UPS name in brackets or until EOF.  The name "default" is
used internally in linkman:upsd[8], so you can't use it in this file.

You must define the 'driver' and 'port' elements for each entry.  Anything
after that in a section is optional.  A simple example might look like this:

	[myups]
		driver = blazer_ser
		port = /dev/ttyS0
		desc = "Web server UPS"

A slightly more complicated version includes some extras for the
hardware-specific part of the driver:

	[bigups]
		driver = apcsmart
		port = /dev/cua00
		cable = 940-0095B
		sdtype = 2
		desc = "Database server UPS"

In this case, the linkman:apcsmart[8] driver will receive variables called
"cable" and "sdtype" which have special meanings.  See the man pages of
your driver(s) to learn which variables are supported and what they do.

Here is another example, when connecting a serial UPS on Windows:

	[windows-ups]
		driver = mge-shut
		port = "\\\\.\\COM10"
		desc = "UPS on a Windows machine"

IMPORTANT NOTES
---------------

* Contents of this file should be pure ASCII (character codes
  not in range would be ignored with a warning message).
* Balance the run-time user permissions to access the file (and perhaps the
  directory it is in) for only `upsd` and the drivers to be able to read it;
  write access is not needed. It is common to use `chown root:nut` and
  `chmod 640` to set up acceptable file permissions.
  - Packages (and build recipes) typically prepare one set of user and
    group accounts for NUT. Custom builds with minimal configuration might
    even use `nobody:nogroup` or similar, which is inherently insecure.
  - On systems with extra security concerns, NUT drivers, data server
    should run as separate user accounts which would be members of one
    same group for shared access to local Unix socket files and the
    directory they are in, as well for reading `ups.conf`, but different
    groups for other configuration file access. This would need some
    daemons to use customized `user`, `group`, `RUN_AS_USER` and/or
    `RUN_AS_GROUP` settings to override the single built-in value.
  - Note that the monitoring, logging, etc. clients are networked-only.
    They do not need access to these files and directories, and can run
    as an independent user and group altogether.
  - Keep in mind the security of also any backup copies of this file,
    e.g. the archive files it might end up in.

GLOBAL DIRECTIVES
-----------------

*chroot*::

Optional.  The driver will linkmanext:chroot[2] to this directory during
initialization.  This can be useful when securing systems.

*driverpath*::

Optional.  Path name of the directory in which the UPS driver executables
reside.  If you don't specify this, the programs look in a built-in default
directory, which is often /usr/local/ups/bin.

*statepath*::

Optional.  Path name of the directory in which the UPS drivers should place
their state sockets for local communication with `upsd` data server, rather
than the default location that was compiled into the program, which is often
/var/state/ups.
+
Note that the drivers must use the same path as `upsd`, so the data server
would prefer this setting from `ups.conf` global section, if present, over
its own in `upsd.conf`.
+
Environment variable `NUT_STATEPATH` set by caller can override this setting.

*maxstartdelay*::

Optional.  Same as the UPS field of the same name, but this is the
default for UPSes that don't have the field.

*maxretry*::
Optional.  Specify the number of attempts to start the driver(s), in case of
failure, before giving up. A delay of 'retrydelay' is inserted between each
attempt. Caution should be taken when using this option, since it can
impact the time taken by your system to start.
+
The default is 1 attempt.

*nowait*::
Optional.  Specify to upsdrvctl to not wait at all for the driver(s) to
execute the request command.
+
The default (omission) is to wait.
+
It can be overridden by `NUT_IGNORE_NOWAIT` environment variable
(e.g. used to work around certain issues with systemd otherwise).

*retrydelay*::
Optional.  Specify the delay between each restart attempt of the driver(s),
as specified by 'maxretry'. Caution should be taken when using this option,
since it can impact the time taken by your system to start.
+
The default is 5 seconds.

*pollinterval*::

Optional.  The status of the UPS will be refreshed after a maximum
delay which is controlled by this setting.  This is normally 2 seconds.
This setting may be useful if the driver is creating too much of a load
on your monitoring system or network.
+
Note that some drivers (such as linkman:usbhid-ups[8], linkman:snmp-ups[8]
and linkman:nutdrv_qx[8]) also have an option called *pollfreq* which
controls how frequently some of the less critical parameters are polled.
Details are provided in the respective driver man pages.

*synchronous*::

Optional.  The drivers work by default in asynchronous mode initially
but can fall back to synchronous mode if writes to server socket failed
(i.e *synchronous=auto*).  This means that all data are pushed by the driver
on the communication socket to upsd (Unix socket on Unix, Named pipe
on Windows) without waiting for these data to be actually consumed.
With some HW, such as ePDUs, that can produce a lot of data,
asynchronous mode may cause some congestion, resulting in the socket to
be full, and the driver to appear as not connected.  In such case, the
driver will provide the following debug message:
+
	write XX bytes to socket Y failed
+
By enabling the 'synchronous' flag (value = 'yes'), the driver will wait
for data to be consumed by upsd, prior to publishing more.  This can be
enabled either globally or per driver.
+
The default of 'auto' acts like 'no' (i.e. asynchronous mode) for backward
compatibility of the driver behavior, until communications fail with a
"Resource temporarily unavailable" condition, which happens when the
driver has many data points to send in a burst, and the server can not
handle that quickly enough so the buffer fills up.

*user*::

Optional.  Overrides the compiled-in default unprivileged username for
all NUT device drivers. See the discussion of the `-u` option in
linkman:nutupsdrv[8] for details.

*group*::

Optional.  Overrides the compiled-in (and/or global-section) default
unprivileged group name for all NUT device drivers, used for the
socket file access. See the discussion of the `-g` option in
linkman:nutupsdrv[8] for details.
This may be specifically useful for ensuring access to dynamic device
filesystem nodes, such as USB (or serial-over-USB) hot-plug support,
or with device filesystems re-generated by an OS for every reboot.

*debug_min* 'INTEGER'::

Optional.  Specify a minimum debug level for all driver daemons and
for the linkman:upsdrvctl[8] tool, e.g. for troubleshooting a deployment
without changing init scripts, without impacting foreground or background
running mode directly. Command-line option `-D` can only increase this
verbosity level.

*LIBUSB_DEBUG* 'INTEGER'::

Optional.  For run-time troubleshooting of USB-capable NUT drivers,
you can specify verbosity of LibUSB specific debugging as a numeric
value such as `4` ("All messages are emitted").  Should not have any
practical impact on other NUT drivers.
+
For more details, including the currently supported values for your
version of the library, see e.g.:

* https://libusb.sourceforge.io/api-1.0/
* link:https://libusb.sourceforge.io/api-1.0/group\__libusb\__lib.html[https://libusb.sourceforge.io/api-1.0/group\__libusb__lib.html]

///////////////////
// EDITOR NOTE: There are no backslashes in the URL above, just that
// asciidoc sees them as "emphasis" markup, they had to be escaped.
// If a link from this asciidoc source file is needed, please visit:
// https://libusb.sourceforge.io/api-1.0/group__libusb__lib.html
///////////////////

UPS FIELDS
----------

*driver*::

Required.  This specifies which program will be monitoring this UPS.
You need to specify the one that is compatible with your hardware.
See linkman:nutupsdrv[8] for more information on drivers in general
and pointers to the man pages of specific drivers.

*port*::

Required.  This is the serial port where the UPS is connected.
On a Linux system, the first serial port usually is '/dev/ttyS0'.
On FreeBSD and similar systems, it probably will be '/dev/cuaa0'.
On Windows, the first serial port will be "\\\\.\\COM1" (note the
escaped slashes).

*user*::

Optional.  Overrides the compiled-in (and/or global-section) default
unprivileged username for a particular NUT device driver. See the
discussion of the `-u` option in linkman:nutupsdrv[8] for details.
This may be specifically useful for ensuring access to dynamic device
filesystem nodes, such as USB (or serial-over-USB) hot-plug support,
or with device filesystems re-generated by an OS for every reboot.

*group*::

Optional.  Overrides the compiled-in (and/or global-section) default
unprivileged group name for a particular NUT device driver, used for
the socket file access. See the discussion of the `-g` option in
linkman:nutupsdrv[8] for details.
This may be specifically useful for ensuring access to dynamic device
filesystem nodes, such as USB (or serial-over-USB) hot-plug support,
or with device filesystems re-generated by an OS for every reboot.

*sdorder*::

Optional.  When you have multiple UPSes on your system, you usually need to
turn them off in a certain order.  upsdrvctl shuts down all the 0s,
then the 1s, 2s, and so on.  To exclude a UPS from the shutdown sequence,
set this to -1.
+
The default value for this parameter is 0.

*sdcommands*::

Optional.  Comma-separated list of instant command name(s) to send to
the UPS when you request its shutdown.
+
Default logic is built into each driver (where supported) and can be
referenced here as the `shutdown.default` value.
+
The primary use-case is for devices whose drivers "natively" support
trying several commands, but the built-in order of those calls a
command that is mis-handled by the specific device model (so the
handling is reported as successful and the loop stops, but nothing
happens as far as the load power-down is concerned).
+
Another use-case is differentiation of automated power-off scenarios
where the UPS and its load should stay "OFF" (e.g. by building emergency
power-off) vs. those where the load should return to work automatically
when it is safe to do so.  NOTE: This would *currently* need editing of
`ups.conf` for such cases before `nutshutdown` sees the file; but could
be better automated in future NUT releases.
+
NOTE: User-provided commands may be something other than actual shutdown,
e.g. a beeper to test that the INSTCMD happened such and when expected,
and the device was contacted, without impacting the load fed by the UPS.

*allow_killpower*::
Optional.  This allows you to request `driver.killpower` instant command,
to immediately call the driver-specific default implementation of
`upsdrv_shutdown()` method, for same effect as when a NUT driver is
started with `-k` command-line flag.  This option can be toggled with
linkman:upsrw[8] as `driver.flag.allow_killpower` during run-time.

*desc*::

Optional.  This allows you to set a brief description that upsd will provide
to clients that ask for a list of connected equipment.

*nolock*::

Optional.  When you specify this, the driver skips the port locking routines
every time it starts.  This may allow other processes to seize the port if
you start more than one accidentally.
+
You should only use this if your system won't work without it.
+
This may be needed on Mac OS X systems.

*ignorelb*::

Optional.  When you specify this, the driver ignores a low battery condition
flag that is reported by the UPS (some devices will switch off almost
immediately after setting this flag, or will report this as soon as the
mains fails).  Instead it will use either of the following conditions to
determine when the battery is low:

	battery.charge < battery.charge.low
	battery.runtime < battery.runtime.low
+
The idea is to set the battery.charge.low and/or battery.runtime.low levels
in *ups.conf* to a value that gives enough time to cleanly shutdown your
system:

	override.battery.charge.low = 30
	override.battery.runtime.low = 180
+
In order for this to work, your UPS should be able to (reliably) report
charge and/or runtime remaining on battery.  Use with caution!

*maxstartdelay*::

Optional.  This can be set as a global variable above your first UPS
definition and it can also be set in a UPS section.  This value controls how
long upsdrvctl will wait for the driver to finish starting.  This keeps your
system from getting stuck due to a broken driver or UPS.
+
Note that after this time `upsdrvctl` would just move along with its
business (whether retrying the same driver if `maxretry>1`, or trying
another driver if starting them all, or just eventually exit); however,
each such most recently started "stuck" driver process may be further
initializing in the background, and might even succeed eventually.
+
They would not be actively killed by `upsdrvctl` after this timeout expires.
+
The default is 75 seconds.

*maxretry*::
Optional.  This can be set as a global variable above your first UPS
definition and it can also be set in a UPS section.  See explanation
above, in the global section.

*retrydelay*::
Optional.  This can be set as a global variable above your first UPS
definition and it can also be set in a UPS section.  See explanation
above, in the global section.

*synchronous*::

Optional.  Same as the global directive of the same name, but this is
for a specific device.

*usb_set_altinterface*[='altinterface']::

Optional.  Force the USB code to call `usb_set_altinterface(0)`, as was done in
NUT 2.7.2 and earlier.  This should not be necessary, since the default for
`bAlternateSetting` (as shown in lsusb) is zero on all USB devices seen to
date.  However, this redundant call to `usb_set_altinterface()` prevents
certain UPSes from working on Mac OS X. If your UPS requires explicitly setting
the alternate interface, include this flag, and email the nut-upsdev list with
details about your UPS and operating system.

*usb_config_index*::
*usb_hid_rep_index*::
*usb_hid_desc_index*::
*usb_hid_ep_in*::
*usb_hid_ep_out*::

Optional.  Force use of specific interface, endpoint, descriptor index etc.
numbers, rather than defaulting to 0 (rarely other values in certain drivers
for some devices known to use non-zero numbers). Specified as a hexadecimal
number.
+
As a rule of thumb for `usb_hid_desc_index` discovery, you can see larger
`wDescriptorLength` values (roughly 600+ bytes) in reports of `lsusb` or
similar tools.

*default.<variable>*::

Optional.  Set a default value for <variable> which is used in case the UPS
doesn't provide a value, but will be overwritten if a value is available
from the UPS:

	default.input.voltage.nominal = 230
+
The above will report the nominal input voltage to be 230, unless the UPS
tells us differently.

*override.<variable>*::

Optional.  Set a value for <value> that overrides any value that may be read
from the UPS.  Used for overriding values from the UPS that are clearly wrong
(some devices report wrong values for battery voltage for instance):

	override.battery.voltage.nominal = 12
+
Use with caution!  This will only change the appearance of the variable to
the outside world, internally in the UPS the original value is used.

All other fields are passed through to the hardware-specific part of the
driver.  See those manuals for the list of what is allowed.

*debug_min* 'INTEGER'::

Optional.  Specify a minimum debug level for this driver daemon, e.g. for
troubleshooting a deployment, without impacting foreground or background
running mode directly.  If the global `debug_min` is also set, this
driver-level setting overrides it.  Command-line option `-D` can only
increase this verbosity level.

*LIBUSB_DEBUG* 'INTEGER'::

Optional.  For run-time troubleshooting of USB-capable NUT drivers,
you can specify verbosity of LibUSB specific debugging as a numeric
value such as `4` ("All messages are emitted").
+
For more details, including the currently supported values for your
version of the library, see e.g.:

* https://libusb.sourceforge.io/api-1.0/
* link:https://libusb.sourceforge.io/api-1.0/group\__libusb\__lib.html[https://libusb.sourceforge.io/api-1.0/group\__libusb__lib.html]

///////////////////
// EDITOR NOTE: There are no backslashes in the URL above, just that
// asciidoc sees them as "emphasis" markup, they had to be escaped.
// If a link from this asciidoc source file is needed, please visit:
// https://libusb.sourceforge.io/api-1.0/group__libusb__lib.html
///////////////////

INTEGRATION
-----------

linkman:upsdrvctl[8] uses this file to start and stop the drivers.

The drivers themselves also obtain configuration data from this file.
Each driver looks up its section and uses that to configure itself.

linkman:upsd[8] learns about which UPSes are installed on this system by
reading this file.  If this system is called "doghouse" and you have
defined a UPS in your *ups.conf* called "snoopy", then you can monitor it
from linkman:upsc[8] or similar as "snoopy@doghouse".

SEE ALSO
--------

linkman:upsd[8], linkman:nutupsdrv[8], linkman:upsdrvctl[8],
linkman:upsdrvsvcctl[8]

Internet resources
~~~~~~~~~~~~~~~~~~

The NUT (Network UPS Tools) home page: https://www.networkupstools.org/
