public void SafeDisposeTest()
{
StreamReader a = new StreamReader(@"C:\windows\explorer.exe");
DisposeHelper.SafeDispose(ref a);
Assert.AreEqual(null, a);
}
private void CleanUp()
{
// stop the service
DisposeHelper.SafeDispose(ref _server);
DisposeHelper.SafeDispose(ref _clientRef);
DisposeHelper.SafeDispose(ref _loggerRef);
}
protected override void OnStart(string[] args)
{
// start the service
ILogger svcLogger = new ServiceLogger(base.EventLog);
try
{
// - set current directory to the install location
// - get executable name for file logger
Environment.CurrentDirectory = AppDomain.CurrentDomain.BaseDirectory;
ProcessModule pm = Process.GetCurrentProcess().MainModule;
string moduleName = pm.ModuleName.Split('.')[0];
_loggerRef = Reference <ILogger> .Create(new MultiLogger(
svcLogger,
new FileLogger(@"C:\_qds\logs\" + moduleName + ".{dddd}.log")));
const EnvId env = EnvId.Dev_Development; // hack
var settings = new NamedValueSet(EnvHelper.GetAppSettings(env, EnvHelper.SvcPrefix(SvcId.CoreServer), true));
DisposeHelper.SafeDispose(ref _server);
_server = new CoreServer(_loggerRef, settings);
_server.Start();
}
catch (Exception ex)
{
svcLogger.Log(ex);
}
}
public void Dispose()
{
for (int i = 0; i < Clients.Length; i++)
{
DisposeHelper.SafeDispose(ref Clients[i]);
}
}
private void btnStart_Click(object sender, EventArgs e)
{
// (re)start the service
DisposeHelper.SafeDispose(ref _Server);
_Server = new ServiceHost(_Logger);
_Server.Start();
}
private void ProcessProfilerLog(string traceLocation)
{
string outputLogPath = Path.Combine(traceLocation, _sessionConfiguration.ProjectName + ".log");
var outputLogWriter = new StreamWriter(outputLogPath, false, Encoding.UTF8, 8192);
try
{
using (outputLogWriter)
{
string errorMessage;
StreamReader traceStreamReader = TryConnectToPort(DataPort, 8192, SocketConnectTimeout,
out errorMessage);
if (traceStreamReader == null)
{
throw new Exception(errorMessage);
}
try
{
DebugWriteToOutput($"Reading profiler trace log from port {DataPort}...");
ProcessProfilerLog(traceStreamReader, outputLogWriter);
}
finally
{
DisposeHelper.SafeDispose(ref traceStreamReader);
}
}
}
catch
{
try { File.Delete(outputLogPath); } catch { }
throw;
}
}
protected AbstractSession(SDBDeviceInfo device, TSessionConfiguration sessionConfiguration)
{
_selectedDevice = device;
var cap = new SDBCapability(_selectedDevice);
_tizenVersion = cap.GetValueByKey("platform_version");
if (!ProfilerPlugin.IsTizenVersionSupported(_tizenVersion, false))
{
throw new Exception($"Target platform version {_tizenVersion} is not supported");
}
_sdkToolPath = cap.GetValueByKey("sdk_toolpath");
_isSecureProtocol = cap.GetAvailabilityByKey("secure_protocol");
_sessionConfiguration = sessionConfiguration;
ProjectDirectory = _sessionConfiguration.ProjectHostPath;
DeviceName = _selectedDevice.Name;
_asyncErrorTask = Task.Run(() =>
{
try
{
_asyncErrorEvent.WaitOne();
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
DisposeHelper.SafeDispose(ref _asyncErrorEvent);
});
}
protected override void OnServerStopping()
{
// cleanup
DisposeHelper.SafeDispose(ref _hostConfigRuleSubs);
// stop all services
_logger.LogInfo("Stopping all servers...");
foreach (ServerFarmNode node in _serverFarmDict.GetValues())
{
try
{
if (node.Server != null)
{
_logger.LogInfo("Server: '{0}' stopping...", node.Key);
node.Server.Stop();
DisposeHelper.SafeDispose(ref node.Server);
DisposeHelper.SafeDispose(ref node.Logger);
_logger.LogInfo("Server: '{0}' stopped.", node.Key);
}
// publish result
PublishHostConfigResult(node, null);
}
catch (Exception e)
{
_logger.Log(e);
// publish result
PublishHostConfigResult(node, "Exception: " + e);
}
}
_logger.LogInfo("All servers stopped.");
}
private void btnStartManager_Click(object sender, EventArgs e)
{
DisposeHelper.SafeDispose(ref _Manager);
_Manager = new GridManagerServer();
_Manager.Logger = _ManagerLog;
_Manager.Client = _ClientRef;
_Manager.Start();
}
private void SetAddressBinding(string replyAddress, NodeType peerNodeType)
{
_peerNodeType = peerNodeType;
_peerAddressBinding = WcfHelper.CreateAddressBinding(
replyAddress, WcfConst.LimitMultiplier, WcfConst.ExpressMsgLifetime);
// dispose any existing client base
DisposeHelper.SafeDispose(ref _clientBase);
}
protected override void OnServerStopping()
{
DisposeHelper.SafeDispose(ref _timerRequestManager);
DisposeHelper.SafeDispose(ref _requestSubs);
DisposeHelper.SafeDispose(ref _resultSubs);
DisposeHelper.SafeDispose(ref _manageThreadQueue);
DisposeHelper.SafeDispose(ref _workerEventQueue);
}
private void btnStartWorkerB_Click(object sender, EventArgs e)
{
DisposeHelper.SafeDispose(ref _WorkerB);
_WorkerB = new GridWorkerServer();
_WorkerB.Logger = _WorkerBLog;
_WorkerB.Client = _ClientRef;
_WorkerB.HostInstance = "B";
_WorkerB.OtherSettings = new NamedValueSet(new NamedValue(GridWorkerServer.Setting.HandlerLimit, 2));
_WorkerB.Start();
}
protected override void OnServerStopping()
{
// stop housekeeping timer
DisposeHelper.SafeDispose(ref _HousekeepTimer);
// cleanup
DisposeHelper.SafeDispose(ref _WorkerAvailabilityCache);
DisposeHelper.SafeDispose(ref _UnassignedRequestsCache);
DisposeHelper.SafeDispose(ref _CancellationsCache);
DisposeHelper.SafeDispose(ref _ManagerResponseCache);
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
// clean up managed resources
DisposeHelper.SafeDispose(ref _streamWriter);
}
// no unmanaged resources to clean up
base.Dispose(disposing);
}
protected override void OnServerStopping()
{
DisposeHelper.SafeDispose(ref _TimerRequestScheduler);
DisposeHelper.SafeDispose(ref _TimerRequestManager);
DisposeHelper.SafeDispose(ref _RequestSubs);
DisposeHelper.SafeDispose(ref _ResultSubs);
DisposeHelper.SafeDispose(ref _ManageThreadQueue);
DisposeHelper.SafeDispose(ref _WorkerThreadQueue);
DisposeHelper.SafeDispose(ref _Workflow);
}
protected override void OnServerStopping()
{
// V2.2
DisposeHelper.SafeDispose(ref _discoServerHostV111);
DisposeHelper.SafeDispose(ref _sessCtrlV131ServerHost);
DisposeHelper.SafeDispose(ref _mrktDataV221ServerHost);
for (int i = 0; i < _providers.Length; i++)
{
DisposeHelper.SafeDispose(ref _providers[i]);
}
}
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
DisposeHelper.SafeDispose(ref _WorkerA);
DisposeHelper.SafeDispose(ref _WorkerB);
DisposeHelper.SafeDispose(ref _Manager);
DisposeHelper.SafeDispose(ref _AvailabilityCache);
DisposeHelper.SafeDispose(ref _ClientRef);
DisposeHelper.SafeDispose(ref _MainLog);
DisposeHelper.SafeDispose(ref _WorkerALog);
DisposeHelper.SafeDispose(ref _WorkerBLog);
DisposeHelper.SafeDispose(ref _ManagerLog);
}
private void CleanUp()
{
// dispose workers before routers
for (int i = 0; i < Workers.Length; i++)
{
DisposeHelper.SafeDispose(ref Workers[i]);
}
for (int i = 0; i < Routers.Length; i++)
{
DisposeHelper.SafeDispose(ref Routers[i]);
}
DisposeHelper.SafeDispose(ref _discoServerHost);
}
/// <summary>
/// Application end
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void ApplicationEnd(object sender, EventArgs e)
{
try
{
LoggerRef.Target.LogInfo("Stopped.");
DisposeHelper.SafeDispose(ref _client);
DisposeHelper.SafeDispose(ref _cache);
}
catch (Exception ex)
{
LoggerRef.Target.LogError(ex);
throw;
}
}
private void CloseLog()
{
lock (logLock)
{
if (log != null)
{
log.WriteLine("*** JIT series ***");
WriteClrJobItems(log, _jitSeriesValues);
log.WriteLine("*** GC series ***");
WriteClrJobItems(log, _gcSeriesValues);
DisposeHelper.SafeDispose(ref log);
}
}
}
public void Stop()
{
Logger.LogDebug("Stopping...");
DisposeHelper.SafeDispose(ref RuleSet);
try
{
OnStop();
}
catch (Exception e)
{
Logger.Log(e);
}
Logger.LogInfo("Stopped.");
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
// final housekeep cycle
DisposeHelper.SafeDispose(ref _housekeepTimer);
DispatchHousekeepTimeout(null);
_mainCommsDispatcher.WaitUntilEmpty(ServerCfg.ShutdownDisposeDelay);
// clean up managed resources
DisposeHelper.SafeDispose(ref _discoverV111ServerHost);
// V3.4 service hosts
DisposeHelper.SafeDispose(ref _sessCtrlV131ServerHost);
DisposeHelper.SafeDispose(ref _transferV341ServerHost);
}
// no unmanaged resources to clean up
base.Dispose(disposing);
}
protected override void OnServerStopping()
{
// stop housekeeping timer
DisposeHelper.SafeDispose(ref _HousekeepTimer);
// wait for worker threads to stop
WaitHelper.WaitFor(
TimeSpan.FromSeconds(30),
() => { return(Interlocked.Add(ref _HandlersExecuting, 0) <= 0); },
null,
TimeSpan.FromSeconds(5),
() => { Logger.LogDebug("Waiting for {0} request handlers to stop...", Interlocked.Add(ref _HandlersExecuting, 0)); });
// cleanup
DisposeHelper.SafeDispose(ref _AssignedRequestsCache);
DisposeHelper.SafeDispose(ref _CancellationsCache);
DisposeHelper.SafeDispose(ref _WorkerResponseCache);
DisposeHelper.SafeDispose(ref _EventQueue);
}
private void CloseOpenStreams()
{
if (_procLogStreamWriter != null)
{
DebugWriteToOutput("Finishing process log");
try
{
lock (_logFileLock)
{
DisposeHelper.SafeDispose(ref _procLogStreamWriter);
}
}
catch (Exception ex)
{
WriteToOutput($"Error closing process log. {ex.Message}");
}
}
}
private void CloseOpenStreams()
{
if (_resFileStream != null)
{
try
{
lock (_logFileLock)
{
DisposeHelper.SafeDispose(ref _resFileStream);
}
DebugWriteToOutput("Closed heaptrack data stream");
}
catch (Exception ex)
{
WriteToOutput($"[CloseOpenStreams] Error closing heaptrack data stream. {ex.Message}");
}
}
}
private void StartTheServer()
{
// start the service
// - reset
DisposeHelper.SafeDispose(ref _server);
// - config
var settings = new NamedValueSet();
if (chkChangePort.Checked)
{
settings.Set(WFPropName.Port, Int32.Parse(txtChangePort.Text));
}
_server = new WorkflowServer {
LoggerRef = _loggerRef, Client = _clientRef
};
// - start
_server.Start();
}
private void BackgroundTransfer(object state)
{
var job = (DataTransferJob)state;
_loggerRef.Target.LogDebug("Job commencing...");
try
{
BackupTools.TransferObjects(job, ref _cancelFlag);
}
finally
{
DisposeHelper.SafeDispose(ref job.SourceClient);
DisposeHelper.SafeDispose(ref job.SourceStream);
DisposeHelper.SafeDispose(ref job.TargetClient);
DisposeHelper.SafeDispose(ref job.TargetStream);
_loggerRef.Target.LogDebug("Job completed.");
}
}
private void ClearSession(bool hideScrollbar)
{
if (_session != null)
{
_session.RemoveListener(_sessionListener);
_session = null;
}
DisposeHelper.SafeDispose(ref _sysInfoProcessor);
DisposeHelper.SafeDispose(ref _eventsProcessor);
ViewPortMinValue = 0;
ViewPortMaxValue = ViewPortSize;
_chartValues.Clear();
_jitSeriesValues.Clear();
_jitEventProcessor.Clear();
_gcSeriesValues.Clear();
_gcEventProcessor.Clear();
LiveTimeline.AxisX[0].Sections.Clear();
LiveTimeline.AxisY[1].MaxValue = 1000;
LiveTimeline.Update(true, true);
_rangeMaxValue = ViewPortSize;
_sysInfoStartTimeSeconds = -1;
_profilingEventsDeltaSeconds = 0;
_sysInfoEventsDeltaSeconds = 0;
_areDeltasSet = false;
_previousSysInfo = null;
_previousChartData = null;
_currentPausedSection = null;
_currentDebugBreakSection = null;
UpdateScrollBar(hideScrollbar);
SessionControlButton.Visibility = Visibility.Collapsed;
SessionControlButton.IsEnabled = false;
_session = null;
}
private void EnsureFileIsOpen()
{
// replace date tokens in template with values
string proposedFilename = StringHelper.ReplaceDateTimeTokens(_templateFilename, DateTimeOffset.Now);
if (String.Compare(proposedFilename, _currentFilename, StringComparison.OrdinalIgnoreCase) != 0)
{
// filename new or changed
DisposeHelper.SafeDispose(ref _streamWriter);
// open the new stream
// - create directory if required
// - append only if first open
string dirName = Path.GetDirectoryName(proposedFilename);
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
_streamWriter = new StreamWriter(proposedFilename, (_currentFilename == null));
_currentFilename = proposedFilename;
}
}
private void CleanUp()
{
// stop the service
DisposeHelper.SafeDispose(ref _server);
}
