void CheckSession(object state)
{
try
{
CheckSession();
}
catch (WebServerException ex)
{
switch (ex.Error)
{
case WebError.AuthenticationRequired:
case WebError.SessionRequired:
{
UserSession session = Session;
session.Expiration = DateTime.UtcNow.AddSeconds(-1);
Session = session;
}
break;
}
}
catch (Exception ex)
{
Trace.TraceWarning("CheckSession error!\n{0}", ex);
}
if (Session.IsExpired())
{
timer?.Dispose();
timer = null;
OnSessionUpdated(new EventArgs());
}
}
public static Action Debounce(Action action, int delay)
{
System.Threading.Timer timer = null;
void callback(object o)
{
action();
timer?.Dispose();
timer = null;
}
System.Threading.Timer CreateTimer()
{
return(new System.Threading.Timer(
callback,
null,
delay,
System.Threading.Timeout.Infinite));
}
return(() =>
{
timer?.Dispose();
timer = CreateTimer();
});
}
public void Handle(object sender, T args)
{
_lastSender = sender;
_lastArgs = args;
_timer?.Dispose();
_timer = new System.Threading.Timer(TimerFired, null, _timeout, int.MaxValue);
}
protected override void OnStart(string[] args)
{
UpdateLog(@"服务启动");
if (args.Length == 5)
{
Domain = args[0];
RR = args[1];
accessKeyId = args[2];
accessKeySecret = args[3];
logPath = args[4];
}
threadTimer?.Dispose();
threadTimer = new System.Threading.Timer(Update, null, 0, 6 * minute);
}
public void Dispose()
{
#if !CONTRACTS_ONLY
if (!_IsDisposed)
{
#if SUPPORTS_APPDOMAIN
AppDomain.CurrentDomain.DomainUnload -= CurrentDomain_DomainUnload;
AppDomain.CurrentDomain.UnhandledException -= CurrentDomain_UnhandledException;
AppDomain.CurrentDomain.ProcessExit -= CurrentDomain_ProcessExit;
#endif
_IsDisposed = true;
_BufferTimeoutTimer?.Dispose();
_WriteBufferedEventsSignal?.Set();
WaitForBackgroundThreadToExit();
(_LogWriter as IDisposable)?.Dispose();
_WriteBufferedEventsSignal?.Dispose();
var emptySignal = _QueueEmptySignal;
_QueueEmptySignal = null;
emptySignal?.Dispose();
_LogEventPool?.Dispose();
}
#endif
}
private void FCrop_FormClosed(object sender, FormClosedEventArgs e)
{
workingImage.Dispose();
workingImage2.Dispose();
pictureBox.Image?.Dispose();
previewTimer?.Dispose();
}
public static void BuildSample(IAppBuilder app)
{
// add eventsource middleware
app.EventSource(envKey);
app.Run(context => {
// get the event stream (not captured yet)
var eventStream = context.Environment[envKey] as IEventStream;
// create some timers to send mesages
var timer = new System.Threading.Timer(_ => {
var ts = DateTime.UtcNow.ToString("O");
eventStream.WriteAsync("Timer1:" + ts + message + "\n");
}, null, 1, 50);
var timer2 = new System.Threading.Timer(_ => {
var ts = DateTime.UtcNow.ToString("O");
eventStream.WriteAsync("Timer 2:" + ts + "\n");
}, null, 1, 25);
// Capture the eventstream by calling Open and pass in the
// clean-up logic for when this client closes the stream
var task = eventStream.Open(() => {
Console.WriteLine("Closed");
timer.Dispose();
timer2.Dispose();
});
eventStream.WriteAsync("Started\n");
return task;
});
}
protected override void OnFormClosing(FormClosingEventArgs e)
{
try
{
_logMsgTimer?.Dispose();
_logMsgTimer = null;
_taskbarProgressTimer?.Dispose();
_taskbarProgressTimer = null;
if (_configuration.Layout.LogListViewColumnsWidths == null ||
_configuration.Layout.LogListViewColumnsWidths.Length != logListView.Columns.Count)
{
_configuration.Layout.LogListViewColumnsWidths = new int[logListView.Columns.Count];
}
for (var i = 0; i < logListView.Columns.Count; i++)
{
_configuration.Layout.LogListViewColumnsWidths[i] = logListView.Columns[i].Width;
}
_configuration.Layout.Set(_windowRestorer.WindowPosition, _windowRestorer.WindowState, logDetailPanel,
loggerPanel);
_configuration.Save();
_configuration.Close();
}
catch
{
// ignored
}
}
public void UnhookEvents()
{
context.OnHealthChange -= OnHealthChange;
context.OnBrokenCounterChange -= OnBrokenCounterChange;
visibilityTimer?.Dispose();
context = null;
}
public void UnhookEvents()
{
Context.OnHealthChange -= OnHealthChange;
Context.OnBrokenCounterChange -= OnBrokenCounterChange;
VisibilityTimer?.Dispose();
this.Context = null;
}
public virtual void Dispose()
{
StopSelfCheckThreadTimer();
StopTaskThreadTimer();
_selfCheckThreadTimer?.Dispose();
_taskThreadTimer?.Dispose();
}
public override void Stop()
{
base.Stop();
_currentVideoCapture?.Dispose();
_worker?.Dispose();
_isRunning = false;
SurrogateFramework.MainController.ProcessHandler.StartProcess(FrameworkConstants.ControllerProcessName);
}
public void UnhookEvents()
{
Context.OnBuildupChange -= OnBuildupChange;
Context.OnDurationChange -= OnDurationChange;
Context.OnCounterChange -= OnCounterChange;
VisibilityTimer?.Dispose();
Context = null;
}
private void ImageForm_FormClosed(object sender, FormClosedEventArgs e)
{
workingImage?.Dispose();
workingImage2?.Dispose();
PictureBox.Image?.Dispose();
previewTimer?.Dispose();
closed = true;
}
private void button1_Click(object sender, EventArgs e)
{
this.button1.Text = "A";
System.Threading.Timer t = new System.Threading.Timer((o) => { }, null, 0, 1000);
t.Dispose();
string a = "";
}
private void StopListen()
{
button1.Enabled = false;
TriggerRun_MenuItem.Enabled = false;
threadTimer?.Dispose();
UpdateLog(@"已停止...");
ID_Box.Enabled = true;
Secret_Box.Enabled = true;
Domain_Box.Enabled = true;
RR_Box.Enabled = true;
button1.Text = @"Start";
TriggerRun_MenuItem.Text = @"Start";
button1.Enabled = true;
TriggerRun_MenuItem.Enabled = true;
}
private void CommonInitialize()
{
// Create map
Map = new Map();
// Create timer for invalidating the control
_invalidateTimer?.Dispose();
_invalidateTimer = new System.Threading.Timer(InvalidateTimerCallback, null, System.Threading.Timeout.Infinite, 16);
// Start the invalidation timer
StartUpdates(false);
}
/*
* Suspend the timer interrupt handling.
*/
static void Timer_InterruptSuspend()
{
s_timer?.Change(Timeout.Infinite, Timeout.Infinite);
s_timer?.Dispose();
s_timer = null;
//if (s_timerThread != IntPtr.Zero) Kernel32.DeleteTimerQueueTimer(Kernel32.TimerQueueHandle.NULL, s_timerThread, Kernel32.SafeEventHandle.Null);
//s_timerThread = IntPtr.Zero;
}
public static Task Delay(int milliseconds)
{
#if NET_4_0
var tcs = new TaskCompletionSource<int>();
var timer = new System.Threading.Timer(_ => tcs.SetResult(0), null, milliseconds, System.Threading.Timeout.Infinite);
return tcs.Task.ContinueWith(t => timer.Dispose(), TaskScheduler.Default);
#else
return Task.Delay(milliseconds);
#endif
}
public void Dispose()
{
if (disposed)
{
return;
}
Closed -= OnClosed;
_timeoutTimer?.Dispose();
disposed = true;
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing)
{
components?.Dispose();
_screenShareServer?.Dispose();
_fpsUpdateTimer?.Dispose();
}
base.Dispose(disposing);
}
public MainWindow()
{
InitializeComponent();
Loaded += MainWindow_Loaded;
Unloaded += (sender, e) =>
{
_timer?.Dispose();
};
}
private bool disposed = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
timer?.Dispose();
}
disposed = true;
}
}
private void Callback(object state)
{
ProxyState proxyState = ChangeContextMenuStripItemsByProxyState();
if (proxyState != _proxySwitcher.RequiredProxyState)
{
_proxySwitcher.Switch(_proxySwitcher.RequiredProxyState);
ChangeContextMenuStripItemsByProxyState();
}
if (_stopwatch.IsRunning && _stopwatch.Elapsed >= TimeSpan.FromMinutes(1))
{
_timer?.Dispose();
_timer = null;
_stopwatch.Stop();
}
}
public void Stop()
{
if (_poll != null)
{
_poll.Dispose();
_poll = null;
}
_dispatcher.Invoke(() =>
{
if (_status.Status == ServerStatusEnum.Processing)
{
_status.Status = ServerStatusEnum.Stopping;
}
else
{
_status.Status = ServerStatusEnum.Stopped;
}
});
}
/// <summary>
/// Set Timer based on timespan parameter
/// </summary>
/// <param name="ts"></param>
static Boolean setAlarm(TimeSpan ts)
{
log.Debug("setting alarm with timespan: " + ts + "which has " + ts.TotalHours + " of total hours and " + ts.TotalMinutes + " of total minutes");
if (timer != null)
{
timer.Dispose();
}
if (ts.Seconds <= 0)
{
sendNotification("Y u no send me proper alarm time?");
return(false);
}
else
{
timer = new System.Threading.Timer(new System.Threading.TimerCallback(ringAlarm), null, ts, TimeSpan.FromHours(24));
sendNotification("Settings set successfully");
return(true);
}
}
private void DoScavenge(object notUsed)
{
if (this.State == Osrs.Runtime.RunState.Running)
{
try
{
prov.DeleteExpired();
}
catch { }
}
else if (scavengeTimer != null)
{
try
{
scavengeTimer.Change(System.Threading.Timeout.Infinite, 60000); //just to be safe here
scavengeTimer.Dispose();
}
catch { }
}
}
public void Stop()
{
// Wait for timer queue to be emptied, before we continue
// (Timer threads should have left the callback method given)
// - http://woowaabob.blogspot.dk/2010/05/properly-disposing-systemthreadingtimer.html
// - http://blogs.msdn.com/b/danielvl/archive/2011/02/18/disposing-system-threading-timer.aspx
lock (_threadLock)
{
if (_timer != null)
{
WaitHandle waitHandle = new AutoResetEvent(false);
if (_timer.Dispose(waitHandle))
{
// Timer has not been disposed by someone else
WaitHandle.WaitAll(new[] { waitHandle }, TimeSpan.FromMinutes(2));
_timer = null;
}
}
}
}
public static void Shutdown()
{
try
{
if (!PersistentData.Instance.Telemetry)
{
return;
}
_heartbeatTimer?.Dispose();
Log.Debug("Telemetry heartbeat stopped.");
CollectEvent("app", "stop", sessionControl: "end");
}
catch (Exception ex)
{
#if DEBUG
Log.Exception(ex);
#endif
}
}
/// <summary>
/// Stop connection to Ge.tt Live.
/// </summary>
public void Stop()
{
if (_webSocket != null)
{
lock (_watchDogSyncRoot)
{
if (_watchDog != null)
{
_watchDog.Dispose();
_watchDog = null;
}
}
_webSocket.OnOpen -= WebSocket_OnOpen;
_webSocket.OnClose -= WebSocket_OnClose;
_webSocket.OnError -= WebSocket_OnError;
_webSocket.OnMessage -= WebSocket_OnMessage;
_webSocket.Close();
}
}
/// <summary>
/// Reports the end of the process/time period to measure.
/// </summary>
public void Stop(bool report = true)
{
if (_memoryUsageTimer != null)
{ // only dispose and stop when there IS a timer.
_memoryUsageTimer.Change(System.Threading.Timeout.Infinite, System.Threading.Timeout.Infinite);
_memoryUsageTimer.Dispose();
}
if (_ticks.HasValue)
{
lock (_memoryUsageLog)
{
var seconds = new TimeSpan(DateTime.Now.Ticks - _ticks.Value - _memoryUsageLoggingDuration).TotalMilliseconds / 1000.0;
//GC.Collect();
var p = Process.GetCurrentProcess();
var memoryDiff = System.Math.Round((p.PrivateMemorySize64 - _memory.Value) / 1024.0 / 1024.0, 4);
if (_memoryUsageLog.Count > 0)
{ // there was memory usage logging.
double max = _memoryUsageLog.Max();
if (report)
{
Itinero.Logging.Logger.Log("PF:" + _name, Itinero.Logging.TraceEventType.Information,
string.Format("Ended at at {0}, spent {1}s and {2}MB of memory diff with {3}MB max used.",
new DateTime(_ticks.Value).ToShortTimeString(),
seconds, memoryDiff, max));
}
}
else
{ // no memory usage logged.
if (report)
{
Itinero.Logging.Logger.Log("PF:" + _name, Itinero.Logging.TraceEventType.Information,
string.Format("Ended at at {0}, spent {1}s and {2}MB of memory diff.",
new DateTime(_ticks.Value).ToShortTimeString(),
seconds, memoryDiff));
}
}
}
}
}
protected virtual void Dispose(bool disposing)
{
if (disposed)
{
return;
}
if (disposing)
{
if (_sqlConn.State == ConnectionState.Open)
{
_sqlConn.Close();
}
if (_internalsqlConn != null && _internalsqlConn.State == ConnectionState.Open)
{
_internalsqlConn.Close();
}
PropertyChanged = null;
_cmd.Dispose();
_sqlConn.Dispose();
if (_internalCmd != null)
{
_internalCmd.Dispose();
}
if (_internalsqlConn != null)
{
_internalsqlConn.Dispose();
}
if (_checkDBTrhead != null)
{
_checkDBTrhead.Dispose();
}
}
// Free any unmanaged objects here.
//
disposed = true;
}
private void ToInitialize()
{
if (!mInitialized)
{
mReceiveDispatchCenter = new Dispatchs.DispatchCenter <SocketAsyncEventArgsX>(ProcessReceiveArgs, Options.IOQueues);
int maxBufferSize;
if (Options.BufferPoolMaxMemory == 0)
{
Options.BufferPoolMaxMemory = 500;
}
maxBufferSize = (int)(((long)Options.BufferPoolMaxMemory * 1024 * 1024) / Options.BufferSize / Options.BufferPoolGroups);
if (maxBufferSize < Options.BufferPoolSize)
{
maxBufferSize = Options.BufferPoolSize;
}
mReceiveBufferPoolGroup = new BufferPoolGroup(Options.BufferSize, Options.BufferPoolSize, maxBufferSize, Options.BufferPoolGroups);
mSendBufferPoolGroup = new BufferPoolGroup(Options.BufferSize, Options.BufferPoolSize, maxBufferSize, Options.BufferPoolGroups);
mSessions = new ConcurrentDictionary <long, ISession>();
mInitialized = true;
mAcceptDispatcher = new Dispatchs.DispatchCenter <AcceptSocketInfo>(AcceptProcess, Math.Min(Environment.ProcessorCount, 16));
if (Options.SessionTimeOut > 0)
{
if (Options.SessionTimeOut * 1000 < mTimeOutCheckTime)
{
mTimeOutCheckTime = Options.SessionTimeOut * 1000;
}
else
{
mTimeOutCheckTime = Options.SessionTimeOut * 1000;
}
if (mDetectionTimer != null)
{
mDetectionTimer.Dispose();
}
mDetectionTimer = new System.Threading.Timer(OnDetectionHandler, null,
mTimeOutCheckTime, mTimeOutCheckTime);
Log(LogType.Info, null, "detection sessions timeout with {0}s", Options.SessionTimeOut);
}
}
}
int RunMinimizeTest()
{
stateCount =-1;
time1 = 0;
time2 = 0;
System.Threading.Timer timer = new System.Threading.Timer(KillTest, null, 1000, 1000);
System.Threading.ThreadStart test = new System.Threading.ThreadStart(RunMinimize);
currTest = new System.Threading.Thread(test);
currTest.Start();
while (stateCount == -1)
{
System.Threading.Thread.Sleep(50);
}
timer.Dispose();
return stateCount;
}
private static void Wait()
{
Int32 intProcessWaitInMins = 1;
if (System.Configuration.ConfigurationManager.AppSettings["ProcessWaitInMins"] != null)
intProcessWaitInMins = Int32.TryParse(System.Configuration.ConfigurationManager.AppSettings["ProcessWaitInMins"].ToString(), out intProcessWaitInMins) ? intProcessWaitInMins : 1;
WriteProcessToMonitor("Waiting " + intProcessWaitInMins.ToString("#,##0") + "Mins for next process...");
// Create a Timer object that knows to call our TimerCallback
// method once every 2000 milliseconds.
iTmrCtr = 0;
System.Threading.Timer t = new System.Threading.Timer(TimerCallback, null, 0, 2000);
System.Threading.Thread.Sleep(60000 * intProcessWaitInMins);
t.Dispose(); // Cancel the timer now
Console.WriteLine();
}
public static void RealMain(string[] args)
{
//If we are on Windows, append the bundled "win-tools" programs to the search path
//We add it last, to allow the user to override with other versions
if (!Library.Utility.Utility.IsClientLinux)
{
Environment.SetEnvironmentVariable("PATH",
Environment.GetEnvironmentVariable("PATH") +
System.IO.Path.PathSeparator.ToString() +
System.IO.Path.Combine(
System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location),
"win-tools")
);
}
//If this executable is invoked directly, write to console, otherwise throw exceptions
bool writeConsole = System.Reflection.Assembly.GetEntryAssembly() == System.Reflection.Assembly.GetExecutingAssembly();
//If we are on windows we encrypt the database by default
//We do not encrypt on Linux as most distros use a SQLite library without encryption support,
//Linux users can use an encrypted home folder, or install a SQLite library with encryption support
if (!Library.Utility.Utility.IsClientLinux && string.IsNullOrEmpty(Environment.GetEnvironmentVariable(DB_KEY_ENV_NAME)))
{
//Note that the password here is a default password and public knowledge
//
//The purpose of this is to prevent casual read of the database, as well
// as protect from harddisk string scans, not to protect from determined
// attacks.
//
//If you desire better security, start Duplicati once with the commandline option
// --unencrypted-database to decrypt the database.
//Then set the environment variable DUPLICATI_DB_KEY to the desired key,
// and run Duplicati again without the --unencrypted-database option
// to re-encrypt it with the new key
//
//If you change the key, please note that you need to supply the same
// key when restoring the setup, as the setup being backed up will
// be encrypted as well.
Environment.SetEnvironmentVariable(DB_KEY_ENV_NAME, Library.AutoUpdater.AutoUpdateSettings.AppName + "_Key_42");
}
//Find commandline options here for handling special startup cases
Dictionary<string, string> commandlineOptions = Duplicati.Library.Utility.CommandLineParser.ExtractOptions(new List<string>(args));
foreach(string s in args)
if (
s.Equals("help", StringComparison.InvariantCultureIgnoreCase) ||
s.Equals("/help", StringComparison.InvariantCultureIgnoreCase) ||
s.Equals("usage", StringComparison.InvariantCultureIgnoreCase) ||
s.Equals("/usage", StringComparison.InvariantCultureIgnoreCase))
commandlineOptions["help"] = "";
//If the commandline issues --help, just stop here
if (commandlineOptions.ContainsKey("help"))
{
if (writeConsole)
{
Console.WriteLine(Strings.Program.HelpDisplayDialog);
foreach(Library.Interface.ICommandLineArgument arg in SupportedCommands)
Console.WriteLine(Strings.Program.HelpDisplayFormat(arg.Name, arg.LongDescription));
return;
}
else
{
throw new Exception("Server invoked with --help");
}
}
#if DEBUG
//Log various information in the logfile
if (!commandlineOptions.ContainsKey("log-file"))
{
commandlineOptions["log-file"] = System.IO.Path.Combine(StartupPath, "Duplicati.debug.log");
commandlineOptions["log-level"] = Duplicati.Library.Logging.LogMessageType.Profiling.ToString();
}
#endif
// Allow override of the environment variables from the commandline
if (commandlineOptions.ContainsKey("server-datafolder"))
Environment.SetEnvironmentVariable(DATAFOLDER_ENV_NAME, commandlineOptions["server-datafolder"]);
if (commandlineOptions.ContainsKey("server-encryption-key"))
Environment.SetEnvironmentVariable(DB_KEY_ENV_NAME, commandlineOptions["server-encryption-key"]);
//Set the %DUPLICATI_HOME% env variable, if it is not already set
if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable(DATAFOLDER_ENV_NAME)))
{
#if DEBUG
//debug mode uses a lock file located in the app folder
Environment.SetEnvironmentVariable(DATAFOLDER_ENV_NAME, StartupPath);
#else
bool portableMode = commandlineOptions.ContainsKey("portable-mode") ? Library.Utility.Utility.ParseBool(commandlineOptions["portable-mode"], true) : false;
if (portableMode)
{
//Portable mode uses a data folder in the application home dir
Environment.SetEnvironmentVariable(DATAFOLDER_ENV_NAME, System.IO.Path.Combine(StartupPath, "data"));
}
else
{
//Normal release mode uses the systems "Application Data" folder
Environment.SetEnvironmentVariable(DATAFOLDER_ENV_NAME, System.IO.Path.Combine(System.Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), Library.AutoUpdater.AutoUpdateSettings.AppName));
}
#endif
}
try
{
try
{
//This will also create Program.DATAFOLDER if it does not exist
Instance = new SingleInstance(Duplicati.Library.AutoUpdater.AutoUpdateSettings.AppName, Program.DATAFOLDER);
}
catch (Exception ex)
{
if (writeConsole)
{
Console.WriteLine(Strings.Program.StartupFailure(ex));
return;
}
else
{
throw new Exception(Strings.Program.StartupFailure(ex));
}
}
if (!Instance.IsFirstInstance)
{
if (writeConsole)
{
Console.WriteLine(Strings.Program.AnotherInstanceDetected);
return;
}
else
{
throw new SingleInstance.MultipleInstanceException(Strings.Program.AnotherInstanceDetected);
}
}
// Setup the log redirect
Duplicati.Library.Logging.Log.CurrentLog = Program.LogHandler;
if (commandlineOptions.ContainsKey("log-file"))
{
if (System.IO.File.Exists(commandlineOptions["log-file"]))
System.IO.File.Delete(commandlineOptions["log-file"]);
var loglevel = Duplicati.Library.Logging.LogMessageType.Error;
if (commandlineOptions.ContainsKey("log-level"))
Enum.TryParse<Duplicati.Library.Logging.LogMessageType>(commandlineOptions["log-level"], true, out loglevel);
Program.LogHandler.SetServerFile(commandlineOptions["log-file"], loglevel);
}
Version sqliteVersion = new Version((string)Duplicati.Library.SQLiteHelper.SQLiteLoader.SQLiteConnectionType.GetProperty("SQLiteVersion").GetValue(null, null));
if (sqliteVersion < new Version(3, 6, 3))
{
if (writeConsole)
{
//The official Mono SQLite provider is also broken with less than 3.6.3
Console.WriteLine(Strings.Program.WrongSQLiteVersion(sqliteVersion, "3.6.3"));
return;
}
else
{
throw new Exception(Strings.Program.WrongSQLiteVersion(sqliteVersion, "3.6.3"));
}
}
//Create the connection instance
System.Data.IDbConnection con = (System.Data.IDbConnection)Activator.CreateInstance(Duplicati.Library.SQLiteHelper.SQLiteLoader.SQLiteConnectionType);
try
{
DatabasePath = System.IO.Path.Combine(Program.DATAFOLDER, "Duplicati-server.sqlite");
if (!System.IO.Directory.Exists(System.IO.Path.GetDirectoryName(DatabasePath)))
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(DatabasePath));
#if DEBUG
//Default is to not use encryption for debugging
Program.UseDatabaseEncryption = commandlineOptions.ContainsKey("unencrypted-database") ? !Library.Utility.Utility.ParseBool(commandlineOptions["unencrypted-database"], true) : false;
#else
Program.UseDatabaseEncryption = commandlineOptions.ContainsKey("unencrypted-database") ? !Library.Utility.Utility.ParseBool(commandlineOptions["unencrypted-database"], true) : true;
#endif
con.ConnectionString = "Data Source=" + DatabasePath;
//Attempt to open the database, handling any encryption present
OpenDatabase(con);
Duplicati.Library.SQLiteHelper.DatabaseUpgrader.UpgradeDatabase(con, DatabasePath, typeof(Duplicati.Server.Database.Connection));
}
catch (Exception ex)
{
//Unwrap the reflection exceptions
if (ex is System.Reflection.TargetInvocationException && ex.InnerException != null)
ex = ex.InnerException;
if (writeConsole)
{
Console.WriteLine(Strings.Program.DatabaseOpenError(ex.Message));
return;
}
else
{
throw new Exception(Strings.Program.DatabaseOpenError(ex.Message), ex);
}
}
DataConnection = new Duplicati.Server.Database.Connection(con);
if (!DataConnection.ApplicationSettings.FixedInvalidBackupId)
DataConnection.FixInvalidBackupId();
if (commandlineOptions.ContainsKey("webservice-password"))
Program.DataConnection.ApplicationSettings.SetWebserverPassword(commandlineOptions["webservice-password"]);
ApplicationExitEvent = new System.Threading.ManualResetEvent(false);
Duplicati.Library.AutoUpdater.UpdaterManager.OnError += (Exception obj) =>
{
Program.DataConnection.LogError(null, "Error in updater", obj);
};
UpdatePoller = new UpdatePollThread();
DateTime lastPurge = new DateTime(0);
System.Threading.TimerCallback purgeTempFilesCallback = (x) => {
try
{
if (Math.Abs((DateTime.Now - lastPurge).TotalHours) < 23)
return;
lastPurge = DateTime.Now;
foreach(var e in Program.DataConnection.GetTempFiles().Where((f) => f.Expires < DateTime.Now))
{
try
{
if (System.IO.File.Exists(e.Path))
System.IO.File.Delete(e.Path);
}
catch (Exception ex)
{
Program.DataConnection.LogError(null, string.Format("Failed to delete temp file: {0}", e.Path), ex);
}
Program.DataConnection.DeleteTempFile(e.ID);
}
Duplicati.Library.Utility.TempFile.RemoveOldApplicationTempFiles((path, ex) => {
Program.DataConnection.LogError(null, string.Format("Failed to delete temp file: {0}", path), ex);
});
string pts;
if (!commandlineOptions.TryGetValue("log-retention", out pts))
pts = DEFAULT_LOG_RETENTION;
Program.DataConnection.PurgeLogData(Library.Utility.Timeparser.ParseTimeInterval(pts, DateTime.Now, true));
}
catch (Exception ex)
{
Program.DataConnection.LogError(null, "Failed during temp file cleanup", ex);
}
};
try
{
PurgeTempFilesTimer = new System.Threading.Timer(purgeTempFilesCallback, null, TimeSpan.FromHours(1), TimeSpan.FromDays(1));
}
catch (ArgumentOutOfRangeException)
{
//Bugfix for older Mono, slightly more resources used to avoid large values in the period field
PurgeTempFilesTimer = new System.Threading.Timer(purgeTempFilesCallback, null, TimeSpan.FromHours(1), TimeSpan.FromHours(1));
}
LiveControl = new LiveControls(DataConnection.ApplicationSettings);
LiveControl.StateChanged += new EventHandler(LiveControl_StateChanged);
LiveControl.ThreadPriorityChanged += new EventHandler(LiveControl_ThreadPriorityChanged);
LiveControl.ThrottleSpeedChanged += new EventHandler(LiveControl_ThrottleSpeedChanged);
Program.WorkThread = new Duplicati.Library.Utility.WorkerThread<Runner.IRunnerData>((x) =>
{
Runner.Run(x, true);
}, LiveControl.State == LiveControls.LiveControlState.Paused);
Program.Scheduler = new Scheduler(WorkThread);
Program.WorkThread.StartingWork += (worker, task) => { SignalNewEvent(null, null); };
Program.WorkThread.CompletedWork += (worker, task) => { SignalNewEvent(null, null); };
Program.WorkThread.WorkQueueChanged += (worker) => { SignalNewEvent(null, null); };
Program.Scheduler.NewSchedule += new EventHandler(SignalNewEvent);
Program.WorkThread.OnError += (worker, task, exception) => { Program.DataConnection.LogError(task == null ? null : task.BackupID, "Error in worker", exception); };
Action<long, Exception> registerTaskResult = (id, ex) => {
lock(Program.MainLock) {
// If the new results says it crashed, we store that instead of success
if (Program.TaskResultCache.Count > 0 && Program.TaskResultCache.Last().Key == id)
{
if (ex != null && Program.TaskResultCache.Last().Value == null)
Program.TaskResultCache.RemoveAt(Program.TaskResultCache.Count - 1);
else
return;
}
Program.TaskResultCache.Add(new KeyValuePair<long, Exception>(id, ex));
while(Program.TaskResultCache.Count > MAX_TASK_RESULT_CACHE_SIZE)
Program.TaskResultCache.RemoveAt(0);
}
};
Program.WorkThread.CompletedWork += (worker, task) => { registerTaskResult(task.TaskID, null); };
Program.WorkThread.OnError += (worker, task, exception) => { registerTaskResult(task.TaskID, exception); };
Program.WebServer = new WebServer.Server(commandlineOptions);
if (Program.WebServer.Port != DataConnection.ApplicationSettings.LastWebserverPort)
ServerPortChanged = true;
DataConnection.ApplicationSettings.LastWebserverPort = Program.WebServer.Port;
if (Library.Utility.Utility.ParseBoolOption(commandlineOptions, "ping-pong-keepalive"))
{
Program.PingPongThread = new System.Threading.Thread(PingPongMethod);
Program.PingPongThread.IsBackground = true;
Program.PingPongThread.Start();
}
ServerStartedEvent.Set();
ApplicationExitEvent.WaitOne();
}
catch (SingleInstance.MultipleInstanceException mex)
{
System.Diagnostics.Trace.WriteLine(Strings.Program.SeriousError(mex.ToString()));
if (writeConsole)
Console.WriteLine(Strings.Program.SeriousError(mex.ToString()));
else
throw mex;
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(Strings.Program.SeriousError(ex.ToString()));
if (writeConsole)
Console.WriteLine(Strings.Program.SeriousError(ex.ToString()));
else
throw new Exception(Strings.Program.SeriousError(ex.ToString()), ex);
}
finally
{
StatusEventNotifyer.SignalNewEvent();
if (UpdatePoller != null)
UpdatePoller.Terminate();
if (Scheduler != null)
Scheduler.Terminate(true);
if (WorkThread != null)
WorkThread.Terminate(true);
if (Instance != null)
Instance.Dispose();
if (PurgeTempFilesTimer != null)
PurgeTempFilesTimer.Dispose();
if (PingPongThread != null)
try { PingPongThread.Abort(); }
catch { }
if (LogHandler != null)
LogHandler.Dispose();
}
}
/// <summary>
/// Restart plex, wait for the specified delay between stop and start
/// </summary>
/// <param name="msDelay">The amount of time in ms to wait before starting after stop</param>
internal void Restart(int delay)
{
Stop();
State = PlexState.Pending;
System.Threading.AutoResetEvent autoEvent = new System.Threading.AutoResetEvent(false);
System.Threading.Timer t = new System.Threading.Timer((x) => { Start(); autoEvent.Set(); }, null, delay, System.Threading.Timeout.Infinite);
autoEvent.WaitOne();
t.Dispose();
}
/// <summary>
/// This event fires when the plex process we have a reference to exits
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void plex_Exited(object sender, EventArgs e)
{
OnPlexStatusChange(this, new StatusChangeEventArgs("Plex Media Server has stopped!"));
//unsubscribe
_plex.Exited -= plex_Exited;
//kill the supporting processes.
killSupportingProcesses();
if (_plex != null)
{
_plex.Dispose();
_plex = null;
}
//restart as required
Settings settings = SettingsHandler.Load();
if (State != PlexState.Stopping && settings.AutoRestart)
{
OnPlexStatusChange(this, new StatusChangeEventArgs(string.Format("Waiting {0} seconds before re-starting the Plex process.", settings.RestartDelay)));
State = PlexState.Pending;
System.Threading.AutoResetEvent autoEvent = new System.Threading.AutoResetEvent(false);
System.Threading.Timer t = new System.Threading.Timer((x) => { Start(); autoEvent.Set(); }, null, settings.RestartDelay * 1000, System.Threading.Timeout.Infinite);
autoEvent.WaitOne();
t.Dispose();
}
else
{
//set the status
State = PlexState.Stopped;
}
}
/// <summary>
/// This event fires when the process we have a refrence to exits
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void auxProcess_Exited(object sender, EventArgs e)
{
if (_aux.KeepAlive)
{
OnStatusChange(this, new StatusChangeEventArgs(_aux.Name + " has stopped!"));
//unsubscribe
_auxProcess.Exited -= auxProcess_Exited;
end();
//restart as required
if (!_stopping)
{
OnStatusChange(this, new StatusChangeEventArgs("Re-starting " + _aux.Name));
//wait some seconds first
System.Threading.AutoResetEvent autoEvent = new System.Threading.AutoResetEvent(false);
System.Threading.Timer t = new System.Threading.Timer((x) => { start(); autoEvent.Set(); }, null, 5000, System.Threading.Timeout.Infinite);
autoEvent.WaitOne();
t.Dispose();
}
else
{
OnStatusChange(this, new StatusChangeEventArgs(_aux.Name + " stopped"));
Running = false;
}
}
else
{
OnStatusChange(this, new StatusChangeEventArgs(_aux.Name + " has completed"));
//unsubscribe
_auxProcess.Exited -= this.auxProcess_Exited;
_auxProcess.Dispose();
Running = false;
}
}
public static void Main(string[] args)
{
EventWithCallback ec = new EventWithCallback();
for (int i = 0; i < 500; i++)
{
System.Threading.Thread t = new System.Threading.Thread(new System.Threading.ThreadStart(() =>
{
ec.Wait(String.Format("world. From Thread {0:X}", System.Threading.Thread.CurrentThread.GetHashCode()));
}));
t.Start();
}
var timer = new System.Threading.Timer(new System.Threading.TimerCallback(timercb), ec, 0, 2000);
Console.ReadLine();
timer.Dispose();
}
private TempFileManager()
{
// set up timer to periodically remove expired entries
_timer = new Timer(TimerCallback, null, SweepInterval, SweepInterval);
// also remove all entries when the desktop is shutdown
// (it isn't nice to have this dependency here, but seems to be no other easy way to do this)
Desktop.Application.Quitting +=
(sender, args) =>
{
_timer.Dispose();
Clean(obj => true);
};
}
