Example #1
0
        public static bool LogSessionItem(string message, LogVerbosityLevel logLevel = LogVerbosityLevel.Info)
        {
            if (string.IsNullOrEmpty(message))
            {
                return(false);
            }

            if (logLevel >= VerbosityLevel)
            {
                message = string.Concat($"[{CoverageSettings.PackageName}] {message}");

                Console.WriteLine(message);
                return(true);
            }

            return(false);
        }
Example #2
0
        protected void PublishRunningTime(
            string sPooledConnectionID,
            LogVerbosityLevel nLogVerbosityLevel,
            string sSpName,
            string sArgsForLog,
            Guid guid,
            Stopwatch sw,
            long nPrevStopwatchValue = -1,
            string sMsg    = "completed",
            string sAuxMsg = ""
            )
        {
            long nCurStopwatchValue = sw.ElapsedMilliseconds;

            sAuxMsg = (sAuxMsg ?? string.Empty).Trim();
            if (sAuxMsg != string.Empty)
            {
                sAuxMsg = " " + sAuxMsg;
            }

            switch (nLogVerbosityLevel)
            {
            case LogVerbosityLevel.Compact:
                string sTime;

                if (nPrevStopwatchValue == -1)
                {
                    sTime = nCurStopwatchValue + "ms";
                }
                else
                {
                    sTime = nPrevStopwatchValue + "ms / " + (nCurStopwatchValue - nPrevStopwatchValue) + "ms";
                }

                Log.Debug("Query {0} in {1}{2} on connection {5}. Request: {3}{4}", sMsg, sTime, sAuxMsg, sSpName, sArgsForLog, sPooledConnectionID);
                break;

            case LogVerbosityLevel.Verbose:
                Log.Debug("Query {1} {2} in {0}ms{3} since query start on connection {4}.", nCurStopwatchValue, guid, sMsg, sAuxMsg, sPooledConnectionID);
                break;

            default:
                throw new ArgumentOutOfRangeException("nLogVerbosityLevel");
            }     // switch
        }         // PublishRunningTime
Example #3
0
        }         // Run

        protected virtual object RunOnce(
            ConnectionWrapper oConnectionToUse,
            Func <DbDataReader, bool, ActionResult> oAction,
            ExecMode nMode,
            DbCommand command,
            LogVerbosityLevel nLogVerbosityLevel,
            string spName,
            string sArgsForLog,
            Guid guid
            )
        {
            ConnectionWrapper oConnection = null;

            bool bAllesInOrdnung = true;

            bool bDropAfterUse = oConnectionToUse == null;

            try {
                oConnection = oConnectionToUse ?? TakeFromPool();

                if (oConnection == null)
                {
                    throw new NullReferenceException("There is no available connection to execute the query.");
                }

                command.Connection = oConnection.Connection;

                if (oConnection.Transaction != null)
                {
                    command.Transaction = oConnection.Transaction;
                }

                string sPooledConID = oConnection.Pooled.Name;

                var sw = new Stopwatch();
                sw.Start();

                switch (nMode)
                {
                case ExecMode.Scalar:
                    oConnection.Open();
                    object value = command.ExecuteScalar();
                    PublishRunningTime(sPooledConID, nLogVerbosityLevel, spName, sArgsForLog, guid, sw);
                    return(value);

                case ExecMode.Reader:
                    oConnection.Open();

                    var oReader = command.ExecuteReader();

                    long nPrevStopwatchValue = sw.ElapsedMilliseconds;

                    if (nLogVerbosityLevel == LogVerbosityLevel.Verbose)
                    {
                        PublishRunningTime(sPooledConID, nLogVerbosityLevel, spName, sArgsForLog, guid, sw);
                    }

                    var dataTable = new DataTable();
                    dataTable.Load(oReader);

                    string sMsg;

                    switch (nLogVerbosityLevel)
                    {
                    case LogVerbosityLevel.Compact:
                        sMsg = "completed and data loaded";
                        break;

                    case LogVerbosityLevel.Verbose:
                        sMsg = "data loaded";
                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                    }                     // switch

                    PublishRunningTime(sPooledConID, nLogVerbosityLevel, spName, sArgsForLog, guid, sw, nPrevStopwatchValue, sMsg);

                    oReader.Close();

                    return(dataTable);

                case ExecMode.NonQuery:
                    oConnection.Open();
                    int    nResult = command.ExecuteNonQuery();
                    string sResult = ((nResult == 0) || (nResult == -1)) ? "no" : nResult.ToString(CultureInfo.InvariantCulture);
                    PublishRunningTime(sPooledConID, nLogVerbosityLevel, spName, sArgsForLog, guid, sw, sAuxMsg: string.Format("- {0} row{1} changed", sResult, nResult == 1 ? "" : "s"));
                    return(nResult);

                case ExecMode.ForEachRow:
                    oConnection.Open();
                    command.ForEachRow(oAction, () => PublishRunningTime(sPooledConID, nLogVerbosityLevel, spName, sArgsForLog, guid, sw));
                    return(null);

                case ExecMode.Enumerable:
                    return(command.ExecuteEnumerable(
                               oConnection,
                               bDropAfterUse ? this : null,
                               () => PublishRunningTime(sPooledConID, nLogVerbosityLevel, spName, sArgsForLog, guid, sw)
                               ));

                default:
                    throw new ArgumentOutOfRangeException("nMode");
                }                 // switch
            } catch (Exception) {
                bAllesInOrdnung = false;
                throw;
            } finally {
                if (bDropAfterUse && (nMode != ExecMode.Enumerable))
                {
                    DisposeAfterOneUsage(bAllesInOrdnung, oConnection);
                }
            }     // try
        }         // RunOnce
Example #4
0
        }         // Run

        protected virtual object Run(
            ConnectionWrapper cw,
            Func <DbDataReader, bool, ActionResult> oAction,
            ExecMode nMode,
            CommandSpecies nSpecies,
            string spName,
            params QueryParameter[] aryParams
            )
        {
            if ((nMode == ExecMode.ForEachRow) && ReferenceEquals(oAction, null))
            {
                throw new DbException("Callback action not specified in 'ForEachRow' call.");
            }

            var oArgsForLog = new StringBuilder();

            LogVerbosityLevel nLogVerbosityLevel = LogVerbosityLevel;

            foreach (QueryParameter prm in aryParams)
            {
                oArgsForLog.Append(oArgsForLog.Length > 0 ? ", " : string.Empty).Append(prm);
            }

            string sArgsForLog = "(" + oArgsForLog + ")";

            Guid guid = Guid.NewGuid();

            if (nLogVerbosityLevel == LogVerbosityLevel.Verbose)
            {
                Log.Debug("Starting to run query:\n\tid = {0}\n\t{1}{2}", guid, spName, sArgsForLog);
            }

            SqlRetryer oRetryer = CreateRetryer();

            oRetryer.LogVerbosityLevel = this.LogVerbosityLevel;

            DbCommand oCmdToDispose = null;

            try {
                DbCommand cmd = BuildCommand(spName, nSpecies, aryParams);
                oCmdToDispose = cmd;

                object oResult = null;

                oRetryer.Retry(() =>
                               oResult = RunOnce(cw, oAction, nMode, cmd, nLogVerbosityLevel, spName, sArgsForLog, guid)
                               );  // Retry

                return(oResult);
            } catch (Exception e) {
                if (nLogVerbosityLevel == LogVerbosityLevel.Verbose)
                {
                    Log.Error(e, "Error while executing query {0}", guid);
                }
                else
                {
                    Log.Error(e, "Error while executing query:\n\tid = {0}\n\t{1}{2}", guid, spName, sArgsForLog);
                }

                throw;
            } finally {
                if (oCmdToDispose != null)
                {
                    oCmdToDispose.Dispose();

                    if (nLogVerbosityLevel == LogVerbosityLevel.Verbose)
                    {
                        Log.Debug("Command has been disposed.");
                    }
                } // if
            }     // try
        }         // Run