290 lines
10 KiB
Python
Executable File
290 lines
10 KiB
Python
Executable File
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
#
|
|
# Copyright 2010 Google Inc. All Rights Reserved.
|
|
# Portions copyright PSF License
|
|
# http://code.activestate.com/recipes/278731-creating-a-daemon-the-python-way/
|
|
|
|
"""A pm-action hook for setting timezone.
|
|
|
|
Uses the Google Latitude API and the geonames.org
|
|
API to find your cellphones latitude and longitude
|
|
and from the determine the timezone you are in,
|
|
and then sets the computer's timezone to that.
|
|
"""
|
|
|
|
__author__ = 'jcgregorio@google.com (Joe Gregorio)'
|
|
|
|
|
|
from apiclient.discovery import build
|
|
|
|
import httplib2
|
|
import os
|
|
import pickle
|
|
import pprint
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
import uritemplate
|
|
|
|
from apiclient.anyjson import simplejson
|
|
from apiclient.discovery import build
|
|
from apiclient.oauth import FlowThreeLegged
|
|
from apiclient.ext.authtools import run
|
|
from apiclient.ext.file import Storage
|
|
|
|
# Uncomment to get detailed logging
|
|
# httplib2.debuglevel = 4
|
|
|
|
# URI Template to convert latitude and longitude into a timezone
|
|
GEONAMES = 'http://api.geonames.org/timezoneJSON?lat={lat}&lng={long}&username=jcgregorio'
|
|
PID_FILE = '/var/lock/tznever.pid'
|
|
CACHE = '/var/local/tznever/.cache'
|
|
|
|
# Default daemon parameters.
|
|
# File mode creation mask of the daemon.
|
|
UMASK = 0
|
|
|
|
# Default working directory for the daemon.
|
|
WORKDIR = "/"
|
|
|
|
# Default maximum for the number of available file descriptors.
|
|
MAXFD = 1024
|
|
|
|
# The standard I/O file descriptors are redirected to /dev/null by default.
|
|
if (hasattr(os, "devnull")):
|
|
REDIRECT_TO = os.devnull
|
|
else:
|
|
REDIRECT_TO = "/dev/null"
|
|
|
|
|
|
def main():
|
|
storage = Storage('/var/local/tznever/latitude_credentials.dat')
|
|
credentials = storage.get()
|
|
if len(sys.argv) == 1:
|
|
if credentials is None or credentials.invalid == True:
|
|
auth_discovery = build('latitude', 'v1').auth_discovery()
|
|
flow = FlowThreeLegged(auth_discovery,
|
|
consumer_key='m-buzz.appspot.com',
|
|
consumer_secret='NQEHb4eU6GkjjFGe1MD5W6IC',
|
|
user_agent='tz-never/1.0',
|
|
domain='m-buzz.appspot.com',
|
|
scope='https://www.googleapis.com/auth/latitude',
|
|
xoauth_displayname='TZ Never Again',
|
|
location='current',
|
|
granularity='city'
|
|
)
|
|
|
|
credentials = run(flow, storage)
|
|
else:
|
|
print "You are already authorized"
|
|
else:
|
|
if credentials is None or credentials.invalid == True:
|
|
print "This app, tznever, is not authorized. Run from the command-line to re-authorize."
|
|
os.exit(1)
|
|
|
|
if len(sys.argv) > 1 and sys.argv[1] in ['hibernate', 'suspend']:
|
|
print "Hibernating"
|
|
# Kill off the possibly still running process by its pid
|
|
if os.path.isfile(PID_FILE):
|
|
f = file(PID_FILE, 'r')
|
|
pid = f.read()
|
|
f.close()
|
|
cmdline = ['/bin/kill', '-2', pid]
|
|
subprocess.Popen(cmdline)
|
|
os.unlink(PID_FILE)
|
|
elif len(sys.argv) > 1 and sys.argv[1] in ['thaw', 'resume']:
|
|
print "Resuming"
|
|
# write our pid out
|
|
f = file(PID_FILE, 'w')
|
|
f.write(str(os.getpid()))
|
|
f.close()
|
|
|
|
success = False
|
|
first_time = True
|
|
while not success:
|
|
try:
|
|
if not first_time:
|
|
time.sleep(5)
|
|
else:
|
|
first_time = False
|
|
print "Daemonizing so as not to gum up the works."
|
|
createDaemon()
|
|
# rewrite the PID file with our new PID
|
|
f = file(PID_FILE, 'w')
|
|
f.write(str(os.getpid()))
|
|
f.close()
|
|
http = httplib2.Http(CACHE)
|
|
http = credentials.authorize(http)
|
|
|
|
service = build('latitude', 'v1', http=http)
|
|
|
|
location = service.currentLocation().get(granularity='city').execute()
|
|
position = {
|
|
'lat': str(location['latitude']),
|
|
'long': str(location['longitude'])
|
|
}
|
|
http2 = httplib2.Http(CACHE)
|
|
resp, content = http2.request(uritemplate.expand(GEONAMES, position))
|
|
geodata = simplejson.loads(content)
|
|
tz = geodata['timezoneId']
|
|
f = file('/etc/timezone', 'w')
|
|
f.write(tz)
|
|
f.close()
|
|
cmdline = 'dpkg-reconfigure -f noninteractive tzdata'.split(' ')
|
|
subprocess.Popen(cmdline)
|
|
success = True
|
|
except httplib2.ServerNotFoundError, e:
|
|
print "still not connected, sleeping"
|
|
except KeyboardInterrupt, e:
|
|
if os.path.isfile(PID_FILE):
|
|
os.unlink(PID_FILE)
|
|
success = True
|
|
# clean up pid file
|
|
if os.path.isfile(PID_FILE):
|
|
os.unlink(PID_FILE)
|
|
|
|
|
|
def createDaemon():
|
|
"""Detach a process from the controlling terminal and run it in the
|
|
background as a daemon.
|
|
"""
|
|
|
|
try:
|
|
# Fork a child process so the parent can exit. This returns control to
|
|
# the command-line or shell. It also guarantees that the child will not
|
|
# be a process group leader, since the child receives a new process ID
|
|
# and inherits the parent's process group ID. This step is required
|
|
# to insure that the next call to os.setsid is successful.
|
|
pid = os.fork()
|
|
except OSError, e:
|
|
raise Exception, "%s [%d]" % (e.strerror, e.errno)
|
|
|
|
if (pid == 0): # The first child.
|
|
# To become the session leader of this new session and the process group
|
|
# leader of the new process group, we call os.setsid(). The process is
|
|
# also guaranteed not to have a controlling terminal.
|
|
os.setsid()
|
|
|
|
# Is ignoring SIGHUP necessary?
|
|
#
|
|
# It's often suggested that the SIGHUP signal should be ignored before
|
|
# the second fork to avoid premature termination of the process. The
|
|
# reason is that when the first child terminates, all processes, e.g.
|
|
# the second child, in the orphaned group will be sent a SIGHUP.
|
|
#
|
|
# "However, as part of the session management system, there are exactly
|
|
# two cases where SIGHUP is sent on the death of a process:
|
|
#
|
|
# 1) When the process that dies is the session leader of a session that
|
|
# is attached to a terminal device, SIGHUP is sent to all processes
|
|
# in the foreground process group of that terminal device.
|
|
# 2) When the death of a process causes a process group to become
|
|
# orphaned, and one or more processes in the orphaned group are
|
|
# stopped, then SIGHUP and SIGCONT are sent to all members of the
|
|
# orphaned group." [2]
|
|
#
|
|
# The first case can be ignored since the child is guaranteed not to have
|
|
# a controlling terminal. The second case isn't so easy to dismiss.
|
|
# The process group is orphaned when the first child terminates and
|
|
# POSIX.1 requires that every STOPPED process in an orphaned process
|
|
# group be sent a SIGHUP signal followed by a SIGCONT signal. Since the
|
|
# second child is not STOPPED though, we can safely forego ignoring the
|
|
# SIGHUP signal. In any case, there are no ill-effects if it is ignored.
|
|
#
|
|
# import signal # Set handlers for asynchronous events.
|
|
# signal.signal(signal.SIGHUP, signal.SIG_IGN)
|
|
|
|
try:
|
|
# Fork a second child and exit immediately to prevent zombies. This
|
|
# causes the second child process to be orphaned, making the init
|
|
# process responsible for its cleanup. And, since the first child is
|
|
# a session leader without a controlling terminal, it's possible for
|
|
# it to acquire one by opening a terminal in the future (System V-
|
|
# based systems). This second fork guarantees that the child is no
|
|
# longer a session leader, preventing the daemon from ever acquiring
|
|
# a controlling terminal.
|
|
pid = os.fork() # Fork a second child.
|
|
except OSError, e:
|
|
raise Exception, "%s [%d]" % (e.strerror, e.errno)
|
|
|
|
if (pid == 0): # The second child.
|
|
# Since the current working directory may be a mounted filesystem, we
|
|
# avoid the issue of not being able to unmount the filesystem at
|
|
# shutdown time by changing it to the root directory.
|
|
os.chdir(WORKDIR)
|
|
# We probably don't want the file mode creation mask inherited from
|
|
# the parent, so we give the child complete control over permissions.
|
|
os.umask(UMASK)
|
|
else:
|
|
# exit() or _exit()? See below.
|
|
os._exit(0) # Exit parent (the first child) of the second child.
|
|
else:
|
|
# exit() or _exit()?
|
|
# _exit is like exit(), but it doesn't call any functions registered
|
|
# with atexit (and on_exit) or any registered signal handlers. It also
|
|
# closes any open file descriptors. Using exit() may cause all stdio
|
|
# streams to be flushed twice and any temporary files may be unexpectedly
|
|
# removed. It's therefore recommended that child branches of a fork()
|
|
# and the parent branch(es) of a daemon use _exit().
|
|
os._exit(0) # Exit parent of the first child.
|
|
|
|
# Close all open file descriptors. This prevents the child from keeping
|
|
# open any file descriptors inherited from the parent. There is a variety
|
|
# of methods to accomplish this task. Three are listed below.
|
|
#
|
|
# Try the system configuration variable, SC_OPEN_MAX, to obtain the maximum
|
|
# number of open file descriptors to close. If it doesn't exists, use
|
|
# the default value (configurable).
|
|
#
|
|
# try:
|
|
# maxfd = os.sysconf("SC_OPEN_MAX")
|
|
# except (AttributeError, ValueError):
|
|
# maxfd = MAXFD
|
|
#
|
|
# OR
|
|
#
|
|
# if (os.sysconf_names.has_key("SC_OPEN_MAX")):
|
|
# maxfd = os.sysconf("SC_OPEN_MAX")
|
|
# else:
|
|
# maxfd = MAXFD
|
|
#
|
|
# OR
|
|
#
|
|
# Use the getrlimit method to retrieve the maximum file descriptor number
|
|
# that can be opened by this process. If there is not limit on the
|
|
# resource, use the default value.
|
|
#
|
|
import resource # Resource usage information.
|
|
maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1]
|
|
if (maxfd == resource.RLIM_INFINITY):
|
|
maxfd = MAXFD
|
|
|
|
# Iterate through and close all file descriptors.
|
|
for fd in range(0, maxfd):
|
|
try:
|
|
os.close(fd)
|
|
except OSError: # ERROR, fd wasn't open to begin with (ignored)
|
|
pass
|
|
|
|
# Redirect the standard I/O file descriptors to the specified file. Since
|
|
# the daemon has no controlling terminal, most daemons redirect stdin,
|
|
# stdout, and stderr to /dev/null. This is done to prevent side-effects
|
|
# from reads and writes to the standard I/O file descriptors.
|
|
|
|
# This call to open is guaranteed to return the lowest file descriptor,
|
|
# which will be 0 (stdin), since it was closed above.
|
|
os.open(REDIRECT_TO, os.O_RDWR) # standard input (0)
|
|
|
|
# Duplicate standard input to standard output and standard error.
|
|
os.dup2(0, 1) # standard output (1)
|
|
os.dup2(0, 2) # standard error (2)
|
|
|
|
return(0)
|
|
|
|
if __name__ == '__main__':
|
|
main()
|
|
|
|
|
|
|