有什么办法吗？
如何编写脚本来/usr/lib/pm-utils/sleep.d检查${downspeed eth0}、${upspeed wlan0}和，${upspeed eth0}并${downspeed wlan0}设置系统在下载过程中不暂停而仅关闭屏幕？
我的操作系统是 Ubuntu 15.04。
答案1
受到@ByteCommanders 第二条评论的启发，下面的脚本执行了您所描述的操作：假设下载文件夹是你下载到的目录
，它会在下载过程中禁用暂停功能，然后等待五分钟（任意设置）再重新启用暂停功能，以确保下载确实完成。能将任何其他目录设置为下载文件夹。
怎么运行的
该脚本循环（每 20 秒一次）使用以下命令检查目标文件夹的大小：
du -ks ~/Downloads
脚本将每次检查与上一次检查进行比较，以检查下载活动（大小增加）。如果超过五分钟没有活动（但您可以设置任何其他“等待”时间），则脚本假定没有下载正在进行，并且“正常”暂停已（重新）启用。
反过来：如果脚本发现~/Downloads目录的大小不断增加，它就会禁用暂停功能，直到五分钟内没有检测到任何活动。
果汁不足
脚本的命令占用的资源极少。由于循环每 20 秒仅运行一次（事实如此），处理器负载几乎为零。
剧本
#!/usr/bin/env python3
import subprocess
import time
#--- set suspend time below (seconds)
suspend_wait = 300
#---
#--- you can change values below, but I'd leave them as they are
speed_limit = 0 # set a minimum speed (kb/sec) to be considered a download activity
looptime = 20 # time interval between checks
download_wait = 300 # time (seconds) to wait after the last download activity before suspend is re- activated
#---
t = 0
key = ["gsettings", "get", "org.gnome.settings-daemon.plugins.power", "sleep-inactive-ac-timeout", "set"]
set_suspend = key[0]+" "+key[-1]+" "+(" ").join(key[2:4])
get_suspend = (" ").join(key[0:4])
def get_size():
return int(subprocess.check_output(["/bin/bash", "-c", cmd]).decode("utf-8").split()[0])
def get(cmd):
return subprocess.check_output(["/bin/bash", "-c", cmd]).decode("utf-8")
check_1 = int(get("du -ks ~/Downloads").split()[0])
while True:
time.sleep(looptime)
try:
check_2 = int(get("du -ks ~/Downloads").split()[0])
except subprocess.CalledProcessError:
pass
speed = int((check_2 - check_1)/looptime)
# check current suspend setting
suspend = get(get_suspend).strip()
if speed > speed_limit:
# check/set disable suspend if necessary
if suspend != "0":
subprocess.Popen(["/bin/bash", "-c", set_suspend+" 0"])
t = 0
else:
if all([t > download_wait/looptime, suspend != str(download_wait)]):
# check/enable suspend if necessary
subprocess.Popen(["/bin/bash", "-c", set_suspend+" "+str(suspend_wait)])
check_1 = check_2
t = t+1
如何使用
- 将以下脚本复制到一个空文件中，并将其另存为
no_suspend.py 在脚本的头部，设置所需的“正常”挂起时间（因为脚本将重新启用挂起）：
#--- set suspend time below (seconds) suspend_wait = 300 #---如果你愿意，你能设置其他值：
#--- you can change values below, but I'd leave them as they are speed_limit = 0 # set a minimum speed (kb/sec) to be considered a download activity looptime = 20 # time interval between checks download_wait = 300 # time (seconds) to wait after the last download activity before suspend is re- activated #---使用以下命令测试运行脚本：
python3 /path/to/no_suspend.py如果一切正常，请将其添加到您的启动应用程序中：Dash > 启动应用程序> 添加命令：
python3 /path/to/no_suspend.py
答案2
更新（2016-06-11）：自从第一次编写下面的脚本以来，它已经发展成为一个完整的程序，可以根据以下情况确定何时暂停
- 网络流量
- 用户活动
- CPU 负载
我已经在 Launchpad 上发布了它https://launchpad.net/keep.awake根据 GPL 许可。
目前还没有 snap 包或 deb，但我最终会找到它的。在此期间，你可以下载这并解压缩以供使用。
它的工作方式与正确的命令类似。
输入 --help 可查看可执行操作的完整列表。下面的示例只是其中几个：
./keepawake.py --help
以交互方式运行：
./keepawake.py
要作为后台服务运行：
nohup ./keepawake.py -r > /dev/null 2>&1 &
作为后台服务运行，并在确定用户处于空闲状态之前将 15 分钟（900 秒）设置为用户活动空闲时间：
nohup ./keepawake.py -u 900 -r > /dev/null 2>&1 &
要作为后台服务运行并将最低 CPU 负载设置为 13%：
nohup ./keepawake.py -c 13 -r > /dev/null 2>&1 &
作为后台服务运行并将最小网络流量设置为 5KB（5120 字节）：
nohup ./keepawake.py -s 5120 -r > /dev/null 2>&1 &
要一次性运行上述所有三个设置（网络、CPU、用户空闲）：
nohup ./keepawake.py -s 5120 -c 13 -u 900 -r > /dev/null 2>&1 &
[原帖]：
根据 dhiya 的回复，我对脚本进行了大量修改。它可以同时处理网络流量和用户活动！
我必须给它起个名字，所以我把它命名为“保持清醒”。
如果您有任何问题或意见，请尝试一下并回复！
发行说明...
- 根据阈值检查用户活动和网络流量
- 如果其中一个或两个都超出阈值限制，则操作系统挂起电源设置将被禁用。
- 我对代码的第一次修改使它降到了 Python 2.7.x，我不得不将它迁移回 3.4.x
- 使用 python 3 功能实现了打印到日志文件和标准输出。
- 添加了许多数据打印以确定状态。对于故障排除非常有帮助。
- 在 If-elif-else 逻辑中，我添加了倒计数器。
- 添加了许多评论，希望能对新手有所帮助。
- 已捆绑 logrotate 配置，您可以使用它来永久管理输出日志。（参见历史记录中的评论）
- 强烈建议将 logrotate cron 移至 cron.hourly
- 使用 xprintidle
- logrotate 配置使用 xz-utils
- 反复的性能测试表明，对 CPU 的影响几乎可以忽略不计。只有 logrotate 运行的 xz 压缩算法会对单个核心产生高达 100% 的影响。但它在现代 CPU 上不会持续很长时间，而且它是单线程的。因此您的其他核心可以做其他工作。它只会压缩几天前的日志或大于 20MB 的日志。
- 对配置满意后，您可以使用发行版的内置启动应用程序启动器进行设置，该启动器将在登录您的帐户时启动该程序。确保您已使用下面的脚本配置配置了 logrotate 来管理日志文件。您也可以根据自己的喜好进行调整。
- 2015 年 9 月 16 日 - 版本 2.1 - 添加了强制优雅暂停逻辑
- 2015 年 9 月 16 日 - 版本 2.1 - 程序现在设计为使用 sudo 权限运行并记录到 /var/log/Keep.Awake/ 。logrotate 配置现在将默认使用多核处理进行压缩，并且仅在大于 1M 时才旋转。这需要 xz-utils >= v5.2.0
在后台运行的示例命令
$ sudo nohup python3 Keep\ Awake.v2.py > /dev/null 2>&1 &
文件名：“Keep\ Awake.v2.py”
#!/usr/bin/env python3
import subprocess
import time
import logging
import datetime
import sys
#--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# Keep Awake
# version: 2.1
#
# PURPOSE:
# This program will check 'network traffic' AND 'user activity' and decide whether to enable the timer to suspend or cancel it.
#
# METHOD:
# The program checks the network traffic if it is greater than a certain treshold; if so it keeps the system awake; if not it checks for user activity.
# If the user activity is idle for a time greater than a treshold then it sets the timer to suspend.
#
# SAMPLE RUN COMMAND:
# sudo nohup python3 Keep\ Awake.v2.py > /dev/null 2>&1 &
#
# History:
# 2015-08-22 DanglingPointer - Modified from https://askubuntu.com/questions/576525/can-i-prevent-ubuntu-being-suspended-while-a-download-is-in-progress/661085#661085
# 2015-09-12 DanglingPointer - Modified to version 2 and renamed "Keep Awake".
# - Version two now prints to standard output as well as a log file information useful for troubleshooting.
# - Comes with a "Kee,Awake.v2.logrotate.config" file which can be used with linux logrotate.d. It is recommended that logrotate be moved to cron.hourly.
# - Upgraded coded from Python 2 to 3 using 2to3 command.
# - Requires xprintidle linux package.
# 2015-09-16 DanglingPointer - Modified to version 2.1. Added logic to "gracefully force suspension" if automatic suspension fails to happen. This has been observed to happen when
# - the setting to require a password after suspension is enabled locking the desktop. Keep.Awake.v2.1 will now send a dbus message to force graceful suspension.
# - **NOTE 1** "Force Graceful suspension" will ONLY work in this version if the program is run as root (sudo privilege) after logging into a user account.
# - **NOTE 2** "Force Graceful suspension" will NOT work if the program is sudo-run from command prompt without logging into a user desktop. (i.e. Fails when: run from CTL+ALT+F2 before login OR run from prompt after "switch user" is selected after locking desktop -> in that order)
#--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# CONFIG
suspend_wait = 3600 # set suspend time (seconds); In Ubuntu 14.04 it needs to be the equivalent of one of the options from the Power Settings or else it may not work.
speed_limit = 1024 # set a minimum speed (bytes/second) to be considered a download activity
looptime = 20 # time interval between checks (seconds)
download_wait = 300 # time (seconds) to wait after the last download activity before suspend is re-activated.
userIdle = download_wait*1000 # user activity idle time in miliseconds before suspend is re-activated, requires xprintidle linux package
forceGraceTime = download_wait # time (seconds); in the event that the automatic suspend fails (like locked screen/user is at login screen) The system is given additional grace-time before a suspension is forced.
logFileLocation = "/var/log/Keep.Awake/" # Logfile location
logFileName = "Keep.Awake.log" # Logfile name
# RATIOS
download_waitTOlooptimeRatio = download_wait/looptime
suspend_waitTOlooptimeRatio = suspend_wait/looptime
forceGraceTimeTOlooptimeRatio = forceGraceTime/looptime
# STRING CONSTANTS
key = ["gsettings", "get", "org.gnome.settings-daemon.plugins.power", "sleep-inactive-ac-timeout", "set"]
dbusForceSuspend = ["dbus-send", "--print-reply", "--system", "--dest=org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.UPower.Suspend"]
# WHERE TO OUTPUT
logging.basicConfig(level=logging.INFO, format='%(message)s')
logger = logging.getLogger()
logger.addHandler(logging.FileHandler(logFileLocation + logFileName, 'a'))
print = logger.info
# VARIALBES
rx_speed=0 # receive speed
tx_speed=0 # transmit speed
t = 0 # time interval interation count
countDown = 0 # count down integer
downLoadWaitCountDown = 0 # count down for download_wait
graceCountDown = 0 # count down for forced grace time. See comments above for forceGraceTime CONFIG
graceFlag = False # flag to provide grace period
set_suspend = key[0]+" "+key[-1]+" "+(" ").join(key[2:4])
get_suspend = (" ").join(key[0:4])
force_suspend = (" ").join(dbusForceSuspend)
print ("")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print ("KEEP AWAKE v2.1")
print ("Python version: " + (sys.version))
print ("")
print ("Program Date-Time Start: " + datetime.datetime.now().isoformat())
print ("Configuration Loaded...")
print ("suspend_wait: " + str(suspend_wait) + " - Time in seconds for setting 'Suspend when inactive for' for the OS.")
print ("speed_limit: " + str(speed_limit) + " - Minimum amount of data in bytes to qualify as activity.")
print ("looptime: " + str(looptime) + " - Time interval in seconds between checks for network activity.")
print ("download_wait: " + str(download_wait) + " - Time in seconds to wait after last download activity before 'suspend_wait' is applied to the OS.")
print ("userIdle: " + str(userIdle) + " - Idle time in miliseconds to wait before 'suspend_wait' is applied to the OS.")
print ("forceGraceTime: " + str(forceGraceTime) + " - Time in seconds; in the event that the automatic suspend fails (like locked screen/user is at login screen), the system is given additional grace-time before a suspension is forced.")
print ("logFileLocation: " + logFileLocation + " - Logfile location")
print ("logFileName: " + logFileName + " - Logfile name")
print ("")
print ("Variables Loaded...")
print ("rx_speed: " + str(rx_speed) + " - Received bytes in last interval")
print ("tx_speed: " + str(tx_speed) + " - Transmited bytes in last interval")
print ("set_suspend: " + set_suspend + " - String used to construct Shell command to set the 'Suspend when inactive for' for the OS.")
print ("get_suspend: " + get_suspend + " - String used to construct Shell command to get the 'Suspend when inactive for' setting from the OS.")
print ("force_suspend: " + force_suspend + " - String used to construct Shell command to force the 'Suspend.")
print ("\n\n")
def get(cmd):
return subprocess.check_output(["/bin/bash", "-c", cmd]).decode("utf-8")
def get_bytes(t, iface='eth0'):
with open('/sys/class/net/' + iface + '/statistics/' + t + '_bytes', 'r') as f:
data = f.read();
return int(data)
if __name__ == '__main__':
(tx_prev, rx_prev) = (0, 0)
while(True):
print ("Interval Loop Started:\t" + datetime.datetime.now().isoformat())
tx = get_bytes('tx')
rx = get_bytes('rx')
if tx_prev > 0:
tx_speed = tx - tx_prev
if rx_prev > 0:
rx_speed = rx - rx_prev
print (str(tx_speed) + " bytes TRANSMITTED in since last interval.")
print (str(rx_speed) + " bytes RECEIVED in since last interval.")
print ("Starting nap for " + str(looptime) + " seconds...")
time.sleep(looptime)
print ("Awaking from nap:\t" + datetime.datetime.now().isoformat())
tx_prev = tx
rx_prev = rx
speedrx =rx_speed/looptime
print ("RECEIVE speed: " + str(speedrx) + " bytes/second")
speedtx = tx_speed/looptime
print ("TRANSMIT speed: " + str(speedtx) + " bytes/second")
if speedtx > speedrx:
speed = speedtx
else:
speed = speedrx
print ("Highest speed selected: " + str(speed) + " bytes/second")
suspend = get(get_suspend).strip()
print ("Speed Limit configured: " + str(speed_limit) + " bytes/second" )
print ("'t'-value loop counter: " + str(t))
print ("'download_wait'/'looptime': " + str(download_waitTOlooptimeRatio))
print ("'suspend' value == " + suspend)
idleTime = int(get("xprintidle"))
print ("User activity idle time: " + str(idleTime/1000) + " seconds")
print ("User activity idle threshold limit: " + str(userIdle/1000) + " seconds")
if speed > speed_limit or userIdle >= idleTime:
# check/set disable suspend if necessary
if suspend != "0":
subprocess.Popen(["/bin/bash", "-c", set_suspend+" 0"])
t = 0
graceFlag = False
print ("Threshold limits breached... keeping system awake...")
elif t > download_waitTOlooptimeRatio:
# check/enable suspend if necessary
subprocess.Popen(["/bin/bash", "-c", set_suspend+" "+str(suspend_wait)])
countDown = suspend_waitTOlooptimeRatio - (t - download_waitTOlooptimeRatio)
# hack logic - if countDown goes below zero, and automatic sleep fails --> force suspend provide grace period.
if countDown < 0 and not graceFlag:
graceCountDown = -(countDown - forceGraceTimeTOlooptimeRatio)
graceFlag = True
print ("FORCE SUSPEND: Expected automatic sleep did not happen. User desktop session likely locked to login screen.")
print ("FORCE SUSPEND: Providing grace time before forcing suspension.")
print ("FORCE SUSPEND: Counting-down to FORCED suspend..." + str(graceCountDown))
graceCountDown = graceCountDown - 1
elif countDown < 0 and graceFlag:
print ("FORCE SUSPEND: Counting-down to FORCED suspend..." + str(graceCountDown))
graceCountDown = graceCountDown - 1
if graceCountDown < 0:
print ("FORCE SUSPEND: Force Suspending...")
# prime graceFlag to False in case it comes back up to the same conditions allowing a new grace time
graceFlag = False
# execute suspend command
subprocess.call(force_suspend, shell=True)
else:
print ("Cumulative activity below threshold limits... Counting-down to suspend..." + str(countDown))
else:
downLoadWaitCountDown = download_waitTOlooptimeRatio - t
print ("Zero activity... Waiting before setting suspension count down..." + str(downLoadWaitCountDown))
t = t+1
print ("Interval Loop End:\t" + datetime.datetime.now().isoformat())
print ("---------------------------------------------------------")
logrotate 自定义配置。使用“$man logrotate”了解其使用详情。它非常方便！... 文件名：“Keep.Awake.v2.logrotate.config”
/var/log/Keep.Awake/Keep.Awake.log
{
copytruncate
size 1M
rotate 30
compress
delaycompress
compresscmd /usr/bin/xz
compressext .xz
compressoptions -9e --threads=0
missingok
notifempty
extension .log
create 664 root danglingpointer
su root root
}
答案3
根据提供的答案这里，我修改了@Jacob Vlijm 的脚本如下，以防止 Ubuntu 在上传或下载过程中暂停。你必须安装打印空闲第一的。
#!/usr/bin/env python3
#install xprintidle first, it is a binary written in C; see https://packages.debian.org/sid/xprintidle
#This script is for prevent/supersede suspend while a download/upload in progress.
#Change wlan0 (wifi) to eth0 (ethernet) or use both if its applies.
#add it to your startup applications: Dash > Startup Applications > add the command: python3 /path/to/delay_suspend.py
import subprocess
import time
time.sleep(15)
subprocess.Popen(['notify-send', "Ubuntu will supersede suspend while a download/upload in progress"])
#--- set suspend time below (seconds)
suspend_wait = 300
#---
#--- you can change values below, but I'd leave them as they are
speed_limit = 1000 # set a minimum speed (bytes/looptime) to be considered a download activity
looptime = 20 # time interval between checks
download_wait = 300 # time (seconds) to wait after the last download activity before suspend is re- activated
#---
rx_speed=0
tx_speed=0
speed=0
idletime = 2
t = 0
key = ["gsettings", "get", "org.gnome.settings-daemon.plugins.power", "sleep-inactive-ac-timeout", "set"]
set_suspend = key[0]+" "+key[-1]+" "+(" ").join(key[2:4])
get_suspend = (" ").join(key[0:4])
def get_size():
return int(subprocess.check_output(["/bin/bash", "-c", cmd]).decode("utf-8").split()[0])
def get(cmd):
return subprocess.check_output(["/bin/bash", "-c", cmd]).decode("utf-8")
def get_bytes(t, iface='wlan0'):
with open('/sys/class/net/' + iface + '/statistics/' + t + '_bytes', 'r') as f:
data = f.read();
return int(data)
if __name__ == '__main__':
(tx_prev, rx_prev) = (0, 0)
#Rx stand for received (download) and Tx for tranferred (upload).
while(True):
tx = get_bytes('tx')
rx = get_bytes('rx')
if tx_prev > 0:
tx_speed = tx - tx_prev
if rx_prev > 0:
rx_speed = rx - rx_prev
time.sleep(looptime)
tx_prev = tx
rx_prev = rx
speedrx =rx_speed/looptime
#print('RX: ', rx_speed, 'xxxxx')
speedtx = tx_speed/looptime
if speedtx > speedrx:
speed = speedtx
else:
speed = speedrx
# check current suspend setting
suspend = get(get_suspend).strip()
idletime = float(subprocess.check_output('xprintidle').strip())
idletime=idletime/1000
if speed > speed_limit:
# check/set disable suspend if necessary
if suspend != "0":
subprocess.Popen(["/bin/bash", "-c", set_suspend+" 0"])
if idletime > download_wait-2*looptime:
subprocess.Popen(['notify-send', "Postponed suspend due to active net traffic"])
#subprocess.Popen(['notify-send', str(speed) +"Postponed suspend for completion of active upload/download"+ str(speed_limit)])
t = 0
else:
if all([t > download_wait/looptime, suspend != str(download_wait)]):
# check/enable suspend if necessary
subprocess.Popen(["/bin/bash", "-c", set_suspend+" "+str(suspend_wait)])
t = t+1
#print(idletime)
#print(speed)
#print(speed_limit)
#subprocess.Popen(['notify-send', str(idletime)])
#print('speed:', speed)
#print('speed limit:', speed_limit)