Esempio n. 1
0
def execute_namespace_until_completion(thisnamespace, thiscontext):

    # I'll use this to detect when the program is idle so I know when to quit...
    idlethreadcount = threading.activeCount()

    # add my thread to the set of threads that are used...
    event_id = idhelper.getuniqueid()
    try:
        nanny.tattle_add_item('events', event_id)
    except Exception as e:
        tracebackrepy.handle_internalerror("Failed to acquire event for '" + \
                  "initialize' event.\n(Exception was: %s)" % e.message, 140)

    try:
        thisnamespace.evaluate(thiscontext)
    except SystemExit:
        raise
    except:
        # I think it makes sense to exit if their code throws an exception...
        tracebackrepy.handle_exception()
        harshexit.harshexit(6)
    finally:
        nanny.tattle_remove_item('events', event_id)

    # I've changed to the threading library, so this should increase if there are
    # pending events
    while threading.activeCount() > idlethreadcount:
        # do accounting here?
        time.sleep(0.25)

    # Once there are no more events, return...
    return
Esempio n. 2
0
def assertisallowed(call, *args):
    if disablerestrictions:
        return True

    # let's pre-reject certain open / file calls
    #print call_rule_table[call]
    matches = find_action(call_rule_table[call], args)
    action, matched_rule, reasoning = matches[0]
    if action == 'allow':
        return True
    elif action == 'deny':
        matches.reverse()
        estr = "Call '" + str(call) + "' with args " + str(
            args) + " not allowed\n"
        estr += "Matching dump:\n"
        for action, matched_rule, reasoning in matches:
            if matched_rule != '':
                estr += "rule: " + str(matched_rule) + ", "
            estr += str(reasoning) + "\n"
        raise Exception, estr
    elif action == 'prompt':
        # would do an upcall here...
        raise Exception, "Call '" + str(call) + "' not allowed"
    else:
        # This will cause the program to exit and log things if logging is
        # enabled. -Brent
        tracebackrepy.handle_internalerror(
            "find_action returned '" + str(action) + "' for call '" +
            str(call) + "'", 31)
Esempio n. 3
0
def assertisallowed(call,*args):
  if disablerestrictions:
    return True

  # let's pre-reject certain open / file calls
  #print call_rule_table[call]
  matches = find_action(call_rule_table[call], args)
  action, matched_rule, reasoning = matches[0]
  if action == 'allow':
    return True
  elif action == 'deny':
    matches.reverse()
    estr = "Call '"+str(call)+"' with args "+str(args)+" not allowed\n"
    estr += "Matching dump:\n"
    for action, matched_rule, reasoning in matches:
      if matched_rule != '':
        estr += "rule: "+str(matched_rule) + ", "
      estr += str(reasoning) + "\n"
    raise Exception, estr
  elif action == 'prompt':
    # would do an upcall here...
    raise Exception, "Call '"+ str(call)+"' not allowed"
  else:
    # This will cause the program to exit and log things if logging is
    # enabled. -Brent
    tracebackrepy.handle_internalerror("find_action returned '" + str(action) +
        "' for call '" + str(call) + "'", 31)
Esempio n. 4
0
def randombytes():
  """
  <Purpose>
    Return a string of random bytes with length 1024

  <Arguments>
    None.

  <Exceptions>
    None.

  <Side Effects>
    This function is metered because it may involve using a hardware source of randomness.

  <Resource Consumption>
    This operation consumes 1024 bytes of random data.

  <Returns>
    The string of bytes.
  """
  # Wait for random resources
  nanny.tattle_quantity('random', 0)

  # If an OS-specific source of randomness is not a found
  # a NotImplementedError would be raised. 
  # Anthony - a NotImplementedError will be logged as an internal
  # error so that we will hopefully be able to identify the system,
  # the exception is not passed on because the problem was not
  # caused by the user. The exit code 217 was chosen to be
  # unique from all other exit calls in repy.
  try:
    randomdata = os.urandom(1024)
  except NotImplementedError, e:
    tracebackrepy.handle_internalerror("os.urandom is not implemented " + \
        "(Exception was: %s)" % e.message, 217)
Esempio n. 5
0
def randombytes():
    """
  <Purpose>
    Return a string of random bytes with length 1024

  <Arguments>
    None.

  <Exceptions>
    None.

  <Side Effects>
    This function is metered because it may involve using a hardware source of randomness.

  <Resource Consumption>
    This operation consumes 1024 bytes of random data.

  <Returns>
    The string of bytes.
  """
    # Wait for random resources
    nanny.tattle_quantity('random', 0)

    # If an OS-specific source of randomness is not a found
    # a NotImplementedError would be raised.
    # Anthony - a NotImplementedError will be logged as an internal
    # error so that we will hopefully be able to identify the system,
    # the exception is not passed on because the problem was not
    # caused by the user. The exit code 217 was chosen to be
    # unique from all other exit calls in repy.
    try:
        randomdata = os.urandom(1024)
    except NotImplementedError, e:
        tracebackrepy.handle_internalerror("os.urandom is not implemented " + \
            "(Exception was: %s)" % e.message, 217)
Esempio n. 6
0
def _tattle_quantity(resource, quantity, resourcesalloweddict,
                     resourcesuseddict):
    """
   <Purpose>
      Notify the nanny of the consumption of a renewable resource.   A 
      renewable resource is something like CPU or network bandwidth that is 
      speficied in quantity per second.

   <Arguments>
      resource:
         A string with the resource name.   
      quantity:
         The amount consumed.   This can be zero (to indicate the program 
         should block if the resource is already over subscribed) but 
         cannot be negative

   <Exceptions>
      None.

   <Side Effects>
      May sleep the program until the resource is available.

   <Returns>
      None.
  """

    # I assume that the quantity will never be negative
    if quantity < 0:
        # This will cause the program to exit and log things if logging is
        # enabled. -Brent
        tracebackrepy.handle_internalerror(
            "Resource '" + resource + "' has a negative quantity " +
            str(quantity) + "!", 132)

    # get the lock for this resource
    resourcesuseddict['renewable_locks'][resource].acquire()

    # release the lock afterwards no matter what
    try:
        # update the resource counters based upon the current time.
        _update_resource_consumption_table(resource, resourcesalloweddict,
                                           resourcesuseddict)

        # It's renewable, so I can wait for it to clear
        if resource not in resource_constants.renewable_resources:
            # Should never have a quantity tattle for a non-renewable resource
            # This will cause the program to exit and log things if logging is
            # enabled. -Brent
            tracebackrepy.handle_internalerror(
                "Resource '" + resource + "' is not renewable!", 133)

        resourcesuseddict[resource] = resourcesuseddict[resource] + quantity
        # I'll block if I'm over...
        _sleep_until_resource_drains(resource, resourcesalloweddict,
                                     resourcesuseddict)

    finally:
        # release the lock for this resource
        resourcesuseddict['renewable_locks'][resource].release()
Esempio n. 7
0
def _tattle_quantity(resource, quantity, resourcesalloweddict, resourcesuseddict):
  """
   <Purpose>
      Notify the nanny of the consumption of a renewable resource.   A 
      renewable resource is something like CPU or network bandwidth that is 
      speficied in quantity per second.

   <Arguments>
      resource:
         A string with the resource name.   
      quantity:
         The amount consumed.   This can be zero (to indicate the program 
         should block if the resource is already over subscribed) but 
         cannot be negative

   <Exceptions>
      None.

   <Side Effects>
      May sleep the program until the resource is available.

   <Returns>
      None.
  """


  # I assume that the quantity will never be negative
  if quantity < 0:
    # This will cause the program to exit and log things if logging is
    # enabled. -Brent
    tracebackrepy.handle_internalerror("Resource '" + resource + 
        "' has a negative quantity " + str(quantity) + "!", 132)
    
  # get the lock for this resource
  resourcesuseddict['renewable_locks'][resource].acquire()
  
  # release the lock afterwards no matter what
  try: 
    # update the resource counters based upon the current time.
    _update_resource_consumption_table(resource, resourcesalloweddict, resourcesuseddict)

    # It's renewable, so I can wait for it to clear
    if resource not in resource_constants.renewable_resources:
      # Should never have a quantity tattle for a non-renewable resource
      # This will cause the program to exit and log things if logging is
      # enabled. -Brent
      tracebackrepy.handle_internalerror("Resource '" + resource + 
          "' is not renewable!", 133)
  

    resourcesuseddict[resource] = resourcesuseddict[resource] + quantity
    # I'll block if I'm over...
    _sleep_until_resource_drains(resource, resourcesalloweddict, resourcesuseddict)
  
  finally:
    # release the lock for this resource
    resourcesuseddict['renewable_locks'][resource].release()
Esempio n. 8
0
def execute_namespace_until_completion(thisnamespace, thiscontext):

    # I'll use this to detect when the program is idle so I know when to quit...
    idlethreadcount = threading.activeCount()

    # add my thread to the set of threads that are used...
    event_id = idhelper.getuniqueid()
    try:
        nanny.tattle_add_item('events', event_id)
    except Exception, e:
        tracebackrepy.handle_internalerror("Failed to acquire event for '" + \
                  "initialize' event.\n(Exception was: %s)" % e.message, 140)
Esempio n. 9
0
def execute_namespace_until_completion(thisnamespace, thiscontext):

  # I'll use this to detect when the program is idle so I know when to quit...
  idlethreadcount =  threading.activeCount()

 
  # add my thread to the set of threads that are used...
  event_id = idhelper.getuniqueid()
  try:
    nanny.tattle_add_item('events', event_id)
  except Exception, e:
    tracebackrepy.handle_internalerror("Failed to acquire event for '" + \
              "initialize' event.\n(Exception was: %s)" % e.message, 140)
Esempio n. 10
0
def randomfloat():
  """
   <Purpose>
     Return a random number in the range [0.0, 1.0) using sources 
     provided by the operating system (such as /dev/urandom on Unix or
     CryptGenRandom on Windows).

   <Arguments>
     None

   <Exceptions>
     None

   <Side Effects>
     This function is metered because it may involve using a hardware
     source of randomness.
     
     If os.urandom raises a NotImplementedError then we will log the
     exception as interalerror and a harshexit will occur. A machine
     that raised this exception has not been observed but it is best
     that the problemed be logged. os.urandom will raise the exception
     if a source of OS-specific random numbers is not found.

   <Returns>
     The number (a float)

  """

  restrictions.assertisallowed('randomfloat')
  nanny.tattle_quantity('random',1)
  
  # If an OS-specific source of randomness is not a found
  # a NotImplementedError would be raised. 
  # Anthony - a NotImplementedError will be logged as an internal
  # error so that we will hopefully be able to identify the system,
  # the exception is not passed on because the problem was not
  # caused by the user. The exit code 217 was chosen to be
  # unique from all other exit calls in repy.
  # Get 56 bits of random data
  try:
    randombytes = os.urandom(7)
  except NotImplementedError, e:
    tracebackrepy.handle_internalerror("os.urandom is not implemented " + \
        "(Exception was: %s)" % e.message, 217)
Esempio n. 11
0
def randomfloat():
    """
   <Purpose>
     Return a random number in the range [0.0, 1.0) using sources 
     provided by the operating system (such as /dev/urandom on Unix or
     CryptGenRandom on Windows).

   <Arguments>
     None

   <Exceptions>
     None

   <Side Effects>
     This function is metered because it may involve using a hardware
     source of randomness.
     
     If os.urandom raises a NotImplementedError then we will log the
     exception as interalerror and a harshexit will occur. A machine
     that raised this exception has not been observed but it is best
     that the problemed be logged. os.urandom will raise the exception
     if a source of OS-specific random numbers is not found.

   <Returns>
     The number (a float)

  """

    restrictions.assertisallowed('randomfloat')
    nanny.tattle_quantity('random', 1)

    # If an OS-specific source of randomness is not a found
    # a NotImplementedError would be raised.
    # Anthony - a NotImplementedError will be logged as an internal
    # error so that we will hopefully be able to identify the system,
    # the exception is not passed on because the problem was not
    # caused by the user. The exit code 217 was chosen to be
    # unique from all other exit calls in repy.
    # Get 56 bits of random data
    try:
        randombytes = os.urandom(7)
    except NotImplementedError, e:
        tracebackrepy.handle_internalerror("os.urandom is not implemented " + \
            "(Exception was: %s)" % e.message, 217)
Esempio n. 12
0
    main_namespace.evaluate(usercontext)
    sys.exit(0)


  # I'll use this to detect when the program is idle so I know when to quit...
  idlethreadcount =  threading.activeCount()

  # call the initialize function
  usercontext['callfunc'] = 'initialize'
  usercontext['callargs'] = args[:]
 
  event_id = idhelper.getuniqueid()
  try:
    nanny.tattle_add_item('events', event_id)
  except Exception, e:
    tracebackrepy.handle_internalerror("Failed to aquire event for '" + \
              "initialize' event.\n(Exception was: %s)" % e.message, 140)
 
  try:
    if profile:
      p = cProfile.Profile()
      p.runctx('main_namespace.evaluate(usercontext)', globals(), locals(),)
      p = pstats.Stats(p)
      # p.sort_stats('cumulative')
      p.print_stats()
    else:
      main_namespace.evaluate(usercontext)
  except SystemExit:
    raise
  except:
    # I think it makes sense to exit if their code throws an exception...
    tracebackrepy.handle_exception()
Esempio n. 13
0
def _handle_internalerror(message, exitcode):
  """
  Terminate the running program. This is used rather than
  tracebackrepy.handle_internalerror directly in order to make testing easier."""
  tracebackrepy.handle_internalerror(message, exitcode)
Esempio n. 14
0
def _handle_internalerror(message, exitcode):
    """
  Terminate the running program. This is used rather than
  tracebackrepy.handle_internalerror directly in order to make testing easier."""
    tracebackrepy.handle_internalerror(message, exitcode)
Esempio n. 15
0
    main_namespace.evaluate(usercontext)
    sys.exit(0)


  # I'll use this to detect when the program is idle so I know when to quit...
  idlethreadcount =  threading.activeCount()

  # call the initialize function
  usercontext['callfunc'] = 'initialize'
  usercontext['callargs'] = args[:]

  initialize_id = idhelper.getuniqueid()
  try:
    nanny.tattle_add_item('events', initialize_id)
  except Exception, e:
    tracebackrepy.handle_internalerror("Failed to aquire event for '" + \
        "initialize' event.\n(Exception was: %s)" % e.message, 140)

  try:
    main_namespace.evaluate(usercontext)
  except SystemExit:
    raise
  except:
    # I think it makes sense to exit if their code throws an exception...
    tracebackrepy.handle_exception()
    harshexit.harshexit(6)
  finally:
    nanny.tattle_remove_item('events', initialize_id)


  # I've changed to the threading library, so this should increase if there are
  # pending events