root/trunk/justrecord.py

#!/usr/bin/env python

#
# justrecord.py
#
# GPL - Alban Peignier - 2007

import alsaaudio
import sys
import signal, os
import time
import wave
import optparse
from optparse import OptionParser
import pwd, grp
import syslog
import subprocess
import ConfigParser

class Recorder:

  def __init__(self, config):
    self.channels = config.int('channels')
    self.rate = config.int('rate')
    self.basename = config['basename']
    self.time_limit = config.int('time_limit')
    self.basedir = config['basedir']
    self.after_script = config['after_script']

    self.output_file_index = 0
    self.output_stopped_until = None

  def init_alsa(self):
    self.inp = alsaaudio.PCM(alsaaudio.PCM_CAPTURE,alsaaudio.PCM_NONBLOCK)

    self.inp.setchannels(self.channels)
    self.inp.setrate(self.rate)
    self.inp.setformat(alsaaudio.PCM_FORMAT_S16_LE)

    self.inp.setperiodsize(160)

  def init_signals(self):
    def handler_stop(signum, frame):
      log('signal : exit')
      self.recording = False

    # Set the signal handler and a 5-second alarm
    signal.signal(signal.SIGTERM, handler_stop)
    signal.signal(signal.SIGINT, handler_stop)

    def handler_nextfile(signum, frame):
      log('signal : new file')
      self.open_next_file()

    signal.signal(signal.SIGUSR1, handler_nextfile)

  def close_current_file(self):
    if self.output_file is not None:
      self.output_file.close()
      if self.after_script is not None:
        log("execute %s %s" % (self.after_script, self.output_file_name))
        try:
          subprocess.Popen([self.after_script, self.output_file_name])
        except OSError, e:
          log("error: after script failed: %d (%s)" % (e.errno, e.strerror))

    self.output_file = None
    self.output_file_name = None

  def open_next_file(self):
    if self.output_stopped_until is not None:
      if self.output_stopped_until > time.time():
        # silently return
        return
      else:
        # end of this alarm
        self.output_stopped_until = None

    if self.output_file is not None:
      self.close_current_file()

    output_file_name = os.path.join(self.basedir , self.next_file_name())

    try:
      self.output_file = wave.open(output_file_name, 'wb')
      log('new file : %s' % output_file_name)

      self.output_file.setnchannels(self.channels)
      self.output_file.setframerate(self.rate)
      self.output_file.setsampwidth(2)

      self.output_file_index += 1
      self.output_file_name = output_file_name
    except IOError, e:
      log("error: can't open new file: %s - %d (%s) - retry in 60s" % (output_file_name, e.errno, e.strerror))
      self.output_stopped_until = time.time() + 60

  def next_file_name(self):
    info = {
      'time': time.strftime('%Y-%m-%d-%H-%M-%S'),
      'index' : self.output_file_index,
      'base' : self.basename
    }
    return '%(base)s-%(index)03d-%(time)s.wav' % info

  def run(self):
    log("start (output: %s, time: %d, channels: %d, rate: %d)" % (self.basename, self.time_limit, self.channels, self.rate ))

    self.init_alsa()
    self.init_signals()

    position_limit = self.time_limit * self.rate
    self.output_file = None
    self.recording = True

    while self.recording:
      l,data = self.inp.read()

      if l:
        if self.output_file is None:
          self.open_next_file()

        # if output_file is still None, we're in IO error
        if self.output_file is not None:
          self.output_file.writeframesraw(data)

          output_position = self.output_file.tell()
          if output_position > position_limit:
            self.open_next_file()

      time.sleep(.001)

    self.close_current_file()
    log('exit')

class Log:
  """file like for writes with auto flush after each write
  to ensure that everything is logged, even during an
  unexpected exit."""
  def __init__(self, f):
    self.f = f
  def write(self, s):
    self.f.write(s)
    self.f.flush()

class Daemon:

  def __init__(self, config, main):
    self.uid = config['uid']
    self.gid = config['gid']
    self.pidfile = config['pidfile']
    self.basedir = config['basedir']
    self.logfile = config['logfile']
    self.main = main

    if isinstance(self.uid, basestring):
      if self.uid.isdigit():
        self.uid = int(self.uid)
      else:
                                self.uid = pwd.getpwnam(self.uid).pw_uid

    if isinstance(self.gid, basestring):
      if self.gid.isdigit():
        self.gid = int(self.gid)
      else:
        self.gid = grp.getgrnam(self.gid).gr_gid

    if self.logfile is None:
      self.logfile = "/dev/null"

  def start(self):
    log('start daemon')
    # do the UNIX double-fork magic, see Stevens' "Advanced
    # Programming in the UNIX Environment" for details (ISBN 0201563177)
    try:
      pid = os.fork()
      if pid > 0:
          # exit first parent
          sys.exit(0)
    except OSError, e:
      log("fork failed: %d (%s)" % (e.errno, e.strerror))
      sys.exit(1)

    # decouple from parent environment
    os.chdir("/")   #don't prevent unmounting....
    os.setsid()
    os.umask(0)

    # do second fork
    try:
        pid = os.fork()
        if pid > 0:
            # exit from second parent
            if self.pidfile is not None:
              open(self.pidfile,'w').write("%d\n"%pid)
            sys.exit(0)
    except OSError, e:
        log("fork 2 failed: %d (%s)" % (e.errno, e.strerror))
        sys.exit(1)

    # start the daemon main loop
    os.chdir(self.basedir)

    #redirect input to /dev/null
    sys.stdin = open("/dev/null", 'r')
    #redirect outputs to a logfile
    sys.stdout = sys.stderr = Log(open(self.logfile, 'a+'))
    #ensure the that the daemon runs a normal user
    os.setegid(self.gid)
    os.seteuid(self.uid)

    #start the user program here:
    self.main()

class Logger:

  def __init__(self, console, syslogEnabled, logfile):
    self.console = console
    self.syslog = syslogEnabled
    self.logfile = None

    if self.syslog:
      syslog.openlog("justrecord", syslog.LOG_PID, syslog.LOG_USER)
    if logfile is not None:
      self.logfile = open(logfile, 'a+')

  def log(self, message):
    timed_message = "%s %s" % (time.strftime('%b %d %T'), message)

    if self.logfile is not None:
      self.logfile.write("%s\n" % timed_message)
    if self.logfile is None or self.console:
      print timed_message
    if self.syslog:
      syslog.syslog(message)

  def close(self):
    if self.logfile is not None:
      self.logfile.close()
    if self.syslog:
      syslog.closelog()

class Config:

  def __init__(self, default_options):
    self.options = {}
    self.update(default_options)

  def update(self, options):
    if isinstance(options, optparse.Values):
      for entry in options.__dict__.iteritems():
        if entry[1] is not None:
          self.options[entry[0]] = entry[1]
    else:
      self.options.update(options)

    return self

  def load_ini(self, inifile):
    config_parser = ConfigParser.ConfigParser()
    if config_parser.read([inifile]) is []:
      return False

    ini_options = {}
    for config_section in config_parser.sections():
      for config_entry in config_parser.items(config_section):
        ini_options[config_entry[0]] = config_entry[1]
    self.update(ini_options)
    return True

  def __getitem__(self, key):
    return self.options[key]

  def string(self, key):
    return self.options[key]

  def int(self, key):
    return int(self.options[key])

  def bool(self, key):
    value = self.options[key]
    if isinstance(value, basestring):
      return value.lower() in [ 'true', 'on', '1' ]
    return value is True

if __name__ == "__main__":

  config = Config({
    'basename': 'record',
    'channels': 2,
    'after_script': None,
    'rate': 44100,
    'time_limit': 30 * 60,
    'basedir': os.getcwd(),
    'daemon': False,
    'console': False,
    'syslog': False,
    'uid': os.getuid(),
    'gid': os.getgid(),
    'pidfile': None,
    'logfile': None
  })

  parser = OptionParser()
  parser.add_option("-o", "--output", dest="basename",
                    help="The output basename. The default is 'record'.")
  parser.add_option("-c", "--config", dest="config", default=None,
                    help="The configuration file.")
  parser.add_option("-n", "--channels", dest="channels", type="int",
                    help="The number of channels. The default is %d channels." % config['channels'])
  parser.add_option("-r", "--rate", dest="rate",
                    choices=["48000", "44100", "22000"],
                    help="The sampling rate in Hertz. The default rate is %d Hertz" % config['rate'])
  parser.add_option("-t", "--time", dest="time_limit", type="int",
                    help="The time length of recording file in seconds. The default time length is 1800 seconds (30 minutes).")
  parser.add_option("-b", "--base-dir", dest="basedir",
                    help="The directory where the recording files are created. The default directory is the current one.")
  parser.add_option("-d", "--daemon", action="store_true", dest="daemon",
                    help="Starts as daemon. Disabled by default")
  parser.add_option("-C", "--console", action="store_true", dest="console",
                    help="Logs messages to the console even if a logfile is specified.")
  parser.add_option("-s", "--syslog", action="store_true", dest="syslog",
                    help="Logs messages to syslog.")
  parser.add_option("-u", "--uid", dest="uid",
                    help="Change to this username/uid before starting the recorder in daemon mode. The default is the current user.")
  parser.add_option("-g", "--gid", dest="gid",
                    help="Change to this group/gid before starting the recorder in daemon mode. The default is the current group.")
  parser.add_option("-p", "--pidfile", dest="pidfile",
                    help="The file used to store the pid in daemon mode.")
  parser.add_option("-l", "--logfile", dest="logfile",
                    help="The file used to log messages.")
  parser.add_option("-A", "--after-script", dest="after_script",
                    help="Specifies a script to be executed each time a recording file is finished.")
  (commandline_options, args) = parser.parse_args()

  if commandline_options.config is not None:
    if not config.load_ini(commandline_options.config):
      log("error: can't read config file: %s" % commandline_options.config)
      sys.exit(1)

  config.update(commandline_options)

  logger = Logger(config.bool('console'), config.bool('syslog'), config['logfile'])
  recorder = Recorder(config)

  def log(message):
    logger.log(message)

  log("config: %s" % config.options)

  def main():
    recorder.run()
    logger.close()

  daemon = config.bool('daemon')
  if daemon:
    Daemon(config, main).start()
  else:
    main()