""" 
Author: Justin Cappos

Start Date: July 1st, 2008

Description:
Handles exiting and killing all threads, tracking CPU / Mem usage, etc.


"""


import threading
import os
import time

# needed for sys.stderr and windows Popen hackery
import sys

# needed for signal numbers
import signal

# needed for harshexit
import harshexit

# print useful info when exiting...
import tracebackrepy  

# used to query status, etc.
# This may fail on Windows CE
try:
  import subprocess
  mobile_no_subprocess = False
except ImportError:
  # Set flag to avoid using subprocess
  mobile_no_subprocess = True 


# used for socket.error
import socket

# need for status retrieval
import statusstorage

# Get constants
import repy_constants

# Get access to the status interface so we can start it
import nmstatusinterface

# This gives us our restrictions information
import nanny_resource_limits

# This is used for IPC
import marshal

# This will fail on non-windows systems
try:
  import windows_api as windows_api
except:
  windows_api = None

# Armon: This is a place holder for the module that will be imported later
os_api = None

# Armon: See additional imports at the bottom of the file

class UnsupportedSystemException(Exception):
  pass



###################     Publicly visible functions   #######################

# check the disk space used by a dir.
def compute_disk_use(dirname):
  # Convert path to absolute
  dirname = os.path.abspath(dirname)
  
  diskused = 0
  
  for filename in os.listdir(dirname):
    try:
      diskused = diskused + os.path.getsize(os.path.join(dirname, filename))
    except IOError:   # They likely deleted the file in the meantime...
      pass
    except OSError:   # They likely deleted the file in the meantime...
      pass

    # charge an extra 4K for each file to prevent lots of little files from 
    # using up the disk.   I'm doing this outside of the except clause in
    # the failure to get the size wasn't related to deletion
    diskused = diskused + 4096
        
  return diskused


# prepare a socket so it behaves how we want
def preparesocket(socketobject):
  
  if ostype == 'Windows':
    # we need to set a timeout because on rare occasions Windows will block 
    # on recvmess with a bad socket.  This prevents it from locking the system.
    # We use select, so the timeout should never be actually used.

    # The actual value doesn't seem to matter, so I'll use 100 years
    socketobject.settimeout(60*60*24*365*100)

  elif ostype == 'Linux' or ostype == 'Darwin':
    # Linux seems not to care if we set the timeout, Mac goes nuts and refuses
    # to let you send from a socket you're receiving on (why?)
    pass

  elif ostype == "WindowsCE":
    # No known issues, so just go
    pass
	
  else:
    raise UnsupportedSystemException, "Unsupported system type: '"+osrealtype+"' (alias: "+ostype+")"
  

# Armon: Also launches the nmstatusinterface thread.
# This will result in an internal thread on Windows
# and a thread on the external process for *NIX
def monitor_cpu_disk_and_mem():
  if ostype == 'Linux' or ostype == 'Darwin':  
    # Startup a CPU monitoring thread/process
    do_forked_resource_monitor()
    
  elif ostype == 'Windows' or ostype == 'WindowsCE':
    # Now we set up a cpu nanny...
    # Use an external CPU monitor for WinCE
    if ostype == 'WindowsCE':
      nannypath = "\"" + repy_constants.PATH_SEATTLE_INSTALL + 'win_cpu_nanny.py' + "\""
      cmdline = str(os.getpid())+" "+str(nanny_resource_limits.resource_limit("cpu"))+" "+str(repy_constants.CPU_POLLING_FREQ_WINCE)
      windows_api.launch_python_script(nannypath, cmdline)
    else:
      WinCPUNannyThread().start()
    
    # Launch mem./disk resource nanny
    WindowsNannyThread().start()
    
    # Start the nmstatusinterface. Windows means repy isn't run in an external
    # process, so pass None instead of a process id.
    nmstatusinterface.launch(None)
  else:
    raise UnsupportedSystemException, "Unsupported system type: '"+osrealtype+"' (alias: "+ostype+")"




# Elapsed time
elapsedtime = 0

# Store the uptime of the system when we first get loaded
starttime = 0
last_uptime = 0

# Timestamp from our starting point
last_timestamp = time.time()

# This is our uptime granularity
granularity = 1

# This ensures only one thread calling getruntime at any given time
runtimelock = threading.Lock()

def getruntime():
  """
   <Purpose>
      Return the amount of time the program has been running.   This is in
      wall clock time.   This function is not guaranteed to always return
      increasing values due to NTP, etc.

   <Arguments>
      None

   <Exceptions>
      None.

   <Side Effects>
      None

   <Remarks>
      By default this will have the same granularity as the system clock. However, if time 
      goes backward due to NTP or other issues, getruntime falls back to system uptime.
      This has much lower granularity, and varies by each system.

   <Returns>
      The elapsed time as float
  """
  global starttime, last_uptime, last_timestamp, elapsedtime, granularity, runtimelock
  
  # Get the lock
  runtimelock.acquire()
  
  # Check if Linux or BSD/Mac
  if ostype in ["Linux", "Darwin"]:
    uptime = os_api.get_system_uptime()

    # Check if time is going backward
    if uptime < last_uptime:
      # If the difference is less than 1 second, that is okay, since
      # The boot time is only precise to 1 second
      if (last_uptime - uptime) > 1:
        raise EnvironmentError, "Uptime is going backwards!"
      else:
        # Use the last uptime
        uptime = last_uptime
        
        # No change in uptime
        diff_uptime = 0
    else:  
      # Current uptime, minus the last uptime
      diff_uptime = uptime - last_uptime
      
      # Update last uptime
      last_uptime = uptime

  # Check for windows  
  elif ostype in ["Windows", "WindowsCE"]:   
    # Release the lock
    runtimelock.release()
    
    # Time.clock returns elapsedtime since the first call to it, so this works for us
    return time.clock()
     
  # Who knows...  
  else:
    raise EnvironmentError, "Unsupported Platform!"
  
  # Current uptime minus start time
  runtime = uptime - starttime
  
  # Get runtime from time.time
  current_time = time.time()
  
  # Current time, minus the last time
  diff_time = current_time - last_timestamp
  
  # Update the last_timestamp
  last_timestamp = current_time
  
  # Is time going backward?
  if diff_time < 0.0:
    # Add in the change in uptime
    elapsedtime += diff_uptime
  
  # Lets check if time.time is too skewed
  else:
    skew = abs(elapsedtime + diff_time - runtime)
    
    # If the skew is too great, use uptime instead of time.time()
    if skew < granularity:
      elapsedtime += diff_time
    else:
      elapsedtime += diff_uptime
  
  # Release the lock
  runtimelock.release()
          
  # Return the new elapsedtime
  return elapsedtime
 

# This lock is used to serialize calls to get_resouces
get_resources_lock = threading.Lock()

# These are the resources we expose in get_resources
exposed_resources = set(["cpu","memory","diskused","events",
                     "filewrite","fileread","filesopened",
                     "insockets","outsockets","netsend",
                     "netrecv","loopsend","looprecv",
                     "lograte","random","messport","connport"])
            
# These are the resources that we don't flatten using
# len() for the usage. For example, instead of given the
# set of thread's, we flatten this into N number of threads.
flatten_exempt_resources = set(["connport","messport"])

# Cache the disk used from the external process
cached_disk_used = 0L

# This array holds the times that repy was stopped.
# It is an array of tuples, of the form (time, amount)
# where time is when repy was stopped (from getruntime()) and amount
# is the stop time in seconds. The last process_stopped_max_entries are retained
process_stopped_timeline = []
process_stopped_max_entries = 100

# Method to expose resource limits and usage
def get_resources():
  """
  <Purpose>
    Returns the resouce utilization limits as well
    as the current resource utilization.

  <Arguments>
    None.

  <Returns>
    A tuple of dictionaries and an array (limits, usage, stoptimes).

    Limits is the dictionary which maps the resouce name
    to its maximum limit.

    Usage is the dictionary which maps the resource name
    to its current usage.

    Stoptimes is an array of tuples with the times which the Repy proces
    was stopped and for how long, due to CPU over-use.
    Each entry in the array is a tuple (TOS, Sleep Time) where TOS is the
    time of stop (respective to getruntime()) and Sleep Time is how long the
    repy process was suspended.

    The stop times array holds a fixed number of the last stop times.
    Currently, it holds the last 100 stop times.
  """
  # Acquire the lock
  get_resources_lock.acquire()

  # Construct the dictionaries as copies from nanny
  limits = nanny_resource_limits.resource_restriction_table.copy()
  usage = nanny_resource_limits.resource_consumption_table.copy()

  # These are the type we need to copy or flatten
  check_types = set([list,dict,set])

  # Check the limits dictionary for bad keys
  for resource in limits.keys():
    # Remove any resources we should not expose
    if resource not in exposed_resources:
      del limits[resource]

    # Check the type
    if type(limits[resource]) in check_types:
      # Copy the data structure
      limits[resource] = limits[resource].copy()

  # Check the usage dictionary
  for resource in usage.keys():
    # Remove any resources that are not exposed
    if resource not in exposed_resources:
      del usage[resource]

    # Check the type, copy any data structures
    # Flatten any structures using len() other than
    # "connport" and "messport"
    if type(usage[resource]) in check_types:
      # Check if they are exempt from flattening, store a shallow copy
      if resource in flatten_exempt_resources:
        usage[resource] = usage[resource].copy()

      # Store the size of the data set
      else:
        usage[resource] = len(usage[resource])
    


  # Calculate all the usage's
  pid = os.getpid()

  # Get CPU and memory, this is thread specific
  if ostype in ["Linux", "Darwin"]:
    
    # Get CPU first, then memory
    usage["cpu"] = os_api.get_process_cpu_time(pid)

    # This uses the cached PID data from the CPU check
    usage["memory"] = os_api.get_process_rss()

    # Get the thread specific CPU usage
    usage["threadcpu"] = os_api.get_current_thread_cpu_time() 


  # Windows Specific versions
  elif ostype in ["Windows","WindowsCE"]:
    
    # Get the CPU time
    usage["cpu"] = windows_api.get_process_cpu_time(pid)

    # Get the memory, use the resident set size
    usage["memory"] = windows_api.process_memory_info(pid)['WorkingSetSize'] 

    # Get thread-level CPU 
    usage["threadcpu"] = windows_api.get_current_thread_cpu_time()

  # Unknown OS
  else:
    raise EnvironmentError("Unsupported Platform!")

  # Use the cached disk used amount
  usage["diskused"] = cached_disk_used

  # Release the lock
  get_resources_lock.release()

  # Copy the stop times
  stoptimes = process_stopped_timeline[:]

  # Return the dictionaries and the stoptimes
  return (limits,usage,stoptimes)


###################     Windows specific functions   #######################

class WindowsNannyThread(threading.Thread):

  def __init__(self):
    threading.Thread.__init__(self,name="NannyThread")

  def run(self):
    # Calculate how often disk should be checked
    if ostype == "WindowsCE":
      disk_interval = int(repy_constants.RESOURCE_POLLING_FREQ_WINCE / repy_constants.CPU_POLLING_FREQ_WINCE)
    else:
      disk_interval = int(repy_constants.RESOURCE_POLLING_FREQ_WIN / repy_constants.CPU_POLLING_FREQ_WIN)
    current_interval = 0 # What cycle are we on  
    
    # Elevate our priority, above normal is higher than the usercode, and is enough for disk/mem
    windows_api.set_current_thread_priority(windows_api.THREAD_PRIORITY_ABOVE_NORMAL)
    
    # need my pid to get a process handle...
    mypid = os.getpid()

    # run forever (only exit if an error occurs)
    while True:
      try:
        # Check memory use, get the WorkingSetSize or RSS
        memused = windows_api.process_memory_info(mypid)['WorkingSetSize']
        
        if memused > nanny_resource_limits.resource_limit("memory"):
          # We will be killed by the other thread...
          raise Exception, "Memory use '"+str(memused)+"' over limit '"+str(nanny_resource_limits.resource_limit("memory"))+"'"
        
        # Increment the interval we are on
        current_interval += 1

        # Check if we should check the disk
        if (current_interval % disk_interval) == 0:
          # Check diskused
          diskused = compute_disk_use(repy_constants.REPY_CURRENT_DIR)
          if diskused > nanny_resource_limits.resource_limit("diskused"):
            raise Exception, "Disk use '"+str(diskused)+"' over limit '"+str(nanny_resource_limits.resource_limit("diskused"))+"'"
        
        if ostype == 'WindowsCE':
          time.sleep(repy_constants.CPU_POLLING_FREQ_WINCE)
        else:
          time.sleep(repy_constants.CPU_POLLING_FREQ_WIN)
        
      except windows_api.DeadProcess:
        #  Process may be dead, or die while checking memory use
        #  In any case, there is no reason to continue running, just exit
        harshexit.harshexit(99)

      except:
        tracebackrepy.handle_exception()
        print >> sys.stderr, "Nanny died!   Trying to kill everything else"
        harshexit.harshexit(20)


# Windows specific CPU Nanny Stuff
winlastcpuinfo = [0,0]

# Enfoces CPU limit on Windows and Windows CE
def win_check_cpu_use(cpulim, pid):
  global winlastcpuinfo
  
  # get use information and time...
  now = getruntime()

  # Get the total cpu time
  usertime = windows_api.get_process_cpu_time(pid)

  useinfo = [usertime, now]

  # get the previous time and cpu so we can compute the percentage
  oldusertime = winlastcpuinfo[0]
  oldnow = winlastcpuinfo[1]

  if winlastcpuinfo == [0,0]:
    winlastcpuinfo = useinfo
    # give them a free pass if it's their first time...
    return 0

  # save this data for next time...
  winlastcpuinfo = useinfo

  # Get the elapsed time...
  elapsedtime = now - oldnow

  # This is a problem
  if elapsedtime == 0:
    return -1 # Error condition
    
  # percent used is the amount of change divided by the time...
  percentused = (usertime - oldusertime) / elapsedtime

  # Calculate amount of time to sleep for
  stoptime = nanny_resource_limits.calculate_cpu_sleep_interval(cpulim, percentused,elapsedtime)

  if stoptime > 0.0:
    # Try to timeout the process
    if windows_api.timeout_process(pid, stoptime):
      # Log the stoptime
      process_stopped_timeline.append((now, stoptime))

      # Drop the first element if the length is greater than the maximum entries
      if len(process_stopped_timeline) > process_stopped_max_entries:
        process_stopped_timeline.pop(0)

      # Return how long we slept so parent knows whether it should sleep
      return stoptime
  
    else:
      # Process must have been making system call, try again next time
      return -1
  
  # If the stop time is 0, then avoid calling timeout_process
  else:
    return 0.0
    
            
# Dedicated Thread for monitoring CPU, this is run as a part of repy
class WinCPUNannyThread(threading.Thread):
  # Thread variables
  pid = 0 # Process pid
  
  def __init__(self):
    self.pid = os.getpid()
    threading.Thread.__init__(self,name="CPUNannyThread")    
      
  def run(self):
    # Elevate our priority, set us to the highest so that we can more effectively throttle
    success = windows_api.set_current_thread_priority(windows_api.THREAD_PRIORITY_HIGHEST)
    
    # If we failed to get HIGHEST priority, try above normal, else we're still at default
    if not success:
      windows_api.set_current_thread_priority(windows_api.THREAD_PRIORITY_ABOVE_NORMAL)
    
    # Run while the process is running
    while True:
      try:
        # Get the frequency
        frequency = repy_constants.CPU_POLLING_FREQ_WIN
        
        # Base amount of sleeping on return value of 
    	  # win_check_cpu_use to prevent under/over sleeping
        slept = win_check_cpu_use(nanny_resource_limits.resource_limit("cpu"), self.pid)
        
        if slept == -1:
          # Something went wrong, try again
          pass
        elif (slept < frequency):
          time.sleep(frequency-slept)

      except windows_api.DeadProcess:
        #  Process may be dead
        harshexit.harshexit(97)
        
      except:
        tracebackrepy.handle_exception()
        print >> sys.stderr, "CPU Nanny died!   Trying to kill everything else"
        harshexit.harshexit(25)
              
              





##############     *nix specific functions (may include Mac)  ###############

# This method handles messages on the "diskused" channel from
# the external process. When the external process measures disk used,
# it is piped in and cached for calls to getresources.
def IPC_handle_diskused(bytes):
  cached_disk_used = bytes


# This method handles meessages on the "repystopped" channel from
# the external process. When the external process stops repy, it sends
# a tuple with (TOS, amount) where TOS is time of stop (getruntime()) and
# amount is the amount of time execution was suspended.
def IPC_handle_stoptime(info):
  # Push this onto the timeline
  process_stopped_timeline.append(info)

  # Drop the first element if the length is greater than the max
  if len(process_stopped_timeline) > process_stopped_max_entries:
    process_stopped_timeline.pop(0)


# Use a special class of exception for when
# resource limits are exceeded
class ResourceException(Exception):
  pass


# Armon: Method to write a message to the pipe, used for IPC.
# This allows the pipe to be multiplexed by sending simple dictionaries
def write_message_to_pipe(writehandle, channel, data):
  """
  <Purpose>
    Writes a message to the pipe

  <Arguments>
    writehandle:
        A handle to a pipe which can be written to.

    channel:
        The channel used to describe the data. Used for multiplexing.

    data:
        The data to send.

  <Exceptions>
    As with os.write()
    EnvironmentError will be thrown if os.write() sends 0 bytes, indicating the
    pipe is broken.
  """
  # Construct the dictionary
  mesg_dict = {"ch":channel,"d":data}

  # Convert to a string
  mesg_dict_str = marshal.dumps(mesg_dict)

  # Make a full string
  mesg = str(len(mesg_dict_str)) + ":" + mesg_dict_str

  # Send this
  index = 0
  while index < len(mesg):
    bytes = os.write(writehandle, mesg[index:])
    if bytes == 0:
      raise EnvironmentError, "Write send 0 bytes! Pipe broken!"
    index += bytes


# Armon: Method to read a message from the pipe, used for IPC.
# This allows the pipe to be multiplexed by sending simple dictionaries
def read_message_from_pipe(readhandle):
  """
  <Purpose>
    Reads a message from a pipe.

  <Arguments>
    readhandle:
        A handle to a pipe which can be read from

  <Exceptions>
    As with os.read().
    EnvironmentError will be thrown if os.read() returns a 0-length string, indicating
    the pipe is broken.

  <Returns>
    A tuple (Channel, Data) where Channel is used to multiplex the pipe.
  """
  # Read until we get to a colon
  data = ""
  index = 0

  # Loop until we get a message
  while True:

    # Read in data if the buffer is empty
    if index >= len(data):
      # Read 8 bytes at a time
      mesg = os.read(readhandle,8)
      if len(mesg) == 0:
        raise EnvironmentError, "Read returned emtpy string! Pipe broken!"
      data += mesg

    # Increment the index while there is data and we have not found a colon
    while index < len(data) and data[index] != ":":
      index += 1

    # Check if we've found a colon
    if len(data) > index and data[index] == ":":
      # Get the message length
      mesg_length = int(data[:index])

      # Determine how much more data we need
      more_data = mesg_length - len(data) + index + 1

      # Read in the rest of the message
      while more_data > 0:
        mesg = os.read(readhandle, more_data)
        if len(mesg) == 0:
          raise EnvironmentError, "Read returned emtpy string! Pipe broken!"
        data += mesg
        more_data -= len(mesg)

      # Done, convert the message to a dict
      whole_mesg = data[index+1:]
      mesg_dict = marshal.loads(whole_mesg)

      # Return a tuple (Channel, Data)
      return (mesg_dict["ch"],mesg_dict["d"])



# This dictionary defines the functions that handle messages
# on each channel. E.g. when a message arrives on the "repystopped" channel,
# the IPC_handle_stoptime function should be invoked to handle it.
IPC_HANDLER_FUNCTIONS = {"repystopped":IPC_handle_stoptime,
                         "diskused":IPC_handle_diskused }


# This thread checks that the parent process is alive and invokes
# delegate methods when messages arrive on the pipe.
class parent_process_checker(threading.Thread):
  def __init__(self, readhandle):
    """
    <Purpose>
      Terminates harshly if our parent dies before we do.

    <Arguments>
      readhandle: A file descriptor to the handle of a pipe to our parent.
    """
    # Name our self
    threading.Thread.__init__(self, name="ParentProcessChecker")

    # Store the handle
    self.readhandle = readhandle

  def run(self):
    # Run forever
    while True:
      # Read a message
      try:
        mesg = read_message_from_pipe(self.readhandle)
      except Exception, e:
        break

      # Check for a handler function
      if mesg[0] in IPC_HANDLER_FUNCTIONS:
        # Invoke the handler function with the data
        handler = IPC_HANDLER_FUNCTIONS[mesg[0]]
        handler(mesg[1])

      # Print a message if there is a message on an unknown channel
      else:
        print "[WARN] Message on unknown channel from parent process:", mesg[0]


    ### We only leave the loop on a fatal error, so we need to exit now

    # Write out status information, our parent would do this, but its dead.
    statusstorage.write_status("Terminated")  
    print >> sys.stderr, "Monitor process died! Terminating!"
    harshexit.harshexit(70)



# For *NIX systems, there is an external process, and the 
# pid for the actual repy process is stored here
repy_process_id = None

# Forks Repy. The child will continue execution, and the parent
# will become a resource monitor
def do_forked_resource_monitor():
  global repy_process_id

  # Get a pipe
  (readhandle, writehandle) = os.pipe()

  # I'll fork a copy of myself
  childpid = os.fork()

  if childpid == 0:
    # We are the child, close the write end of the pipe
    os.close(writehandle)

    # Start a thread to check on the survival of the parent
    parent_process_checker(readhandle).start()

    return
  else:
    # We are the parent, close the read end
    os.close(readhandle)

  # Store the childpid
  repy_process_id = childpid

  # Start the nmstatusinterface
  nmstatusinterface.launch(repy_process_id)
  
  # Small internal error handler function
  def _internal_error(message):
    try:
      print >> sys.stderr, message
      sys.stderr.flush()
    except:
      pass
      
    # Stop the nmstatusinterface, we don't want any more status updates
    nmstatusinterface.stop()  

    # Kill repy
    harshexit.portablekill(childpid)

    try:
      # Write out status information, repy was Stopped
      statusstorage.write_status("Terminated")  
    except:
      pass
  
  try:
    # Some OS's require that you wait on the pid at least once
    # before they do any accounting
    (pid, status) = os.waitpid(childpid,os.WNOHANG)
    
    # Launch the resource monitor, if it fails determine why and restart if necessary
    resource_monitor(childpid, writehandle)
    
  except ResourceException, exp:
    # Repy exceeded its resource limit, kill it
    _internal_error(str(exp)+" Impolitely killing child!")
    harshexit.harshexit(98)
    
  except Exception, exp:
    # There is some general error...
    try:
      (pid, status) = os.waitpid(childpid,os.WNOHANG)
    except:
      # This means that the process is dead
      pass
    
    # Check if this is repy exiting
    if os.WIFEXITED(status) or os.WIFSIGNALED(status):
      sys.exit(0)
    
    else:
      _internal_error(str(exp)+" Monitor death! Impolitely killing child!")
      raise
  
def resource_monitor(childpid, pipe_handle):
  """
  <Purpose>
    Function runs in a loop forever, checking resource usage and throttling CPU.
    Checks CPU, memory, and disk.
    
  <Arguments>
    childpid:
      The child pid, e.g. the pid of repy

    pipe_handle:
      A handle to the pipe to the repy process. Allows sending resource use information.
  """
  # Get our pid
  ourpid = os.getpid()
  
  # Calculate how often disk should be checked
  disk_interval = int(repy_constants.RESOURCE_POLLING_FREQ_LINUX / repy_constants.CPU_POLLING_FREQ_LINUX)
  current_interval = -1 # What cycle are we on  
  
  # Store time of the last interval
  last_time = getruntime()
  last_CPU_time = 0
  resume_time = 0 
  
  # Run forever...
  while True:
    ########### Check CPU ###########
    # Get elasped time
    currenttime = getruntime()
    elapsedtime1 = currenttime - last_time     # Calculate against last run
    elapsedtime2 = currenttime - resume_time   # Calculate since we last resumed repy
    elapsedtime = min(elapsedtime1, elapsedtime2) # Take the minimum interval
    last_time = currenttime  # Save the current time
    
    # Safety check, prevent ZeroDivisionError
    if elapsedtime == 0.0:
      continue
    
    # Get the total cpu at this point
    totalCPU =  os_api.get_process_cpu_time(ourpid)   # Our own usage
    totalCPU += os_api.get_process_cpu_time(childpid) # Repy's usage
    
    # Calculate percentage of CPU used
    percentused = (totalCPU - last_CPU_time) / elapsedtime
    
    # Do not throttle for the first interval, wrap around
    # Store the totalCPU for the next cycle
    if last_CPU_time == 0:
      last_CPU_time = totalCPU    
      continue
    else:
      last_CPU_time = totalCPU
      
    # Calculate stop time
    stoptime = nanny_resource_limits.calculate_cpu_sleep_interval(nanny_resource_limits.resource_limit("cpu"), percentused, elapsedtime)
    
    # If we are supposed to stop repy, then suspend, sleep and resume
    if stoptime > 0.0:
      # They must be punished by stopping
      os.kill(childpid, signal.SIGSTOP)

      # Sleep until time to resume
      time.sleep(stoptime)

      # And now they can start back up!
      os.kill(childpid, signal.SIGCONT)
      
      # Save the resume time
      resume_time = getruntime()

      # Send this information as a tuple containing the time repy was stopped and
      # for how long it was stopped
      write_message_to_pipe(pipe_handle, "repystopped", (currenttime, stoptime))
      
    
    ########### End Check CPU ###########
    # 
    ########### Check Memory ###########
    
    # Get how much memory repy is using
    memused = os_api.get_process_rss()
    
    # Check if it is using too much memory
    if memused > nanny_resource_limits.resource_limit("memory"):
      raise ResourceException, "Memory use '"+str(memused)+"' over limit '"+str(nanny_resource_limits.resource_limit("memory"))+"'."
    
    ########### End Check Memory ###########
    # 
    ########### Check Disk Usage ###########
    # Increment our current cycle
    current_interval += 1;
    
    # Check if it is time to check the disk usage
    if (current_interval % disk_interval) == 0:
      # Reset the interval
      current_interval = 0
       
      # Calculate disk used
      diskused = compute_disk_use(repy_constants.REPY_CURRENT_DIR)

      # Raise exception if we are over limit
      if diskused > nanny_resource_limits.resource_limit("diskused"):
        raise ResourceException, "Disk use '"+str(diskused)+"' over limit '"+str(nanny_resource_limits.resource_limit("diskused"))+"'."

      # Send the disk usage information, raw bytes used
      write_message_to_pipe(pipe_handle, "diskused", diskused)
    
    ########### End Check Disk ###########
    
    # Sleep before the next iteration
    time.sleep(repy_constants.CPU_POLLING_FREQ_LINUX)


###########     functions that help me figure out the os type    ###########

# Calculates the system granularity
def calculate_granularity():
  global granularity

  if ostype in ["Windows", "WindowsCE"]:
    # The Granularity of getTickCount is 1 millisecond
    granularity = pow(10,-3)
    
  elif ostype == "Linux":
    # We don't know if the granularity is correct yet
    correct_granularity = False
    
    # How many times have we tested
    tests = 0
    
    # Loop while the granularity is incorrect, up to 10 times
    while not correct_granularity and tests <= 10:
      current_granularity = os_api.get_uptime_granularity()
      uptime_pre = os_api.get_system_uptime()
      time.sleep(current_granularity / 10)
      uptime_post = os_api.get_system_uptime()
    
      diff = uptime_post - uptime_pre
    
      correct_granularity = int(diff / current_granularity) == (diff / current_granularity)
      tests += 1
    
    granularity = current_granularity
    
  elif ostype == "Darwin":
    granularity = os_api.get_uptime_granularity()
    


# Call init_ostype!!!
harshexit.init_ostype()

ostype = harshexit.ostype
osrealtype = harshexit.osrealtype

# Import the proper system wide API
if osrealtype == "Linux":
  import linux_api as os_api
elif osrealtype == "Darwin":
  import darwin_api as os_api
elif osrealtype == "FreeBSD":
  import freebsd_api as os_api
elif ostype == "Windows" or ostype == "WindowsCE":
  # There is no real reason to do this, since windows is imported separately
  import windows_api as os_api
else:
  # This is a non-supported OS
  raise UnsupportedSystemException, "The current Operating System is not supported! Fatal Error."
  
# Set granularity
calculate_granularity()  

# For Windows, we need to initialize time.clock()
if ostype in ["Windows", "WindowsCE"]:
  time.clock()

# Initialize getruntime for other platforms 
else:
  # Set the starttime to the initial uptime
  starttime = getruntime()
  last_uptime = starttime

  # Reset elapsed time 
  elapsedtime = 0


# Conrad: initialize nanny (Prevents circular imports)
# Note: nanny_resource_limits can be initialized at any time after getruntime()
# is defined, this just seems the most appropriate place to put the call.
nanny_resource_limits.init(getruntime)
