/*
* private void Processing()
* {
* TimeSpan ts;
* while (null != _th && IsRunning &&
* !ApplicationManager.Instance.IsExit)
* {
* ts = DateTime.Now - _lastUpdate;
* if (ts.TotalMilliseconds > _timeout)
* {
* UpdateConfig();
* _lastUpdate = DateTime.Now;
* }
* }
* Shutdown();
* }
*/
/*
* private void UpdateConfig()
* {
* lock (this)
* {
* MethodBase med = MethodBase.GetCurrentMethod();
* try
* {
* var oldCfg = _plazaCfg;
* if (!NJson.ConfigExists(_fileName))
* {
* _plazaCfg = null;
* }
* else
* {
* _plazaCfg = NJson.LoadFromFile<PlazaConfig>(_fileName);
* if (null != oldCfg)
* {
* // some thing error
* }
* }
*
* // save back to file.
* if (null == _plazaCfg)
* {
* Console.WriteLine("Config create new.");
* _plazaCfg = (null != oldCfg ) ? oldCfg : new PlazaConfig();
* NJson.SaveToFile(_plazaCfg, _fileName);
* // Raise event.
* ConfigChanged.Call(this, EventArgs.Empty);
* }
* else
* {
* if (!_plazaCfg.IsEquals(oldCfg))
* {
* Console.WriteLine("Config changed by external.");
* NJson.SaveToFile(_plazaCfg, _fileName);
* // Raise event.
* ConfigChanged.Call(this, EventArgs.Empty);
* }
* else
* {
* Console.WriteLine("Config not changed.");
* }
* }
* }
* catch (Exception ex)
* {
* med.Err(ex);
* }
* }
* }
*/
#endregion
#region Public Methods
/*
* /// <summary>
* /// Start Service.
* /// </summary>
* public void Start()
* {
* if (null == _th)
* {
* _th = new Thread(Processing);
* _th.Priority = ThreadPriority.BelowNormal;
* _th.Name = "DMT Config Manager Thread";
* _th.IsBackground = true;
* IsRunning = true;
* _th.Start();
* }
* }
* /// <summary>
* /// Shutdown Service.
* /// </summary>
* public void Shutdown()
* {
* IsRunning = false;
* if (null != _th)
* {
* try { _th.Abort(); }
* catch (ThreadAbortException) { }
* }
* _th = null;
* }
*/
/// <summary>
/// Load Config from file.
/// </summary>
public void LoadConfig()
{
lock (this)
{
MethodBase med = MethodBase.GetCurrentMethod();
try
{
// save back to file.
if (!NJson.ConfigExists(_fileName))
{
if (null == _plazaCfg)
{
_plazaCfg = new PlazaConfig();
}
NJson.SaveToFile(_plazaCfg, _fileName);
}
else
{
// Check When file is exists but size is zero so config is null.
_plazaCfg = NJson.LoadFromFile <PlazaConfig>(_fileName);
}
// Raise event.
ConfigChanged.Call(this, EventArgs.Empty);
}
catch (Exception ex)
{
med.Err(ex);
}
}
}
protected void FireConfigChange(ConfigChangeEventArgs changeEventCopy)
{
if (ConfigChanged != null)
{
foreach (var @delegate in ConfigChanged.GetInvocationList())
{
var handlerCopy = (ConfigChangeEvent)@delegate;
ExecutorService.StartNew(() =>
{
string methodName;
if (handlerCopy.Target == null)
{
methodName = handlerCopy.Method.Name;
}
else
{
methodName = $"{handlerCopy.Target.GetType()}.{handlerCopy.Method.Name}";
}
try
{
handlerCopy(this, changeEventCopy);
}
catch (Exception ex)
{
Logger.Error($"Failed to invoke config change handler {methodName}", ex);
}
});
}
}
}
public async Task SaveHotkeyConfig(HotkeyConfig newConfig)
{
_config.hotkey = newConfig;
await SaveConfig(_config);
ConfigChanged?.Invoke(this, new EventArgs());
}
public void SaveHotkeyConfig(HotkeyConfig newConfig)
{
_config.hotkey = newConfig;
SaveConfig(_config);
ConfigChanged?.Invoke(this, new EventArgs());
}
public void Process()
{
foreach (var newMap in _configQueue.GetConsumingEnumerable())
{
try
{
var isUpdate = false;
var stored = _configs.AddOrUpdate(newMap.Name, newMap, (key, oldMap) =>
{
if (newMap.Equals(oldMap))
{
return(oldMap);
}
isUpdate = true;
return(newMap.Rev > oldMap.Rev ? newMap : oldMap);
});
if (isUpdate)
{
if (stored.Rev > newMap.Rev)
{
ConfigChanged?.Invoke(newMap, new BucketConfigEventArgs(stored));
}
}
else
{
ConfigChanged?.Invoke(newMap, new BucketConfigEventArgs(stored));
}
}
catch (Exception e)
{
}
}
}
public void ToggleSecureLocalPac(bool enabled)
{
_config.secureLocalPac = enabled;
SaveConfig(_config);
ConfigChanged?.Invoke(this, new EventArgs());
}
public void ToggleCheckingUpdate(bool enabled)
{
_config.autoCheckUpdate = enabled;
Configuration.Save(_config);
ConfigChanged?.Invoke(this, new EventArgs());
}
public void SavePACUrl(string pacUrl)
{
_config.pacUrl = pacUrl;
SaveConfig(_config);
ConfigChanged?.Invoke(this, new EventArgs());
}
public void Process()
{
foreach (var newMap in _configQueue.GetConsumingEnumerable())
{
try
{
var isNewOrUpdate = false;
var stored = _configs.AddOrUpdate(newMap.Name, key =>
{
isNewOrUpdate = true;
return(newMap);
},
(key, map) =>
{
if (newMap.Equals(map))
{
return(map);
}
isNewOrUpdate = true;
return(newMap.Rev > map.Rev ? newMap : map);
});
if (isNewOrUpdate)
{
ConfigChanged?.Invoke(this, new BucketConfigEventArgs(stored));
}
}
catch (Exception e)
{
Logger.LogWarning(e, "Error processing new clusterOptions");
}
}
}
protected void FireConfigChange(ConfigChangeEventArgs changeEvent)
{
if (ConfigChanged != null)
{
foreach (ConfigChangeEvent handler in ConfigChanged.GetInvocationList())
{
m_executorService.QueueWorkItem((handlerCopy, changeEventCopy) =>
{
string methodName;
if (handlerCopy.Target == null)
{
methodName = handlerCopy.Method.Name;
}
else
{
methodName = string.Format("{0}.{1}", handlerCopy.Target.GetType(), handlerCopy.Method.Name);
}
try
{
handlerCopy(this, changeEventCopy);
}
catch (Exception ex)
{
logger.Error(string.Format("Failed to invoke config change handler {0}", methodName), ex);
}
}, handler, changeEvent);
}
}
}
protected virtual void OnConfigChanged()
{
if (ConfigChanged != null)
{
ConfigChanged.Invoke(this, new EventArgs());
}
}
void classExpanded(string ns, string className)
{
Debug.WriteLine(">>! class expanded");
_config.classExpanded(ns, className);
ConfigChanged.raise();
_scheduler.schedule();
}
public void UseOnlinePAC(bool useOnlinePac)
{
_config.useOnlinePac = useOnlinePac;
SaveConfig(_config);
ConfigChanged?.Invoke(this, new EventArgs());
}
public void SaveLogViewerConfig(LogViewerConfig newConfig)
{
_config.logViewer = newConfig;
newConfig.SaveSize();
Configuration.Save(_config);
ConfigChanged?.Invoke(this, new EventArgs());
}
public static void InvokeNotify(NotifyEventType eventType, INotifyEventArgs args)
{
switch (eventType)
{
case NotifyEventType.ConfigChanged:
ConfigChanged? .Invoke(args as ConfigEventArgs);
break;
case NotifyEventType.MousePointDataBind:
MousePositionDataBind? .Invoke(args as MousePointEventArgs);
break;
case NotifyEventType.ScreenCaptureDataBInd:
ScreenCaptureDataBind? .Invoke(args as CaptureEventArgs);
break;
case NotifyEventType.TreeItemOrderChanged:
TreeItemOrderChanged? .Invoke(args as EventTriggerOrderChangedEventArgs);
break;
case NotifyEventType.SelctTreeViewItemChanged:
SelectTreeViewChanged? .Invoke(args as SelctTreeViewItemChangedEventArgs);
break;
case NotifyEventType.EventTriggerOrderChanged:
EventTriggerOrderChanged? .Invoke(args as EventTriggerOrderChangedEventArgs);
break;
case NotifyEventType.EventTriggerInserted:
EventTriggerInserted?.Invoke(args as EventTriggerEventArgs);
break;
case NotifyEventType.EventTriggerRemoved:
EventTriggerRemoved?.Invoke(args as EventTriggerEventArgs);
break;
case NotifyEventType.Save:
SaveEventTriggerModel?.Invoke(args as SaveEventTriggerModelArgs);
break;
case NotifyEventType.Delete:
DeleteEventTriggerModel?.Invoke(args as DeleteEventTriggerModelArgs);
break;
case NotifyEventType.ComboProcessChanged:
ComboProcessChanged?.Invoke(args as ComboProcessChangedEventArgs);
break;
case NotifyEventType.TreeGridViewFocus:
TreeGridViewFocus?.Invoke(args as TreeGridViewFocusEventArgs);
break;
}
}
public ConfigThreadState(BucketConfig bucketConfig, ConfigChanged configChangedDelegate,
ErrorOccurred errorOccurredDelegate, CancellationToken cancellationToken)
{
_bucketConfig = bucketConfig;
_configChangedDelegate += configChangedDelegate;
_errorOccurredDelegate += errorOccurredDelegate;
_cancellationToken = cancellationToken;
}
public async Task ToggleCheckingUpdate(bool enabled)
{
_config.autoCheckUpdate = enabled;
await Task.Delay(100);
Configuration.Save(_config);
ConfigChanged?.Invoke(this, new EventArgs());
}
public ConfigThreadState(BucketConfig bucketConfig, ConfigChanged configChangedDelegate,
ErrorOccurred errorOccurredDelegate, CancellationToken cancellationToken)
{
_bucketConfig = bucketConfig;
_configChangedDelegate += configChangedDelegate;
_errorOccurredDelegate += errorOccurredDelegate;
_cancellationToken = cancellationToken;
}
public void Reload()
{
StopPortMap();
// some logic in configuration updated the config when saving, we need to read it again
Global.GuiConfig = MergeGetConfiguration(Global.GuiConfig);
Global.GuiConfig.FlushPortMapCache();
Logging.SaveToFile = Global.GuiConfig.LogEnable;
Logging.OpenLogFile();
ReloadProxyRule();
if (_privoxyRunner == null)
{
_privoxyRunner = new HttpProxyRunner();
}
ReloadPacServer();
if (_gfwListUpdater == null)
{
_gfwListUpdater = new GfwListUpdater();
_gfwListUpdater.UpdateCompleted += (o, args) => UpdatePACFromGFWListCompleted?.Invoke(o, args);
_gfwListUpdater.Error += (o, args) => UpdatePACFromGFWListError?.Invoke(o, args);
}
_listener?.Stop();
_privoxyRunner.Stop();
// don't put privoxyRunner.Start() before pacServer.Stop()
// or bind will fail when switching bind address from 0.0.0.0 to 127.0.0.1
// though UseShellExecute is set to true now
// http://stackoverflow.com/questions/10235093/socket-doesnt-close-after-application-exits-if-a-launched-process-is-open
try
{
_privoxyRunner.Start(Global.GuiConfig);
var local = new Local(Global.GuiConfig, _transfer, _chnRangeSet);
var services = new List <Listener.IService>
{
local,
_pacServer,
new HttpPortForwarder(_privoxyRunner.RunningPort, Global.GuiConfig)
};
_listener = new Listener(services);
_listener.Start(Global.GuiConfig, 0);
}
catch (Exception e)
{
ThrowSocketException(ref e);
Logging.LogUsefulException(e);
ReportError(e);
}
LoadPortMap();
Application.Current.Dispatcher?.InvokeAsync(() => { ConfigChanged?.Invoke(this, new EventArgs()); });
UpdateSystemProxy();
Utils.ReleaseMemory();
}
private int FireEvents(HashSet <EventType> events)
{
int eventsProcessed = 0;
if (events.Contains(EventType.ConfigChanged))
{
//Logger.Trace("ConfigChanged");
ConfigChanged?.Invoke();
eventsProcessed++;
}
if (events.Contains(EventType.HeadChanged))
{
//Logger.Trace("HeadChanged");
HeadChanged?.Invoke();
eventsProcessed++;
}
if (events.Contains(EventType.LocalBranchesChanged))
{
//Logger.Trace("LocalBranchesChanged");
LocalBranchesChanged?.Invoke();
eventsProcessed++;
}
if (events.Contains(EventType.RemoteBranchesChanged))
{
//Logger.Trace("RemoteBranchesChanged");
RemoteBranchesChanged?.Invoke();
eventsProcessed++;
}
if (events.Contains(EventType.IndexChanged))
{
if (!events.Contains(EventType.RepositoryChanged))
{
//Logger.Trace("IndexChanged");
IndexChanged?.Invoke();
eventsProcessed++;
}
}
if (events.Contains(EventType.RepositoryChanged))
{
//Logger.Trace("RepositoryChanged");
RepositoryChanged?.Invoke();
eventsProcessed++;
}
if (events.Contains(EventType.RepositoryCommitted))
{
//Logger.Trace("RepositoryCommitted");
RepositoryCommitted?.Invoke();
eventsProcessed++;
}
return(eventsProcessed);
}
void editwnd_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
WndEditScheduleAction editwnd = (WndEditScheduleAction)sender;
//parse schedule and update view
_schedules[editwnd.ScheduleId] = editwnd.Schedule;
LoadScheduleView();
ConfigChanged.Invoke(this, new EventArgs()); //invoke parent update
}
public void Reset()
{
HeadChanged.Reset();
ConfigChanged.Reset();
RepositoryCommitted.Reset();
IndexChanged.Reset();
RepositoryChanged.Reset();
LocalBranchesChanged.Reset();
RemoteBranchesChanged.Reset();
}
private int FireEvents(Dictionary <EventType, List <EventData> > events)
{
int eventsProcessed = 0;
if (events.ContainsKey(EventType.ConfigChanged))
{
Logger.Trace("ConfigChanged");
ConfigChanged?.Invoke();
eventsProcessed++;
}
if (events.ContainsKey(EventType.HeadChanged))
{
Logger.Trace("HeadChanged");
HeadChanged?.Invoke();
eventsProcessed++;
}
if (events.ContainsKey(EventType.LocalBranchesChanged))
{
Logger.Trace("LocalBranchesChanged");
LocalBranchesChanged?.Invoke();
eventsProcessed++;
}
if (events.ContainsKey(EventType.RemoteBranchesChanged))
{
Logger.Trace("RemoteBranchesChanged");
RemoteBranchesChanged?.Invoke();
eventsProcessed++;
}
if (events.ContainsKey(EventType.IndexChanged))
{
Logger.Trace("IndexChanged");
IndexChanged?.Invoke();
eventsProcessed++;
}
if (events.ContainsKey(EventType.RepositoryChanged))
{
Logger.Trace("RepositoryChanged");
RepositoryChanged?.Invoke();
eventsProcessed++;
}
if (events.ContainsKey(EventType.RepositoryCommitted))
{
Logger.Trace("RepositoryCommitted");
RepositoryCommitted?.Invoke();
eventsProcessed++;
}
return(eventsProcessed);
}
protected void FireConfigChange(ConfigChangeEventArgs changeEvent)
{
if (ConfigChanged != null)
{
foreach (ConfigChangeEvent handler in ConfigChanged.GetInvocationList())
{
//加入线程池执行
ThreadPool.QueueUserWorkItem(state => handler.Invoke(this, changeEvent));
}
}
}
private void FileSystemWatcherOnChanged(object sender, FileSystemEventArgs e)
{
_fileSystemWatcher.EnableRaisingEvents = false;
var configContents = File.ReadAllText(e.FullPath);
var config = JsonSerializer.Deserialize <T>(configContents);
ConfigChanged?.Invoke(config);
_fileSystemWatcher.EnableRaisingEvents = true;
}
protected void Reload()
{
Encryption.RNG.Reload();
// some logic in configuration updated the config when saving, we need to read it again
_config = Configuration.Load();
NLogConfig.LoadConfiguration();
privoxyRunner = privoxyRunner ?? new PrivoxyRunner();
_pacDaemon = _pacDaemon ?? new PACDaemon();
_pacDaemon.PACFileChanged += PacDaemon_PACFileChanged;
_pacDaemon.UserRuleFileChanged += PacDaemon_UserRuleFileChanged;
_pacServer = _pacServer ?? new PACServer(_pacDaemon);
_pacServer.UpdatePACURL(_config); // So PACServer works when system proxy disabled.
gfwListUpdater = gfwListUpdater ?? new GFWListUpdater();
gfwListUpdater.UpdateCompleted += PacServer_PACUpdateCompleted;
gfwListUpdater.Error += PacServer_PACUpdateError;
// don't put PrivoxyRunner.Start() before pacServer.Stop()
// or bind will fail when switching bind address from 0.0.0.0 to 127.0.0.1
// though UseShellExecute is set to true now
// http://stackoverflow.com/questions/10235093/socket-doesnt-close-after-application-exits-if-a-launched-process-is-open
privoxyRunner.Stop();
_pacServer.Stop();
try
{
privoxyRunner.Start(this, _config);
_pacServer.Start(_config);
}
catch (Exception e)
{
// translate Microsoft language into human language
// i.e. An attempt was made to access a socket in a way forbidden by its access permissions => Port already in use
if (e is SocketException se)
{
if (se.SocketErrorCode == SocketError.AddressAlreadyInUse)
{
e = new Exception(I18N.GetString("Port {0} already in use", _config.localPort), e);
}
else if (se.SocketErrorCode == SocketError.AccessDenied)
{
e = new Exception(I18N.GetString("Port {0} is reserved by system", _config.localPort), e);
}
}
logger.LogUsefulException(e);
ReportError(e);
}
ConfigChanged?.Invoke(this, new EventArgs());
UpdateSystemProxy();
Utils.ReleaseMemory(true);
}
public void Dispose()
{
_configQueue?.Dispose();
TokenSource?.Dispose();
if (ConfigChanged == null)
{
return;
}
foreach (var subscriber in ConfigChanged.GetInvocationList())
{
ConfigChanged -= (BucketConfigHandler)subscriber;
}
}
public void SaveConfig(Configuration config)
{
Configuration.Save(config);
this._config = config;
if (config.isDefault)
{
config.isDefault = false;
}
if (ConfigChanged != null)
{
ConfigChanged.Invoke(this, new EventArgs());
}
}
private int FireEvents(HashSet <EventType> events)
{
int eventsProcessed = 0;
if (events.Contains(EventType.ConfigChanged))
{
ConfigChanged?.Invoke();
eventsProcessed++;
}
if (events.Contains(EventType.HeadChanged))
{
HeadChanged?.Invoke();
eventsProcessed++;
}
if (events.Contains(EventType.LocalBranchesChanged))
{
LocalBranchesChanged?.Invoke();
eventsProcessed++;
}
if (events.Contains(EventType.RemoteBranchesChanged))
{
RemoteBranchesChanged?.Invoke();
eventsProcessed++;
}
if (events.Contains(EventType.IndexChanged))
{
if (!events.Contains(EventType.RepositoryChanged))
{
IndexChanged?.Invoke();
eventsProcessed++;
}
}
if (events.Contains(EventType.RepositoryChanged))
{
RepositoryChanged?.Invoke();
eventsProcessed++;
}
if (events.Contains(EventType.RepositoryCommitted))
{
RepositoryCommitted?.Invoke();
eventsProcessed++;
}
return(eventsProcessed);
}
internal WurmConfig(string gameSettingsFullPath, [NotNull] IPublicEventInvoker publicEventMarshaller,
[NotNull] TaskManager taskManager, IWurmApiLogger logger)
{
if (gameSettingsFullPath == null)
{
throw new ArgumentNullException(nameof(gameSettingsFullPath));
}
if (taskManager == null)
{
throw new ArgumentNullException(nameof(taskManager));
}
gameSettingsFileInfo = new FileInfo(gameSettingsFullPath);
if (gameSettingsFileInfo.Directory == null)
{
throw new WurmApiException("gameSettingsFileInfo.Directory is null, provided file raw path: "
+ gameSettingsFullPath);
}
Name = gameSettingsFileInfo.Directory.Name;
this.taskManager = taskManager;
onConfigChanged = publicEventMarshaller.Create(() => ConfigChanged.SafeInvoke(this, EventArgs.Empty),
WurmApiTuningParams.PublicEventMarshallerDelay);
configReader = new ConfigReader(this);
try
{
Refresh();
}
catch (Exception exception)
{
logger.Log(LogLevel.Error, "Error at initial config update: " + Name, this, exception);
}
configFileWatcher = new FileSystemWatcher(gameSettingsFileInfo.Directory.FullName)
{
Filter = gameSettingsFileInfo.Name,
NotifyFilter = NotifyFilters.Size | NotifyFilters.LastWrite
};
configFileWatcher.Changed += ConfigFileWatcherOnChanged;
configFileWatcher.Created += ConfigFileWatcherOnChanged;
configFileWatcher.Deleted += ConfigFileWatcherOnChanged;
configFileWatcher.Renamed += ConfigFileWatcherOnChanged;
configFileWatcher.EnableRaisingEvents = true;
taskHandle = new TaskHandle(Refresh, "WurmConfig update: " + Name);
taskManager.Add(taskHandle);
taskHandle.Trigger();
}
internal async Task UpdateConfiguration()
{
try
{
ConfigFilePath = (!File.Exists(ConfigFilePath) ? Path.Combine(AppContext.BaseDirectory, IPBanService.ConfigFileName) : ConfigFilePath);
string newXml = await ConfigReaderWriter.CheckForConfigChange();
if (!string.IsNullOrWhiteSpace(newXml))
{
IPBanConfig oldConfig = Config;
IPBanConfig newConfig = IPBanConfig.LoadFromXml(newXml, DnsLookup);
ConfigChanged?.Invoke(newConfig);
whitelistChanged = (Config is null || Config.Whitelist != newConfig.Whitelist || Config.WhitelistRegex != newConfig.WhitelistRegex);
Config = newConfig;
LoadFirewall(oldConfig);
ParseAndAddUriFirewallRules(newConfig);
Logger.Info("Config file changed");
}
}
catch (Exception ex)
{
Logger.Error(ex);
}
if (Config is null)
{
throw new ApplicationException("Configuration failed to load, make sure to check for XML errors or unblock all the files.");
}
if (Firewall is null)
{
throw new ApplicationException("Firewall failed to load, check that your firewall is enabled and setup in configuration properly");
}
// set or unset default banned ip address handler based on config
if (Config.UseDefaultBannedIPAddressHandler && BannedIPAddressHandler is null)
{
BannedIPAddressHandler = new DefaultBannedIPAddressHandler();
}
else if (!Config.UseDefaultBannedIPAddressHandler && BannedIPAddressHandler != null && BannedIPAddressHandler is DefaultBannedIPAddressHandler)
{
BannedIPAddressHandler = NullBannedIPAddressHandler.Instance;
}
// will only execute once
UpdateBannedIPAddressesOnStart();
// will only execute once
SetupWindowsEventViewer();
}
