# (*) otherwise, entering through the root context
# make sync PLCHOST=testbox1.inria.fr GUEST=vplc03.inria.fr
+PLCHOST ?= testplc.onelab.eu
+
ifdef GUEST
ifdef PLCHOST
SSHURL:=root@$(PLCHOST):/vservers/$(GUEST)
print >> sys.stderr, "FAILED: on node %s: %s=%s" % (node, name, value)
print command.rspec
-
-
-
print >> sys.stderr, "FAILED: on node %s: %s=%s" % (node, name, value)
print command.rspec
-
-
-
from sfa.util.faults import *
from sfa.util.storage import *
from sfa.util.policy import Policy
-from sfa.util.debug import log
from sfa.server.aggregate import Aggregates
from sfa.server.registry import Registries
from sfa.util.faults import *
from sfa.util.policy import Policy
from sfa.util.record import *
from sfa.util.sfaticket import SfaTicket
-from sfa.util.debug import log
from sfa.plc.slices import Slices
from sfa.trust.credential import Credential
import sfa.plc.peers as peers
from sfa.util.record import *
from sfa.util.sfaticket import SfaTicket
from sfa.server.registry import Registries
-from sfa.util.debug import log
from sfa.plc.slices import Slices
import sfa.plc.peers as peers
from sfa.managers.vini.vini_network import *
from sfa.trust.credential import Credential
from sfa.util.threadmanager import ThreadManager
import sfa.util.xmlrpcprotocol as xmlrpcprotocol
-from sfa.util.debug import log
import sfa.plc.peers as peers
from copy import copy
from sfa.util.method import Method
from sfa.util.parameter import Parameter, Mixed
from sfa.util.sfatablesRuntime import run_sfatables
-import sys
from sfa.trust.credential import Credential
class CreateSliver(Method):
allocated = manager.create_slice(self.api, slice_xrn, creds, rspec, users)
return rspec
-
from sfa.util.namespace import *
from sfa.util.method import Method
from sfa.util.parameter import Parameter, Mixed
-from sfa.util.debug import log
from sfa.trust.credential import Credential
class GetCredential(Method):
from sfa.util.method import Method
from sfa.util.parameter import Parameter, Mixed
from sfa.util.record import SfaRecord
-from sfa.util.debug import log
from sfa.trust.certificate import Certificate
class GetSelfCredential(Method):
from sfa.util.method import Method
from sfa.util.parameter import Parameter, Mixed
from sfa.util.record import SfaRecord
-from sfa.util.debug import log
from sfa.trust.auth import Auth
from sfa.trust.gid import create_uuid
from sfa.trust.credential import Credential
from sfa.util.parameter import Parameter, Mixed
from sfa.util.record import SfaRecord
from sfa.util.table import SfaTable
-from sfa.util.debug import log
from sfa.trust.auth import Auth
from sfa.trust.gid import create_uuid
from sfa.trust.credential import Credential
from sfa.util.namespace import *
from sfa.util.method import Method
from sfa.util.parameter import Parameter, Mixed
-from sfa.util.debug import log
from sfa.trust.credential import Credential
class Remove(Method):
from sfa.trust.auth import Auth
from sfa.util.record import SfaRecord
from sfa.util.table import SfaTable
-from sfa.util.debug import log
from sfa.trust.credential import Credential
from types import StringTypes
from sfa.util.namespace import *
from sfa.util.method import Method
from sfa.util.parameter import Parameter, Mixed
-from sfa.util.debug import log
from sfa.trust.credential import Credential
from sfa.util.record import SfaRecord
from sfa.util.faults import *
from sfa.util.method import Method
from sfa.util.parameter import Parameter, Mixed
-from sfa.util.debug import log
from sfa.trust.credential import Credential
class Update(Method):
from sfa.util.method import Method
from sfa.util.parameter import Parameter, Mixed
from sfa.util.record import SfaRecord
-from sfa.util.debug import log
from sfa.methods.GetSelfCredential import GetSelfCredential
class get_self_credential(GetSelfCredential):
-
-### $URL: https://svn.planet-lab.org/svn/sfa/trunk/sfa/methods/reset_slices.py $
-
from sfa.util.faults import *
from sfa.util.method import Method
from sfa.util.parameter import Parameter, Mixed
# If cred is not specified just return the gid for this interface.
# This is true when when a peer is attempting to initiate federation
# with this interface
- print cred
+ sfaloging.logger.debug("get_trusted_certs: %r"%cred)
if not cred:
gid_strings = []
for gid in self.api.auth.trusted_cert_list:
from sfa.util.parameter import Parameter, Mixed
from sfa.util.record import SfaRecord
from sfa.util.table import SfaTable
-from sfa.util.debug import log
from sfa.trust.auth import Auth
from sfa.trust.gid import create_uuid
from sfa.trust.credential import Credential
from sfa.trust.auth import Auth
from sfa.util.record import SfaRecord
from sfa.util.table import SfaTable
-from sfa.util.debug import log
from sfa.trust.credential import Credential
from types import StringTypes
import string
import xmlrpclib
-import sfa.util.sfalogging
+from sfa.util.sfalogging import sfa_logger
from sfa.trust.auth import Auth
from sfa.util.config import *
from sfa.util.faults import *
-from sfa.util.debug import *
from sfa.trust.rights import *
from sfa.trust.credential import *
from sfa.trust.certificate import *
self.hrn = self.config.SFA_INTERFACE_HRN
self.time_format = "%Y-%m-%d %H:%M:%S"
- self.logger=sfa.util.sfalogging.logger
+ self.logger=sfa_logger
def getPLCShell(self):
self.plauth = {'Username': self.config.SFA_PLC_USER,
import string
import xmlrpclib
-import sfa.util.sfalogging
+from sfa.util.sfalogging import sfa_logger
import sfa.util.xmlrpcprotocol as xmlrpcprotocol
from sfa.trust.auth import Auth
from sfa.util.config import *
from sfa.util.faults import *
-from sfa.util.debug import *
from sfa.trust.rights import *
from sfa.trust.credential import *
from sfa.trust.certificate import *
self.hrn = self.config.SFA_INTERFACE_HRN
self.time_format = "%Y-%m-%d %H:%M:%S"
- self.logger=sfa.util.sfalogging.logger
+ self.logger=sfa_logger
def getPLCShell(self):
self.plauth = {'Username': self.config.SFA_PLC_USER,
def getCredential(self):
"""
- Retrun a valid credential for this interface.
+ Return a valid credential for this interface.
"""
if self.interface in ['registry']:
return self.getCredentialFromLocalRegistry()
self.hostname = iface['hostname']
self.primary = iface['is_primary']
- """
- Just print out bwlimit right now
- """
def toxml(self, xml):
+ """
+ Just print out bwlimit right now
+ """
if self.bwlimit:
with xml.bw_limit(units="kbps"):
xml << str(self.bwlimit / 1000)
import getopt
import sys
import tempfile
-import logging.handlers
-import logging
+
from sfa.util.record import *
from sfa.util.table import SfaTable
from sfa.util.namespace import *
from sfa.trust.hierarchy import *
from sfa.plc.api import *
from sfa.trust.gid import create_uuid
-from sfa.plc.sfaImport import *
-from sfa.util.report import trace, error
+from sfa.plc.sfaImport import sfaImport
def process_options():
global hrn
f.close()
def main():
- # setup the logger
- LOGFILE='/var/log/sfa_import_plc.log'
- logging.basicConfig(level=logging.INFO,
- format='%(asctime)s - %(message)s',
- filename=LOGFILE)
- rotate_handler = logging.handlers.RotatingFileHandler(LOGFILE, maxBytes=1000000, backupCount=5)
- logger = logging.getLogger()
- logger.addHandler(rotate_handler)
-
+
process_options()
config = Config()
if not config.SFA_REGISTRY_ENABLED:
root_auth = config.SFA_REGISTRY_ROOT_AUTH
interface_hrn = config.SFA_INTERFACE_HRN
keys_filename = config.config_path + os.sep + 'person_keys.py'
- sfaImporter = sfaImport(logger)
+ sfaImporter = sfaImport()
shell = sfaImporter.shell
plc_auth = sfaImporter.plc_auth
AuthHierarchy = sfaImporter.AuthHierarchy
if not root_auth == interface_hrn:
sfaImporter.create_top_level_auth_records(interface_hrn)
- trace("Import: adding " + interface_hrn + " to trusted list", logger)
+ sfaImporter.logger.info("Import: adding " + interface_hrn + " to trusted list")
authority = AuthHierarchy.get_auth_info(interface_hrn)
TrustedRoots.add_gid(authority.get_gid_object())
sfaImporter.delete_record(record_hrn, type)
# save pub keys
- trace('Import: saving current pub keys', logger)
+ sfaImporter.logger.info('Import: saving current pub keys')
save_keys(keys_filename, person_keys)
if __name__ == "__main__":
from sfa.trust.hierarchy import *
from sfa.util.record import *
from sfa.util.table import SfaTable
+from sfa.util.sfalogging import sfa_import_logger
def process_options():
def main():
process_options()
- print "Purging SFA records from database"
+ sfa_import_logger.info("Purging SFA records from database")
table = SfaTable()
table.sfa_records_purge()
import sys
import tempfile
+from sfa.util.sfalogging import sfa_import_logger
from sfa.util.record import *
from sfa.util.table import SfaTable
from sfa.util.namespace import *
from sfa.util.config import Config
-from sfa.util.report import trace, error
from sfa.trust.certificate import convert_public_key, Keypair
from sfa.trust.trustedroot import *
from sfa.trust.hierarchy import *
from sfa.trust.gid import create_uuid
-def un_unicode(str):
+def _un_unicode(str):
if isinstance(str, unicode):
return str.encode("ascii", "ignore")
else:
return str
-def cleanup_string(str):
+def _cleanup_string(str):
# pgsql has a fit with strings that have high ascii in them, so filter it
# out when generating the hrns.
tmp = ""
tmp = tmp + c
str = tmp
- str = un_unicode(str)
+ str = _un_unicode(str)
str = str.replace(" ", "_")
str = str.replace(".", "_")
str = str.replace("(", "_")
class sfaImport:
- def __init__(self, logger=None):
- self.logger = logger
+ def __init__(self):
+ self.logger = sfa_import_logger
self.AuthHierarchy = Hierarchy()
self.config = Config()
self.TrustedRoots = TrustedRootList(Config.get_trustedroots_dir(self.config))
# create the authority if it doesnt already exist
if not AuthHierarchy.auth_exists(urn):
- trace("Import: creating top level authorites", self.logger)
+ self.logger.info("Import: creating top level authorites")
AuthHierarchy.create_auth(urn)
# create the db record if it doesnt already exist
if not auth_record:
auth_record = SfaRecord(hrn=hrn, gid=auth_info.get_gid_object(), type="authority", pointer=-1)
auth_record['authority'] = get_authority(auth_record['hrn'])
- trace("Import: inserting authority record for " + hrn, self.logger)
+ self.logger.info("Import: inserting authority record for " + hrn)
table.insert(auth_record)
if len(hrn) > 64:
hrn = hrn[:64]
- trace("Import: importing person " + hrn, self.logger)
+ self.logger.info("Import: importing person " + hrn)
key_ids = []
if 'key_ids' in person and person['key_ids']:
key_ids = person["key_ids"]
pkey = Keypair(create=True)
else:
# the user has no keys
- trace(" person " + hrn + " does not have a PL public key", self.logger)
+ self.logger.info(" person " + hrn + " does not have a PL public key")
# if a key is unavailable, then we still need to put something in the
# user's GID. So make one up.
pkey = Keypair(create=True)
if not existing_records:
table.insert(person_record)
else:
- trace("Import: %s exists, updating " % hrn, self.logger)
+ self.logger.info("Import: %s exists, updating " % hrn)
existing_record = existing_records[0]
person_record['record_id'] = existing_record['record_id']
table.update(person_record)
def import_slice(self, parent_hrn, slice):
AuthHierarchy = self.AuthHierarchy
slicename = slice['name'].split("_",1)[-1]
- slicename = cleanup_string(slicename)
+ slicename = _cleanup_string(slicename)
if not slicename:
- error("Import_Slice: failed to parse slice name " + slice['name'], self.logger)
+ self.logger.error("Import_Slice: failed to parse slice name " + slice['name'])
return
hrn = parent_hrn + "." + slicename
- trace("Import: importing slice " + hrn, self.logger)
+ self.logger.info("Import: importing slice " + hrn)
pkey = Keypair(create=True)
urn = hrn_to_urn(hrn, 'slice')
if not existing_records:
table.insert(slice_record)
else:
- trace("Import: %s exists, updating " % hrn, self.logger)
+ self.logger.info("Import: %s exists, updating " % hrn)
existing_record = existing_records[0]
slice_record['record_id'] = existing_record['record_id']
table.update(slice_record)
def import_node(self, parent_hrn, node):
AuthHierarchy = self.AuthHierarchy
nodename = node['hostname'].split(".")[0]
- nodename = cleanup_string(nodename)
+ nodename = _cleanup_string(nodename)
if not nodename:
- error("Import_node: failed to parse node name " + node['hostname'], self.logger)
+ self.logger.error("Import_node: failed to parse node name " + node['hostname'])
return
hrn = parent_hrn + "." + nodename
- trace("Import: importing node " + hrn, self.logger)
+ self.logger.info("Import: importing node " + hrn)
# ASN.1 will have problems with hrn's longer than 64 characters
if len(hrn) > 64:
hrn = hrn[:64]
if not existing_records:
table.insert(node_record)
else:
- trace("Import: %s exists, updating " % hrn, self.logger)
+ self.logger.info("Import: %s exists, updating " % hrn)
existing_record = existing_records[0]
node_record['record_id'] = existing_record['record_id']
table.update(node_record)
shell = self.shell
plc_auth = self.plc_auth
sitename = site['login_base']
- sitename = cleanup_string(sitename)
+ sitename = _cleanup_string(sitename)
print 'importing site %s' % sitename
hrn = parent_hrn + "." + sitename
# Hardcode 'internet2' into the hrn for sites hosting
hrn = ".".join([parent_hrn, "internet2", sitename])
urn = hrn_to_urn(hrn, 'authority')
- trace("Import: importing site " + hrn, self.logger)
+ self.logger.info("Import: importing site " + hrn)
# create the authority
if not AuthHierarchy.auth_exists(urn):
if not existing_records:
table.insert(auth_record)
else:
- trace("Import: %s exists, updating " % hrn, self.logger)
+ self.logger.info("Import: %s exists, updating " % hrn)
existing_record = existing_records[0]
auth_record['record_id'] = existing_record['record_id']
table.update(auth_record)
table = SfaTable()
record_list = table.find({'type': type, 'hrn': hrn})
for record in record_list:
- trace("Import: Removing record %s %s" % (type, hrn), self.logger)
+ self.logger.info("Import: Removing record %s %s" % (type, hrn))
table.remove(record)
from sfa.util.record import SfaRecord
from sfa.util.policy import Policy
from sfa.util.prefixTree import prefixTree
-from sfa.util.debug import log
MAXINT = 2L**31-1
from sfa.util.faults import *
from sfa.util.storage import *
from sfa.util.policy import Policy
-from sfa.util.debug import log
from sfa.server.aggregate import Aggregates
from sfa.server.registry import Registries
from sfa.util.faults import *
import sfa.util.xmlrpcprotocol as xmlrpcprotocol
import sfa.util.soapprotocol as soapprotocol
-
# GeniLight client support is optional
try:
from egeni.geniLight_client import *
except:
message = "interface: %s\tunable to install trusted gid for %s" % \
(self.api.interface, new_hrn)
- self.api.logger.info(message)
- traceback.print_exc()
+ self.api.logger.log_exc(message)
# reload the trusted certs list
self.api.auth.load_trusted_certs()
defined in the config file (registries.xml). Removes old records from
the db.
"""
- # import SfaTable here so this module can be loaded by CompoenetAPI
+ # import SfaTable here so this module can be loaded by ComponentAPI
from sfa.util.table import SfaTable
if not gids:
return
from mod_python import apache
from sfa.plc.api import SfaAPI
-from sfa.util.debug import log
+from sfa.util.sfalogging import sfa_logger
api = SfaAPI(interface='aggregate')
-class unbuffered:
- """\r
- Write to /var/log/httpd/error_log. See\r
-\r
- http://www.modpython.org/FAQ/faqw.py?req=edit&file=faq02.003.htp\r
- """\r
-\r
- def write(self, data):\r
- sys.stderr.write(data)\r
- sys.stderr.flush()\r
-\r
-#log = unbuffered()
-
def handler(req):
try:
if req.method != "POST":
except Exception, err:
# Log error in /var/log/httpd/(ssl_)?error_log
- print >> log, err, traceback.format_exc()
+ sfa_logger.log_exc('%r'%err)
return apache.HTTP_INTERNAL_SERVER_ERROR
import traceback
import xmlrpclib
from mod_python import apache
-from sfa.util.debug import log
+
from sfa.plc.api import SfaAPI
+from sfa.util.sfalogging import sfa_logger
api = SfaAPI(interface='registry')
-class unbuffered:
- """\r
- Write to /var/log/httpd/error_log. See\r
-\r
- http://www.modpython.org/FAQ/faqw.py?req=edit&file=faq02.003.htp\r
- """\r
-\r
- def write(self, data):\r
- sys.stderr.write(data)\r
- sys.stderr.flush()\r
-\r
-#log = unbuffered()
-
def handler(req):
try:
if req.method != "POST":
except Exception, err:
# Log error in /var/log/httpd/(ssl_)?error_log
- print >> log, err, traceback.format_exc()
+ sfa_logger.log_exc('%r'%err)
return apache.HTTP_INTERNAL_SERVER_ERROR
from mod_python import apache
from sfa.plc.api import SfaAPI
-from sfa.util.debug import log
+from sfa.util.sfalogging import sfa_logger
api = SfaAPI(interface='slicemgr')
-class unbuffered:
- """\r
- Write to /var/log/httpd/error_log. See\r
-\r
- http://www.modpython.org/FAQ/faqw.py?req=edit&file=faq02.003.htp\r
- """\r
-\r
- def write(self, data):\r
- sys.stderr.write(data)\r
- sys.stderr.flush()\r
-\r
-#log = unbuffered()
-
def handler(req):
try:
if req.method != "POST":
except Exception, err:
# Log error in /var/log/httpd/(ssl_)?error_log
- print >> log, err, traceback.format_exc()
+ sfa_logger.log_exc('%r'%err)
return apache.HTTP_INTERNAL_SERVER_ERROR
class ExceptionUnmarshaller(xmlrpclib.Unmarshaller):
def close(self):
- try:\r
- return xmlrpclib.Unmarshaller.close(self)\r
- except xmlrpclib.Fault, e:\r
- # if the server tagged some traceback info onto the end of the\r
- # exception text, then print it out on the client.\r
-\r
- if "\nFAULT_TRACEBACK:" in e.faultString:\r
- parts = e.faultString.split("\nFAULT_TRACEBACK:")\r
- e.faultString = parts[0]\r
- if VerboseExceptions:\r
- print "\n|Server Traceback:", "\n|".join(parts[1].split("\n"))\r
-\r
- raise e\r
-\r
+ try:
+ return xmlrpclib.Unmarshaller.close(self)
+ except xmlrpclib.Fault, e:
+ # if the server tagged some traceback info onto the end of the
+ # exception text, then print it out on the client.
+
+ if "\nFAULT_TRACEBACK:" in e.faultString:
+ parts = e.faultString.split("\nFAULT_TRACEBACK:")
+ e.faultString = parts[0]
+ if VerboseExceptions:
+ print "\n|Server Traceback:", "\n|".join(parts[1].split("\n"))
+
+ raise e
+
class ExceptionReportingTransport(xmlrpclib.Transport):
def make_connection(self, host):
- import httplib\r
- if host.startswith("https:"):\r
- return httplib.HTTPS(host)\r
- else:\r
- return httplib.HTTP(host)\r
-\r
- def getparser(self):\r
- unmarshaller = ExceptionUnmarshaller()\r
- parser = xmlrpclib.ExpatParser(unmarshaller)\r
+ import httplib
+ if host.startswith("https:"):
+ return httplib.HTTPS(host)
+ else:
+ return httplib.HTTP(host)
+
+ def getparser(self):
+ unmarshaller = ExceptionUnmarshaller()
+ parser = xmlrpclib.ExpatParser(unmarshaller)
return parser, unmarshaller
class BaseClient():
import xmlrpclib
from mod_python import apache
+from sfa.util.logging import sfa_logger
from API import RemoteApi
api = RemoteApi()
-class unbuffered:
- """\r
- Write to /var/log/httpd/error_log. See\r
-\r
- http://www.modpython.org/FAQ/faqw.py?req=edit&file=faq02.003.htp\r
- """\r
-\r
- def write(self, data):\r
- sys.stderr.write(data)\r
- sys.stderr.flush()\r
-\r
-#log = unbuffered()
-
def handler(req):
try:
if req.method != "POST":
except Exception, err:
# Log error in /var/log/httpd/(ssl_)?error_log
- print >> log, err, traceback.format_exc()
+ sfa_logger.log_exc("%r"%e)
return apache.HTTP_INTERNAL_SERVER_ERROR
import os, os.path
import sys
from optparse import OptionParser
+from sfa.util.sfalogging import sfa_logger
from sfa.trust.trustedroot import TrustedRootList
from sfa.trust.certificate import Keypair, Certificate
from sfa.trust.hierarchy import Hierarchy
devnull = os.open(os.devnull, os.O_RDWR)
os.dup2(devnull, 0)
# xxx fixme - this is just to make sure that nothing gets stupidly lost - should use devnull
- crashlog = os.open('/var/log/sfa.daemon', os.O_RDWR | os.O_APPEND | os.O_CREAT, 0644)
+ crashlog = os.open('/var/log/httpd/sfa_access_log', os.O_RDWR | os.O_APPEND | os.O_CREAT, 0644)
os.dup2(crashlog, 1)
os.dup2(crashlog, 2)
c.start()
if __name__ == "__main__":
- main()
+ try:
+ main()
+ except:
+ sfa_logger.log_exc_critical("SFA server is exiting")
#
-#import sfa.util.sfalogging
from sfa.trust.certificate import Keypair, Certificate
from sfa.trust.credential import Credential
from sfa.trust.trustedroot import TrustedRootList
import M2Crypto
from M2Crypto import X509
-import sfa.util.sfalogging
+from sfa.util.sfalogging import sfa_logger
from sfa.util.namespace import urn_to_hrn
from sfa.util.faults import *
try:
k.load_pubkey_from_file(ssl_fn)
except:
- traceback.print_exc()
+ sfa_logger.log_exc("convert_public_key caught exception")
k = None
# remove the temporary files
# if this cert is signed by a trusted_cert, then we are set
for trusted_cert in trusted_certs:
if self.is_signed_by_cert(trusted_cert):
- sfa.util.sfalogging.logger.debug("Cert %s signed by trusted cert %s", self.get_subject(), trusted_cert.get_subject())
+ sfa_logger.debug("Cert %s signed by trusted cert %s", self.get_subject(), trusted_cert.get_subject())
# verify expiration of trusted_cert ?
if not trusted_cert.cert.has_expired():
return trusted_cert
else:
- sfa.util.sfalogging.logger.debug("Trusted cert %s is expired", trusted_cert.get_subject())
+ sfa_logger.debug("Trusted cert %s is expired", trusted_cert.get_subject())
# if there is no parent, then no way to verify the chain
if not self.parent:
- #print self.get_subject(), "has no parent"
+ sfa_logger.debug("%r has no parent"%self.get_subject())
raise CertMissingParent(self.get_subject())
# if it wasn't signed by the parent...
if not self.is_signed_by_cert(self.parent):
- #print self.get_subject(), "is not signed by parent"
+ sfa_logger.debug("%r is not signed by parent"%self.get_subject())
return CertNotSignedByParent(self.get_subject())
# if the parent isn't verified...
from xml.dom.minidom import Document, parseString
from dateutil.parser import parse
-import sfa.util.sfalogging
+from sfa.util.sfalogging import sfa_logger
from sfa.trust.certificate import Keypair
from sfa.trust.credential_legacy import CredentialLegacy
from sfa.trust.rights import *
trusted_cert_objects.append(GID(filename=f))
ok_trusted_certs.append(f)
except Exception, exc:
- sfa.util.sfalogging.logger.error("Failed to load trusted cert from %s: %r", f, exc)
+ sfa_logger.error("Failed to load trusted cert from %s: %r", f, exc)
trusted_certs = ok_trusted_certs
# Use legacy verification if this is a legacy credential
# Maybe should be (hrn, type) = urn_to_hrn(root_cred_signer.get_urn())
root_cred_signer_type = root_cred_signer.get_type()
if (root_cred_signer_type == 'authority'):
- #sfa.util.sfalogging.logger.debug('Cred signer is an authority')
+ #sfa_logger.debug('Cred signer is an authority')
# signer is an authority, see if target is in authority's domain
hrn = root_cred_signer.get_hrn()
if root_target_gid.get_hrn().startswith(hrn):
import xmlrpclib
import uuid
-import sfa.util.sfalogging
+from sfa.util.sfalogging import sfa_logger
from sfa.trust.certificate import Certificate
from sfa.util.namespace import *
Certificate.__init__(self, create, subject, string, filename)
if subject:
- sfa.util.sfalogging.logger.debug("Creating GID for subject: %s" % subject)
+ sfa_logger.debug("Creating GID for subject: %s" % subject)
if uuid:
self.uuid = int(uuid)
if hrn:
if self.parent:
# make sure the parent's hrn is a prefix of the child's hrn
if not self.get_hrn().startswith(self.parent.get_hrn()):
- #print self.get_hrn(), " ", self.parent.get_hrn()
- raise GidParentHrn("This cert %s HRN doesnt start with parent HRN %s" % (self.get_hrn(), self.parent.get_hrn()))
+ raise GidParentHrn("This cert HRN %s doesnt start with parent HRN %s" % (self.get_hrn(), self.parent.get_hrn()))
else:
# make sure that the trusted root's hrn is a prefix of the child's
trusted_gid = GID(string=trusted_root.save_to_string())
import os
+from sfa.util.sfalogging import sfa_logger
from sfa.util.report import *
from sfa.trust.certificate import Keypair
from sfa.trust.credential import *
pass
if os.path.exists(privkey_filename):
- print "using existing key", privkey_filename, "for authority", hrn
+ sfa_logger.debug("using existing key %r for authority %r"%(privkey_filename,hrn))
pkey = Keypair(filename = privkey_filename)
else:
pkey = Keypair(create = True)
from pprint import pformat
from sfa.util.faults import *
-from sfa.util.debug import *
+from sfa.util.sfalogging import sfa_logger
if not psycopg2:
is8bit = re.compile("[\x80-\xff]").search
if not params:
if self.debug:
- print >> log,'execute0',query
+ sfa_logger.debug('execute0 %r'%query)
cursor.execute(query)
elif isinstance(params,dict):
if self.debug:
- print >> log,'execute-dict: params',params,'query',query%params
+ sfa_logger.debug('execute-dict: params=[%r] query=[%r]'%(params,query%params))
cursor.execute(query,params)
elif isinstance(params,tuple) and len(params)==1:
if self.debug:
- print >> log,'execute-tuple',query%params[0]
+ sfa_logger.debug('execute-tuple %r'%(query%params[0]))
cursor.execute(query,params[0])
else:
param_seq=(params,)
if self.debug:
for params in param_seq:
- print >> log,'executemany',query%params
+ sfa_logger.debug('executemany %r'%(query%params))
cursor.executemany(query, param_seq)
(self.rowcount, self.description, self.lastrowid) = \
(cursor.rowcount, cursor.description, cursor.lastrowid)
except:
pass
uuid = commands.getoutput("uuidgen")
- print >> log, "Database error %s:" % uuid
- print >> log, e
- print >> log, "Query:"
- print >> log, query
- print >> log, "Params:"
- print >> log, pformat(params)
+ sfa_logger.error("Database error %s:" % uuid)
+ sfa_logger.error("Exception=%r"%e)
+ sfa_logger.error("Query=%r"%query)
+ sfa_logger.error("Params=%r"%pformat(params))
+ sfa_logger.log_exc("PostgreSQL.execute caught exception")
raise SfaDBError("Please contact support: %s" % str(e))
return cursor
import string
import xmlrpclib
-import sfa.util.sfalogging
+from sfa.util.sfalogging import sfa_logger
from sfa.trust.auth import Auth
from sfa.util.config import *
from sfa.util.faults import *
-from sfa.util.debug import *
from sfa.trust.credential import *
from sfa.trust.certificate import *
from sfa.util.namespace import *
self.credential = None
self.source = None
self.time_format = "%Y-%m-%d %H:%M:%S"
- self.logger=sfa.util.sfalogging.logger
+ self.logger=sfa_logger
# load registries
from sfa.server.registry import Registries
except SfaFault, fault:
result = fault
except Exception, fault:
- traceback.print_exc(file = log)
+ sfa_logger.log_exc("BaseAPI.handle has caught Exception")
result = SfaAPIError(fault)
import SimpleHTTPServer
import SimpleXMLRPCServer
from OpenSSL import SSL
+
+from sfa.util.sfalogging import sfa_logger
from sfa.trust.certificate import Keypair, Certificate
from sfa.trust.credential import *
from sfa.util.faults import *
from sfa.plc.api import ComponentAPI
from sfa.util.server import verify_callback, ThreadedServer
-from sfa.util.debug import log
##
# internal error, report as HTTP server error
self.send_response(500)
self.end_headers()
- traceback.print_exc()
+ sfa_logger.log_exc("componentserver.SecureXMLRpcRequestHandler.do_POST")
else:
# got a valid XML RPC response
self.send_response(200)
import os.path
import traceback
-from sfa.util.debug import log
-
class Config:
"""
Parse the bash/Python/PHP version of the configuration file. Very
+++ /dev/null
-### $Id$
-### $URL$
-
-import time
-import sys
-import syslog
-
-class unbuffered:
- """
- Write to /var/log/httpd/error_log. See
-
- http://www.modpython.org/FAQ/faqw.py?req=edit&file=faq02.003.htp
- """
-
- def write(self, data):
- sys.stderr.write(data)
- sys.stderr.flush()
-
-log = unbuffered()
-
-def profile(callable):
- """
- Prints the runtime of the specified callable. Use as a decorator, e.g.,
-
- @profile
- def foo(...):
- ...
-
- Or, equivalently,
-
- def foo(...):
- ...
- foo = profile(foo)
-
- Or inline:
-
- result = profile(foo)(...)
- """
-
- def wrapper(*args, **kwds):
- start = time.time()
- result = callable(*args, **kwds)
- end = time.time()
- args = map(str, args)
- args += ["%s = %s" % (name, str(value)) for (name, value) in kwds.items()]
- print >> log, "%s (%s): %f s" % (callable.__name__, ", ".join(args), end - start)
- return result
-
- return wrapper
-
-if __name__ == "__main__":
- def sleep(seconds = 1):
- time.sleep(seconds)
-
- sleep = profile(sleep)
-
- sleep(1)
clip_part += " ORDER BY " + ",".join(sorts)
if clips:
clip_part += " " + " ".join(clips)
-# print 'where_part=',where_part,'clip_part',clip_part
return (where_part,clip_part)
import xmlrpclib
-import sfa.util.sfalogging
+from sfa.util.sfalogging import sfa_logger
from sfa.util.faults import *
from sfa.util.parameter import Parameter, Mixed, python_type, xmlrpc_type
from sfa.trust.auth import Auth
-#from sfa.util.debug import profile, log
# we inherit object because we use new-style classes for legacy methods
class Method (object):
if self.api.config.SFA_API_DEBUG or hasattr(self, 'message'):
msg=getattr(self,'message',"method %s completed"%methodname)
- sfa.util.sfalogging.logger.info(msg)
- # XX print to some log file
- # print >> log, "some output"
+ sfa_logger.info(msg)
return result
# Prepend caller and method name to expected faults
fault.faultString = caller + ": " + self.name + ": " + fault.faultString
runtime = time.time() - start
-# if self.api.config.SFA_API_DEBUG:
-# traceback.print_exc()
- sfa.util.sfalogging.log_exc("Method %s raised an exception"%self.name)
+ sfa_logger.log_exc("Method %s raised an exception"%self.name)
raise fault
import os
from sfa.util.storage import *
-from sfa.util.debug import log
class Policy(SimpleStorage):
from sfa.trust.gid import *
-import sfa.util.report
from sfa.util.rspec import *
from sfa.util.parameter import *
from sfa.util.namespace import *
+++ /dev/null
-def trace(x, logger=None):
- if logger:
- logger.info(x)
- else:
- print x
-
-def error(x, logger=None):
- if logger:
- logger.error(x)
- else:
- print x
from lxml import etree
from StringIO import StringIO
+from sfa.util.sfalogging import sfa_logger
class RSpec:
except Exception, e:
# logging.debug("%s: web file not found" % xsdURI)
# logging.debug("Using local file %s" % self.xsd")
- print e
- print "Can't find %s on the web. Continuing." % xsdURI
+ sfa_logger.log_exc("rspec.parseXSD: can't find %s on the web. Continuing." % xsdURI)
if not schemaDom:
if os.path.exists(xsdURI):
# logging.debug("using local copy.")
- print "Using local %s" % xsdURI
+ sfa_logger.debug("rspec.parseXSD: Using local %s" % xsdURI)
schemaDom = minidom.parse(xsdURI)
else:
- raise Exception("Can't find xsd locally")
+ raise Exception("rspec.parseXSD: can't find xsd locally")
self.schemaDict = self.toDict(schemaDom.childNodes[0])
from OpenSSL import SSL
from Queue import Queue
-#import sfa.util.sfalogging
from sfa.trust.certificate import Keypair, Certificate
from sfa.trust.credential import *
from sfa.util.faults import *
from sfa.plc.api import SfaAPI
from sfa.util.cache import Cache
-#from sfa.util.debug import log
##
# Verification callback for pyOpenSSL. We do our own checking of keys because
# we have our own authentication spec. Thus we disable several of the normal
except Exception, fault:
# This should only happen if the module is buggy
# internal error, report as HTTP server error
- traceback.print_exc()
+ sfa_error.log_exc("server.do_POST")
response = self.api.prepare_response(fault)
#self.send_response(500)
#self.end_headers()
-import logging
+#!/usr/bin/python
+
import os
import traceback
+import logging, logging.handlers
+
+class SfaLogging:
+ def __init__ (self,logfile,name=None,level=logging.INFO):
+ # default is to locate logger name from the logfile
+ if not name:
+ name=os.path.basename(logfile)
+ self.logger=logging.getLogger(name)
+ self.logger.setLevel(level)
+ try:
+ handler=logging.handlers.RotatingFileHandler(logfile,maxBytes=1000000, backupCount=5)
+ except IOError:
+ # This is usually a permissions error becaue the file is
+ # owned by root, but httpd is trying to access it.
+ tmplogfile=os.getenv("TMPDIR", "/tmp") + os.path.sep + os.path.basename(logfile)
+ handler=logging.handlers.RotatingFileHandler(tmplogfile,maxBytes=1000000, backupCount=5)
+ handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+ self.logger.addHandler(handler)
+
+ def wrap(fun):
+ def wrapped(self,msg,*args,**kwds):
+ native=getattr(self.logger,fun.__name__)
+ return native(msg,*args,**kwds)
+ #wrapped.__doc__=native.__doc__
+ return wrapped
-#SFA access log initialization
-TMPDIR = os.getenv("TMPDIR", "/tmp")
-SFA_HTTPD_ACCESS_LOGFILE = TMPDIR + "/" + 'sfa_httpd_access.log'
-SFA_ACCESS_LOGFILE='/var/log/sfa_access.log'
-logger=logging.getLogger()
-#logger.setLevel(logging.INFO)
-logger.setLevel(logging.DEBUG)
-
-try:
- logfile=logging.FileHandler(SFA_ACCESS_LOGFILE)
-except IOError:
- # This is usually a permissions error becaue the file is
- # owned by root, but httpd is trying to access it.
- logfile=logging.FileHandler(SFA_HTTPD_ACCESS_LOGFILE)
+ def setLevel(self,level):
+ self.logger.setLevel(level)
+
+ @wrap
+ def critical(): pass
+ @wrap
+ def error(): pass
+ @wrap
+ def warning(): pass
+ @wrap
+ def info(): pass
+ @wrap
+ def debug(): pass
-formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
-logfile.setFormatter(formatter)
-logger.addHandler(logfile)
-def get_sfa_logger():
- return logger
-
-# logs an exception - use in an except statement
-def log_exc(message):
- logger.error("%s BEG TRACEBACK"%message+"\n"+traceback.format_exc().strip("\n"))
- logger.error("%s END TRACEBACK"%message)
+ # logs an exception - use in an except statement
+ def log_exc(self,message):
+ self.error("%s BEG TRACEBACK"%message+"\n"+traceback.format_exc().strip("\n"))
+ self.error("%s END TRACEBACK"%message)
-
-# for investigation purposes, can be placed anywhere
-def log_stack(message):
- to_log="".join(traceback.format_stack())
- logger.debug("%s BEG STACK"%message+"\n"+to_log)
- logger.debug("%s END STACK"%message)
+ def log_exc_critical(self,message):
+ self.critical("%s BEG TRACEBACK"%message+"\n"+traceback.format_exc().strip("\n"))
+ self.critical("%s END TRACEBACK"%message)
+ # for investigation purposes, can be placed anywhere
+ def log_stack(self,message):
+ to_log="".join(traceback.format_stack())
+ self.debug("%s BEG STACK"%message+"\n"+to_log)
+ self.debug("%s END STACK"%message)
+
+sfa_logger=SfaLogging(logfile='/var/log/sfa.log')
+sfa_import_logger=SfaLogging(logfile='/var/log/sfa_import.log')
+
+
+########################################
+import time
+
+def profile(callable):
+ """
+ Prints the runtime of the specified callable. Use as a decorator, e.g.,
+
+ @profile
+ def foo(...):
+ ...
+
+ Or, equivalently,
+
+ def foo(...):
+ ...
+ foo = profile(foo)
+
+ Or inline:
+
+ result = profile(foo)(...)
+ """
+
+ def wrapper(*args, **kwds):
+ start = time.time()
+ result = callable(*args, **kwds)
+ end = time.time()
+ args = map(str, args)
+ args += ["%s = %s" % (name, str(value)) for (name, value) in kwds.items()]
+ sfa_logger.debug("%s (%s): %.02f s" % (callable.__name__, ", ".join(args), end - start))
+ return result
+
+ return wrapper
+
+if __name__ == '__main__':
+ print 'testing sfalogging into logger.log'
+ global sfa_logger
+ sfa_logger=SfaLogging('logger.log')
+ sfa_logger.critical("logger.critical")
+ sfa_logger.error("logger.error")
+ sfa_logger.warning("logger.warning")
+ sfa_logger.info("logger.info")
+ sfa_logger.debug("logger.debug")
+ sfa_logger.setLevel(logging.DEBUG)
+ sfa_logger.debug("logger.debug again")
+
+ @profile
+ def sleep(seconds = 1):
+ time.sleep(seconds)
+ sleep(1)
from sfa.util.PostgreSQL import *
from sfa.trust.gid import *
from sfa.util.record import *
-from sfa.util.debug import *
from sfa.util.config import *
from sfa.util.filter import *
git://git.onelab.eu / sfa.git / commitdiff