def execute(self, _sql, _args=None, **_kwargs):
"""Wrap the execute so that unhandled exceptions are handled."""
if _args is None:
_args = _kwargs
try:
if self.connection.logSql \
and cx_Logging.Debug("SQL\n%s", _sql or self.statement):
if isinstance(_args, dict):
_output = [(k, v) for k, v in _args.items() \
if not k.endswith("_")]
_output.sort()
else:
_output = enumerate(_args)
_output = [" %s => %r" % (n, v) for n, v in _output]
if _output:
cx_Logging.Debug("BIND VARIABLES\n%s", "\n".join(_output))
return cx_Oracle.Cursor.execute(self, _sql, _args)
except:
exc = self.connection.ExceptionHandler(*sys.exc_info())
exc.details.append("SQL: %s" % _sql or self.statement)
exc.details.append("Bind Variables:")
if isinstance(_args, dict):
_output = [(k, v) for k, v in _args.items() \
if not k.endswith("_")]
_output.sort()
else:
_output = enumerate(_args)
for name, value in _output:
exc.details.append(" %s -> %r" % (name, value))
raise exc
def UpdateRow(self, cache, externalRow, contextItem=None):
row = self._FindRow(externalRow)
if row is None:
cx_Logging.Debug("%s: creating new row with source as %s",
self.name, externalRow)
row = self.rowClass.New()
self._CopyAttrs(row, externalRow, contextItem)
self.OnLoadRow(cache, row)
if not self.loadAllRowsOnFirstLoad:
for path in self.paths:
if isinstance(path, MultipleRowPath):
key = path.GetKeyValue(row)
path.rows.setdefault(key, []).append(row)
if self.allRowsLoaded:
self.allRows.append(row)
else:
cx_Logging.Debug("%s: modifying row %s", self.name, row)
beforeKeyValues = []
for path in self.singleRowPaths:
beforeKeyValues.append((path, path.GetKeyValue(row)))
self._CopyAttrs(row, externalRow, contextItem)
for path, beforeKeyValue in beforeKeyValues:
afterKeyValue = path.GetKeyValue(row)
if afterKeyValue != beforeKeyValue:
del path.rows[beforeKeyValue]
path.rows[afterKeyValue] = row
method = getattr(self, self.setExtraAttrValuesMethodName, None)
if method is not None:
method(cache, row)
def Run(threadNum):
cx_Logging.Debug("Thread-%d: starting", threadNum)
iterationsLeft = numIterations
while iterationsLeft > 0:
numFiles = len(os.listdir("."))
cx_Logging.Debug("Thread-%d: counted %d files, %d iterations left",
threadNum, numFiles, iterationsLeft)
iterationsLeft -= 1
def __exit__(self, excType, excValue, excTraceback):
if excValue is None:
cx_Logging.Debug("transaction succeeded, committing")
self.dataSource.commit()
else:
cx_Logging.Debug("transaction failed, rolling back")
self.dataSource.rollback()
return super(TransactionContext,
self).__exit__(excType, excValue, excTraceback)
def __ShouldTrace(self, fileName):
cx_Logging.Debug("should trace code from file %s?", fileName)
fileName, ext = os.path.splitext(fileName)
if os.path.isabs(fileName):
for path in sys.path:
if fileName.startswith(path + os.sep):
fileName = fileName[len(path) + 1:]
moduleName = fileName.split(os.sep)[0]
domain = self.traceManager.modules.get(moduleName)
trace = (domain in self.domains)
cx_Logging.Debug(" tracing for module %s is %s", moduleName, trace)
return trace
def OnGenerateReceipts(self):
with ceGUI.BusyCursorContext(self):
cx_Logging.Debug("generating receipts for year %s",
self.config.year)
yearRow = Models.Years.GetRow(self.config.dataSource,
year=self.config.year)
origReceiptDict = self.__GetOriginalReceipts()
cx_Logging.Debug("%s original receipts", len(origReceiptDict))
maxReceiptNum = self.__GetNextReceiptNum()
cx_Logging.Debug("max receipt number is %s", maxReceiptNum)
donatedAmounts = self.__GetDonatedAmounts()
cx_Logging.Debug("%s donations to receipt", len(donatedAmounts))
receiptsCanceled = receiptsUpdated = receiptsCreated = 0
cursor = self.config.dataSource.connection.cursor()
for donatorId, amount in donatedAmounts:
origReceipt = origReceiptDict.get(donatorId)
if origReceipt is not None and origReceipt.amount == amount:
continue
if yearRow.receiptsIssued and origReceipt is not None:
receiptsCanceled += 1
cursor.execute(
"""
update TaxReceipts set
Canceled = 't'
where ReceiptNumber = ?""",
origReceipt.receiptNumber)
if not yearRow.receiptsIssued and origReceipt is not None:
receiptsUpdated += 1
cursor.execute(
"""
update TaxReceipts set
Amount = ?
where ReceiptNumber = ?""", amount,
origReceipt.receiptNumber)
else:
receiptsCreated += 1
maxReceiptNum += 1
cursor.execute(
"""
insert into TaxReceipts
(ReceiptNumber, Year, DonatorId, Amount, Canceled,
DateIssued, IsDuplicate)
values (?, ?, ?, ?, 'f', ?, 'f')""", maxReceiptNum,
yearRow.year, donatorId, amount, datetime.date.today())
cursor.connection.commit()
message = "%d canceled. %d updated. %d created." % \
(receiptsCanceled, receiptsUpdated, receiptsCreated)
wx.MessageBox(message, "Receipt Generation Results",
wx.OK | wx.ICON_INFORMATION, self)
if receiptsCanceled or receiptsUpdated or receiptsCreated:
self.config.GetCachedRows(self.dataSet.rowClass, refresh=True)
self.Retrieve()
def run(self):
cx_Logging.Debug("stdout=%r", sys.stdout)
sys.stdout = open(os.path.join(self.directory, "stdout.log"), "a")
sys.stderr = open(os.path.join(self.directory, "stderr.log"), "a")
app.run(host="0.0.0.0")
self.stopRequestedEvent.wait()
self.stopEvent.set()
def ExecuteOSCommands(*commands):
"""Execute OS commands, raising an error if any return errors."""
for command in commands:
cx_Logging.Debug("executing command %s", command)
exitCode = os.system(command)
if exitCode != 0:
raise CommandExecutionFailed(command=command, exitCode=exitCode)
def SetEnvironment(self):
cx_Logging.Debug("setting environment for %s", self)
os.environ["ORACLE_SID"] = self.sid
os.environ["ORACLE_HOME"] = self.oracleHome
self.__PrependPathEnvVar("PATH", self.binDir)
if sys.platform != "win32":
self.__PrependPathEnvVar("LD_LIBRARY_PATH", self.libDir)
def AddRow(self, cache, key1, key2):
cx_Logging.Debug("%s: adding xref between %s and %s", self.name, key1,
key2)
path1, path2 = self.paths
if key1 in path1.rows:
path1.rows[key1].append(key2)
if key2 in path2.rows:
path2.rows[key2].append(key1)
def RemoveRow(self, cache, key1, key2):
cx_Logging.Debug("%s: removing xref between %s and %s", self.name,
key1, key2)
path1, path2 = self.paths
if key1 in path1.rows:
path1.rows[key1].remove(key2)
if key2 in path2.rows:
path2.rows[key2].remove(key1)
def LoadAllRows(self, cache):
if self.tracePathLoads:
cx_Logging.Debug("%s: loading all rows", self.name)
rows = self.GetAllRowsFromDataSource(cache)
self.OnLoadRows(cache, rows)
self.allRows = rows
self.allRowsLoaded = True
return self.allRows
def _GenerateMethod(cls, targetClass, methodName, methodLines, *args):
actualArgs = ("self", ) + args
codeString = "def %s(%s):\n %s" % \
(methodName, ", ".join(actualArgs), "\n ".join(methodLines))
cx_Logging.Debug("%s: GENERATED CODE\n%s", cls.name, codeString)
code = compile(codeString, "SubCacheGeneratedCode.py", "exec")
temp = {}
exec(code, dict(), temp)
setattr(targetClass, methodName, temp[methodName])
def executemany(self, _sql, _args):
try:
if self.connection.logSql \
and cx_Logging.Debug("SQL\n%s", _sql or self.statement):
_output = [" %s" % (r, ) for r in _args]
cx_Logging.Debug("ROWS (%s):\n%s", len(_output),
"\n".join(_output))
return cx_Oracle.Cursor.executemany(self, _sql, _args)
except:
exc = self.connection.ExceptionHandler(*sys.exc_info())
exc.details.append("SQL: %s" % _sql or self.statement)
if self.rowcount > -1 and self.rowcount < len(_args):
exc.details.append("FAILED ROW: %s" % (_args[self.rowcount], ))
exc.details.append("ROWS (%s, %s before error):" % \
(len(_args), self.rowcount))
for row in _args:
exc.details.append(" %s" % (row, ))
raise exc
def Enable(connection, pipeName=None):
"""Enable debugging messages on the given pipe."""
cursor = connection.cursor()
if pipeName is None:
pipeName = cursor.callfunc("dbms_pipe.unique_session_name",
cx_Oracle.STRING)
cursor.callproc("pkg_Debug.Enable", (pipeName, ))
cx_Logging.Debug("logging messages to pipe %s", pipeName)
return pipeName
def LogMessages(connection, pipeName):
"""Log messages using the cx_Logging module."""
cx_Logging.Debug("logging messages from pipe %s", pipeName)
debugConnection = cx_Oracle.Connection(connection.username,
connection.password,
connection.tnsentry,
threaded=True)
for message in MessageGenerator(debugConnection, pipeName):
cx_Logging.Trace("%s", message)
def run(self):
cx_Logging.Debug("stdout=%r", sys.stdout)
sys.stdout = open(os.path.join(self.directory, "stdout.log"), "a")
sys.stderr = open(os.path.join(self.directory, "stderr.log"), "a")
#sys.stdout = open(os.path.join("C:\\Data\\logs\\", "stdout.log"), "a")
#sys.stderr = open(os.path.join("C:\\Data\\logs\\", "stderr.log"), "a")
app.run(host="127.0.0.1",port=5123)
self.stopRequestedEvent.wait()
self.stopEvent.set()
def SetValue(self, handle, attrName, value):
row = self.rows[handle]
origValue = getattr(row, attrName)
if value != origValue:
self.MarkAsChanged(handle)
row = self.rows[handle]
cx_Logging.Debug("setting attr %s on row %s to %r (from %r)",
attrName, handle, value, origValue)
self._OnSetValue(row, attrName, value, origValue)
setattr(row, attrName, value)
def GetValue(self, key, defaultValue=None):
"""Return a value from the database, returning the default value
if a value cannot be found and destroying invalid values if
any are found."""
key = "%s.%s" % (self.baseName, key)
try:
value = self.database[key]
except KeyError:
cx_Logging.Debug("no value for key %s, default value is %s",
key, defaultValue)
return defaultValue
try:
value = eval(value)
except:
del self.database[key]
cx_Logging.Debug("bad value for key %s, default value is %s",
key, defaultValue)
return defaultValue
cx_Logging.Debug("value for key %s is %r", key, value)
return value
def Update(self):
if not self.PendingChanges():
cx_Logging.Debug("no update to perform")
return
self._PreUpdate()
transaction = self.dataSource.BeginTransaction()
self._Update(transaction)
self.dataSource.CommitTransaction(transaction)
self._GetPrimaryKeyValues(transaction)
self.ClearChanges()
self._PostUpdate()
def GetValue(self, key, defaultValue=None):
"""Return a value from the registry, returning the default value
if a value cannot be found and destroying invalid values if
any are found."""
try:
value, type = win32api.RegQueryValueEx(self.key, key)
except:
cx_Logging.Debug(
"Getting default for session key %s\\%s. Value=\"%s\"",
self.baseName, key, defaultValue)
return defaultValue
try:
returnValue = eval(str(value))
cx_Logging.Debug("Getting session key %s\\%s. Value=\"%s\"",
self.baseName, key, returnValue)
return returnValue
except:
win32api.RegDeleteValue(self.key, key)
cx_Logging.Debug(
"Getting default for session key %s\\%s. Value=\"%s\"",
self.baseName, key, defaultValue)
return defaultValue
def ExecuteForDatabase(self, database):
cx_Logging.Debug("executing program for database %s", database)
database.SetEnvironment()
os.environ[ENV_NAME] = "Y"
os.environ["START_MODE"] = database.startMode
if sys.platform == "win32":
executable = '"%s"' % sys.executable
else:
executable = sys.executable
returnCode = os.spawnv(os.P_WAIT, sys.executable,
[executable] + sys.argv[1:])
if returnCode != 0:
sys.exit(1)
def Load(self, cache, pathName, *args):
if self.tracePathLoads:
cx_Logging.Debug("%s: loading rows by path %s with args %s",
self.name, pathName, args)
path = self.pathsByName[pathName]
actualArgs = []
for attrName, value in zip(path.retrievalAttrNames, args):
if isinstance(value, ceDatabase.Row):
value = getattr(value, attrName)
actualArgs.append(value)
actualArgs = tuple(actualArgs)
if self.loadAllRowsOnFirstLoad:
if not self.allRowsLoaded:
self.LoadAllRows(cache)
return path.GetCachedValue(actualArgs)
return path.Load(cache, self, *actualArgs)
def AddModule(self, module, domain = None):
"""Add a module to the list of modules to trace. If the domain is
specified, then it will be added to the domain regardless of
whether or not a domain is specified in the module itself; otherwise
the module will be searched for the above domains and only added to
the list if the correct attribute is specified."""
if domain is None:
domain = getattr(module, STATIC_DOMAIN_ATTR, None)
if domain is not None:
origDomain = self.modules.get(module.__name__)
self.modules[module.__name__] = domain
if origDomain is not None and domain != origDomain:
cx_Logging.Warning("swapping domain for %s from %s to %s",
module.__name__, origDomain, domain)
else:
cx_Logging.Debug("adding %s to domain %s",
module.__name__, domain)
dynamicDomains = getattr(module, DYNAMIC_DOMAIN_ATTR, [])
for domain in dynamicDomains:
self.dynamicDomains[domain] = None
from flask import Flask
from app import create_app
import os
import sys
import cx_Logging
app = create_app('default')
cx_Logging.Debug("stdout=%r", sys.stdout)
sys.stdout = open(os.path.join("C:\\Data\\logs\\", "stdout_console.log"), "a")
sys.stderr = open(os.path.join("C:\\Data\\logs\\", "stderr_console.log"), "a")
cx_Logging.StartLogging(os.path.join("C:\\Data\\logs\\", "teste_console.log"), cx_Logging.DEBUG)
if __name__ == "__main__":
app.run(host="127.0.0.1",port=5123)
def run(self):
cx_Logging.Debug('Starting kukur.exe')
self.process = subprocess.Popen(['kukur.exe'], cwd=self.directory)
self.process.wait()
self.stopRequestedEvent.wait()
self.stopEvent.set()
def stop(self):
if self.process:
cx_Logging.Debug('Stopping kukur.exe')
self.process.kill()
self.stopRequestedEvent.set()
self.stopEvent.wait()
def RemoveRow(self, cache, externalRow):
row = self._FindRow(externalRow, errorIfMissing=True)
cx_Logging.Debug("%s: removing row %s", self.name, row)
self.OnRemoveRow(cache, row)
if self.allRowsLoaded:
self.allRows.remove(row)
def SetValue(self, key, value):
"""Set the value in the database."""
key = "%s.%s" % (self.baseName, key)
self.database[key] = repr(value)
cx_Logging.Debug("setting value for key %s to %r", key, value)
def SetValue(self, key, value):
"""Set the value in the registry."""
cx_Logging.Debug("Setting Session key %s\\%s=\"%s\"",
self.baseName, key, repr(value))
win32api.RegSetValueEx(self.key, key, 0, win32con.REG_SZ,
repr(value))
